Move PathToRopeCache to language, update documentation and language access

Author: bjfish

src/main/java/org/truffleruby/RubyContext.java

@@ -56,7 +56,6 @@
 import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.regexp.RegexpCacheKey;
 import org.truffleruby.core.rope.NativeRope;
-import org.truffleruby.core.rope.PathToRopeCache;
 import org.truffleruby.core.symbol.RubySymbol;
 import org.truffleruby.core.thread.ThreadManager;
 import org.truffleruby.core.time.GetTimeZoneNode;
@@ -121,7 +120,7 @@ public class RubyContext {
     private final ObjectSpaceManager objectSpaceManager = new ObjectSpaceManager();
     private final SharedObjects sharedObjects = new SharedObjects(this);
     private final AtExitManager atExitManager = new AtExitManager(this);
-    private final CallStackManager callStack = new CallStackManager(this);
+    private final CallStackManager callStack;
     private final CoreExceptions coreExceptions;
     private final EncodingManager encodingManager;
     private final MetricsProfiler metricsProfiler = new MetricsProfiler(this);
@@ -138,7 +137,6 @@ public class RubyContext {
     private final Hashing hashing;
     @CompilationFinal private BacktraceFormatter defaultBacktraceFormatter;
     private final BacktraceFormatter userBacktraceFormatter;
-    private final PathToRopeCache pathToRopeCache = new PathToRopeCache(this);
     @CompilationFinal private TruffleNFIPlatform truffleNFIPlatform;
     private final CoreLibrary coreLibrary;
     @CompilationFinal private CoreMethods coreMethods;
@@ -163,6 +161,7 @@ public RubyContext(RubyLanguage language, TruffleLanguage.Env env) {
 
         this.logger = env.getLogger("");
         this.language = language;
+        this.callStack = new CallStackManager(language, this);
         setEnv(env);
         this.preInitialized = preInitializing;
 
@@ -633,10 +632,6 @@ public CoverageManager getCoverageManager() {
         return coverageManager;
     }
 
-    public PathToRopeCache getPathToRopeCache() {
-        return pathToRopeCache;
-    }
-
     public CodeLoader getCodeLoader() {
         return codeLoader;
     }

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

@@ -58,6 +58,7 @@
 import org.truffleruby.core.range.RubyObjectRange;
 import org.truffleruby.core.regexp.RubyMatchData;
 import org.truffleruby.core.rope.CodeRange;
+import org.truffleruby.core.rope.PathToRopeCache;
 import org.truffleruby.core.rope.Rope;
 import org.truffleruby.core.rope.RopeCache;
 import org.truffleruby.core.string.CoreStrings;
@@ -170,6 +171,7 @@ public final class RubyLanguage extends TruffleLanguage<RubyContext> {
     @CompilationFinal private AllocationReporter allocationReporter;
 
     private final AtomicLong nextObjectID = new AtomicLong(ObjectSpaceManager.INITIAL_LANGUAGE_OBJECT_ID);
+    private final PathToRopeCache pathToRopeCache = new PathToRopeCache(this);
 
     private static final RubyObjectType objectType = new RubyObjectType();
 
@@ -285,7 +287,7 @@ public RubyContext createContext(Env env) {
             }
             if (this.options == null) {
                 this.options = new LanguageOptions(env, env.getOptions());
-                this.coreLoadPath = buildCoreLoadPath();
+                this.coreLoadPath = buildCoreLoadPath(this.options.CORE_LOAD_PATH);
                 this.corePath = coreLoadPath + File.separator + "core" + File.separator;
                 primitiveManager.loadCoreMethodNodes(this.options);
             }
@@ -474,6 +476,10 @@ public long getNextObjectID() {
         return id;
     }
 
+    public PathToRopeCache getPathToRopeCache() {
+        return pathToRopeCache;
+    }
+
     private static Shape createShape(Class<? extends RubyDynamicObject> layoutClass) {
         return Shape
                 .newBuilder()
@@ -489,7 +495,7 @@ protected boolean areOptionsCompatible(OptionValues firstOptions, OptionValues n
     }
 
     /** {@link RubyLanguage#getSourcePath(Source)} should be used instead whenever possible (i.e., when we can access
-     * the context).
+     * the language).
      *
      * Returns the path of a Source. Returns the short, potentially relative, path for the main script. Note however
      * that the path of {@code eval(code, nil, filename)} is just {@code filename} and might not be absolute. */
@@ -507,7 +513,7 @@ public static String getPath(Source source) {
 
     /** {@link RubyLanguage#getPath(Source)} but also handles core library sources. Ideally this method would be static
      * but for now the core load path is an option and it also depends on the current working directory. Once we have
-     * Source metadata in Truffle we could use that to identify core library sources without needing the context. */
+     * Source metadata in Truffle we could use that to identify core library sources without needing the language. */
     public String getSourcePath(Source source) {
         final String path = getPath(source);
         if (path.startsWith(coreLoadPath)) {
@@ -517,19 +523,18 @@ public String getSourcePath(Source source) {
         }
     }
 
-    private String buildCoreLoadPath() {
-        String path = options.CORE_LOAD_PATH;
+    private static String buildCoreLoadPath(String coreLoadPath) {
 
-        while (path.endsWith("/")) {
-            path = path.substring(0, path.length() - 1);
+        while (coreLoadPath.endsWith("/")) {
+            coreLoadPath = coreLoadPath.substring(0, coreLoadPath.length() - 1);
         }
 
-        if (path.startsWith(RubyLanguage.RESOURCE_SCHEME)) {
-            return path;
+        if (coreLoadPath.startsWith(RubyLanguage.RESOURCE_SCHEME)) {
+            return coreLoadPath;
         }
 
         try {
-            return new File(path).getCanonicalPath();
+            return new File(coreLoadPath).getCanonicalPath();
         } catch (IOException e) {
             throw CompilerDirectives.shouldNotReachHere(e);
         }

src/main/java/org/truffleruby/core/rope/PathToRopeCache.java

@@ -15,7 +15,6 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 import org.jcodings.specific.UTF8Encoding;
-import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.string.StringOperations;
 
@@ -26,17 +25,17 @@
  * Source is reachable. */
 public class PathToRopeCache {
 
-    private final RubyContext context;
+    private final RubyLanguage language;
     private final ReadWriteLock lock = new ReentrantReadWriteLock();
     private final WeakHashMap<String, Rope> javaStringToRope = new WeakHashMap<>();
 
-    public PathToRopeCache(RubyContext context) {
-        this.context = context;
+    public PathToRopeCache(RubyLanguage language) {
+        this.language = language;
     }
 
     @TruffleBoundary
     public Rope getCachedPath(Source source) {
-        final String path = context.getLanguageSlow().getSourcePath(source);
+        final String path = language.getSourcePath(source);
 
         final Lock readLock = lock.readLock();
         readLock.lock();
@@ -49,7 +48,7 @@ public Rope getCachedPath(Source source) {
             readLock.unlock();
         }
 
-        final Rope cachedRope = context.getLanguageSlow().ropeCache.getRope(
+        final Rope cachedRope = language.ropeCache.getRope(
                 StringOperations.encodeRope(path, UTF8Encoding.INSTANCE));
 
         final Lock writeLock = lock.writeLock();

src/main/java/org/truffleruby/core/thread/ThreadBacktraceLocationNodes.java

@@ -66,7 +66,7 @@ protected Object absolutePath(RubyBacktraceLocation threadBacktraceLocation,
                     return makeStringNode.fromRope(cachedRope);
                 } else { // eval()
                     return makeStringNode
-                            .fromRope(getContext().getPathToRopeCache().getCachedPath(source));
+                            .fromRope(getLanguage().getPathToRopeCache().getCachedPath(source));
                 }
             }
         }
@@ -85,7 +85,7 @@ protected RubyString path(RubyBacktraceLocation threadBacktraceLocation,
             if (sourceSection == null) {
                 return coreStrings().UNKNOWN.createInstance(getContext());
             } else {
-                final Rope path = getContext().getPathToRopeCache().getCachedPath(sourceSection.getSource());
+                final Rope path = getLanguage().getPathToRopeCache().getCachedPath(sourceSection.getSource());
                 return makeStringNode.fromRope(path);
             }
         }

src/main/java/org/truffleruby/core/tracepoint/TraceBaseEventNode.java

@@ -43,7 +43,8 @@ protected RubyString getFile() {
         if (file == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
             final Source source = eventContext.getInstrumentedSourceSection().getSource();
-            file = StringOperations.createString(context, language, context.getPathToRopeCache().getCachedPath(source));
+            file = StringOperations
+                    .createString(context, language, language.getPathToRopeCache().getCachedPath(source));
         }
         return file;
     }

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

@@ -13,6 +13,7 @@
 import java.util.function.Predicate;
 
 import org.truffleruby.RubyContext;
+import org.truffleruby.RubyLanguage;
 import org.truffleruby.SuppressFBWarnings;
 import org.truffleruby.collections.Memo;
 import org.truffleruby.core.array.ArrayUtils;
@@ -37,9 +38,11 @@
 
 public class CallStackManager {
 
+    private final RubyLanguage language;
     private final RubyContext context;
 
-    public CallStackManager(RubyContext context) {
+    public CallStackManager(RubyLanguage language, RubyContext context) {
+        this.language = language;
         this.context = context;
     }
 
@@ -102,7 +105,7 @@ public InternalMethod getCallingMethod() {
 
     @TruffleBoundary
     public SourceSection getTopMostUserSourceSection(SourceSection encapsulatingSourceSection) {
-        if (BacktraceFormatter.isUserSourceSection(context.getLanguageSlow(), encapsulatingSourceSection)) {
+        if (BacktraceFormatter.isUserSourceSection(language, encapsulatingSourceSection)) {
             return encapsulatingSourceSection;
         } else {
             return getTopMostUserSourceSection();

src/main/java/org/truffleruby/language/backtrace/BacktraceFormatter.java

@@ -85,9 +85,9 @@ public static String printableRubyBacktrace(Node node) {
     }
 
     /** For debug purposes. */
-    public static boolean isApplicationCode(RubyContext context, SourceSection sourceSection) {
-        return isUserSourceSection(context.getLanguageSlow(), sourceSection) &&
-                !context.getLanguageSlow().getSourcePath(sourceSection.getSource()).contains("/lib/stdlib/rubygems");
+    public static boolean isApplicationCode(RubyLanguage language, SourceSection sourceSection) {
+        return isUserSourceSection(language, sourceSection) &&
+                !language.getSourcePath(sourceSection.getSource()).contains("/lib/stdlib/rubygems");
     }
 
     public BacktraceFormatter(RubyContext context, RubyLanguage language, EnumSet<FormattingFlags> flags) {