Rename class FrozenStringLiterals to ImmutableStrings

Author: andrykonchin

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

@@ -87,10 +87,10 @@
 import org.truffleruby.core.regexp.RegexpTable;
 import org.truffleruby.core.regexp.RubyMatchData;
 import org.truffleruby.core.regexp.RubyRegexp;
+import org.truffleruby.core.string.ImmutableStrings;
 import org.truffleruby.core.string.PathToTStringCache;
 import org.truffleruby.core.string.TStringCache;
 import org.truffleruby.core.string.CoreStrings;
-import org.truffleruby.core.string.FrozenStringLiterals;
 import org.truffleruby.core.string.RubyString;
 import org.truffleruby.core.string.StringUtils;
 import org.truffleruby.core.string.TStringWithEncoding;
@@ -272,7 +272,7 @@ private RubyThread getOrCreateForeignThread(RubyContext context, Thread thread)
     public final RegexpTable regexpTable;
     public final SymbolTable symbolTable;
     public final KeywordArgumentsDescriptorManager keywordArgumentsDescriptorManager = new KeywordArgumentsDescriptorManager();
-    public final FrozenStringLiterals frozenStringLiterals;
+    public final ImmutableStrings immutableStrings;
 
     // GR-44025: We store the cleanerThread explicitly here to make it a clear image building failure if it would still be set.
     public Thread cleanerThread = null;
@@ -385,7 +385,7 @@ public RubyLanguage() {
         tstringCache = new TStringCache(coreSymbols);
         symbolTable = new SymbolTable(tstringCache, coreSymbols);
         regexpTable = new RegexpTable();
-        frozenStringLiterals = new FrozenStringLiterals(tstringCache);
+        immutableStrings = new ImmutableStrings(tstringCache);
     }
 
     public RubyThread getCurrentThread() {
@@ -878,12 +878,12 @@ public AllocationReporter getAllocationReporter() {
     }
 
     public ImmutableRubyString getFrozenStringLiteral(TruffleString tstring, RubyEncoding encoding) {
-        return frozenStringLiterals.getFrozenStringLiteral(tstring, encoding);
+        return immutableStrings.getFrozenStringLiteral(tstring, encoding);
     }
 
     public ImmutableRubyString getFrozenStringLiteral(InternalByteArray byteArray, boolean isImmutable,
             RubyEncoding encoding) {
-        return frozenStringLiterals.getFrozenStringLiteral(byteArray, isImmutable, encoding);
+        return immutableStrings.getFrozenStringLiteral(byteArray, isImmutable, encoding);
     }
 
     public long getNextObjectID() {

src/main/java/org/truffleruby/core/encoding/Encodings.java

@@ -28,7 +28,7 @@
 import org.graalvm.shadowed.org.jcodings.specific.UTF32LEEncoding;
 import org.graalvm.shadowed.org.jcodings.specific.UTF8Encoding;
 import org.truffleruby.RubyLanguage;
-import org.truffleruby.core.string.FrozenStringLiterals;
+import org.truffleruby.core.string.ImmutableStrings;
 import org.truffleruby.core.string.ImmutableRubyString;
 import org.truffleruby.core.string.StringOperations;
 import org.truffleruby.core.string.TStringConstants;
@@ -113,7 +113,7 @@ private static RubyEncoding[] initializeRubyEncodings() {
                 if (tstring == null) {
                     throw CompilerDirectives.shouldNotReachHere("no TStringConstants for " + encoding);
                 }
-                final ImmutableRubyString name = FrozenStringLiterals.createStringAndCacheLater(tstring, US_ASCII);
+                final ImmutableRubyString name = ImmutableStrings.createStringAndCacheLater(tstring, US_ASCII);
                 rubyEncoding = new RubyEncoding(encoding, name, index);
             }
             encodings[index] = rubyEncoding;

src/main/java/org/truffleruby/core/encoding/RubyEncoding.java

@@ -21,7 +21,7 @@
 import org.truffleruby.RubyContext;
 import org.truffleruby.core.kernel.KernelNodes;
 import org.truffleruby.core.klass.RubyClass;
-import org.truffleruby.core.string.FrozenStringLiterals;
+import org.truffleruby.core.string.ImmutableStrings;
 import org.truffleruby.core.string.ImmutableRubyString;
 import org.truffleruby.language.ImmutableRubyObjectNotCopyable;
 import org.truffleruby.core.string.TStringConstants;
@@ -79,7 +79,7 @@ public RubyEncoding(int index) {
         this.jcoding = Objects.requireNonNull(USASCIIEncoding.INSTANCE);
         this.tencoding = Objects.requireNonNull(TruffleString.Encoding.US_ASCII);
         this.name = Objects.requireNonNull(
-                FrozenStringLiterals.createStringAndCacheLater(TStringConstants.US_ASCII, this));
+                ImmutableStrings.createStringAndCacheLater(TStringConstants.US_ASCII, this));
         this.index = index;
 
         var jcoding = this.jcoding;

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

@@ -21,7 +21,7 @@ public final class FrozenStrings {
 
     static final List<TruffleString> TSTRINGS = new ArrayList<>();
 
-    public static final ImmutableRubyString EMPTY_US_ASCII = FrozenStringLiterals.createStringAndCacheLater(
+    public static final ImmutableRubyString EMPTY_US_ASCII = ImmutableStrings.createStringAndCacheLater(
             TStringConstants.EMPTY_US_ASCII,
             Encodings.US_ASCII);
 
@@ -50,7 +50,7 @@ private static ImmutableRubyString createFrozenStaticString(String string, RubyE
         // defined?(...) returns frozen strings with a binary encoding
         var tstring = TStringUtils.fromJavaString(string, encoding);
         TSTRINGS.add(tstring);
-        return FrozenStringLiterals.createStringAndCacheLater(tstring, encoding);
+        return ImmutableStrings.createStringAndCacheLater(tstring, encoding);
     }
 
 }

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

@@ -44,7 +44,7 @@
 import java.util.Objects;
 
 /** All ImmutableRubyString are interned and must be created through
- * {@link FrozenStringLiterals#getFrozenStringLiteral}. */
+ * {@link ImmutableStrings#getFrozenStringLiteral}. */
 @ExportLibrary(InteropLibrary.class)
 public final class ImmutableRubyString extends ImmutableRubyObjectCopyable
         implements TruffleObject, DetailedInspectingSupport {

src/main/java/org/truffleruby/core/string/FrozenStringLiterals.java renamed to src/main/java/org/truffleruby/core/string/ImmutableStrings.java

@@ -21,15 +21,14 @@
 import java.util.Collection;
 import java.util.List;
 
-// TODO: should rename to ImmutableStrings
-public final class FrozenStringLiterals {
+public final class ImmutableStrings {
 
     private static final List<ImmutableRubyString> STRINGS_TO_CACHE = new ArrayList<>();
 
     private final TStringCache tstringCache;
     private final WeakValueCache<TStringWithEncoding, ImmutableRubyString> values = new WeakValueCache<>();
 
-    public FrozenStringLiterals(TStringCache tStringCache) {
+    public ImmutableStrings(TStringCache tStringCache) {
         this.tstringCache = tStringCache;
         for (ImmutableRubyString name : STRINGS_TO_CACHE) {
             addFrozenStringToCache(name);
@@ -89,7 +88,7 @@ private void addFrozenStringToCache(ImmutableRubyString string) {
         final ImmutableRubyString existing = values.addInCacheIfAbsent(tstringWithEncoding, string);
         if (existing != string) {
             throw CompilerDirectives
-                    .shouldNotReachHere("Duplicate ImmutableRubyString in FrozenStringLiterals: " + existing);
+                    .shouldNotReachHere("Duplicate ImmutableRubyString in ImmutableStrings: " + existing);
         }
     }
 

src/main/java/org/truffleruby/language/objects/ObjectGraph.java

@@ -115,7 +115,7 @@ public void run(RubyThread rubyThread, Node currentNode) {
     public static void visitContextRoots(RubyContext context, Set<Object> roots) {
         final RubyLanguage language = context.getLanguageSlow();
         roots.addAll(language.symbolTable.allSymbols());
-        roots.addAll(language.frozenStringLiterals.allFrozenStrings());
+        roots.addAll(language.immutableStrings.allFrozenStrings());
 
         // We do not want to expose the global object
         roots.addAll(context.getCoreLibrary().globalVariables.objectGraphValues());

src/main/java/org/truffleruby/parser/YARPTranslator.java

@@ -3253,7 +3253,7 @@ public RubyNode visitStringNode(Nodes.StringNode node) {
             final TruffleString cachedTString = language.tstringCache.getTString(bytes, encoding);
             rubyNode = new StringLiteralNode(cachedTString, encoding);
         } else {
-            ImmutableRubyString frozenString = language.frozenStringLiterals.getFrozenStringLiteral(bytes, encoding);
+            ImmutableRubyString frozenString = language.immutableStrings.getFrozenStringLiteral(bytes, encoding);
             rubyNode = new FrozenStringLiteralNode(frozenString, FrozenStrings.EXPRESSION);
         }