Remove ParserCache

* Unfortunately it cannot work anymore because we need to find
  libyarpbindings.so to use the Prism parser but there is no way to
  locate it for the case of embedding truffleruby as a native image,
  while running in a static initializer. For example when using
  https://github.com/graalvm/polyglot-embedding-demo and building via Maven.
  In that case the resources/ direcotry is only created after the image is built,
  and also Class#getResourceAsStream() does not seem to work + would be messy.
* Going forward we likely want to cache the serialized bytes of core and
  maybe stdlib sources, on the filesystem or in a jar, by running some
  java process to do so while building TruffleRuby.
* This cache was only useful for native and when pre-initialization is
  not used, which is a narrow use case.

Author: eregon

src/main/java/META-INF/native-image/org.graalvm.ruby/resource-config.json

@@ -0,0 +1,8 @@
+{
+  "resources": {
+    "includes": [
+      { "pattern": "^truffleruby/core/.+\\.rb$" },
+      { "pattern": "^truffleruby/post-boot/.+\\.rb$" }
+    ]
+  }
+}

src/main/java/org/truffleruby/aot/ParserCache.java

@@ -29,7 +29,6 @@
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.annotations.CoreMethod;
 import org.truffleruby.annotations.SuppressFBWarnings;
-import org.truffleruby.aot.ParserCache;
 import org.truffleruby.builtins.BuiltinsClasses;
 import org.truffleruby.builtins.CoreMethodNodeManager;
 import org.truffleruby.core.array.RubyArray;
@@ -73,7 +72,6 @@
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.Truffle;
-import com.oracle.truffle.api.TruffleOptions;
 import com.oracle.truffle.api.object.DynamicObjectLibrary;
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.SourceSection;
@@ -785,12 +783,7 @@ public void loadRubyCoreLibraryAndPostBoot() {
 
     public RubySource loadCoreFileSource(String path) throws IOException {
         if (path.startsWith(RubyLanguage.RESOURCE_SCHEME)) {
-            if (TruffleOptions.AOT || ParserCache.INSTANCE != null) {
-                Source source = ParserCache.INSTANCE.get(path).getRight();
-                return new RubySource(source, path);
-            } else {
-                return new RubySource(ResourceLoader.loadResource(path, language.options.CORE_AS_INTERNAL), path);
-            }
+            return new RubySource(ResourceLoader.loadResource(path, language.options.CORE_AS_INTERNAL), path);
         } else {
             final FileLoader fileLoader = new FileLoader(context, language);
             return fileLoader.loadFile(path);

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

@@ -14,13 +14,10 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.Locale;
 
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
-import org.truffleruby.core.string.StringUtils;
 import org.truffleruby.shared.TruffleRuby;
 
 import com.oracle.truffle.api.source.Source;
@@ -38,12 +35,11 @@ public static Source loadResource(String path, boolean internal) throws IOExcept
         }
 
         final Class<?> relativeClass = RubyContext.class;
-        final Path relativePath = Paths.get(path.substring(RubyLanguage.RESOURCE_SCHEME.length()));
-        final String normalizedPath = StringUtils.replace(relativePath.normalize().toString(), '\\', '/');
-        final InputStream stream = relativeClass.getResourceAsStream(normalizedPath);
+        final String resourcePath = path.substring(RubyLanguage.RESOURCE_SCHEME.length());
+        final InputStream stream = relativeClass.getResourceAsStream(resourcePath);
 
         if (stream == null) {
-            throw new FileNotFoundException(path);
+            throw new FileNotFoundException(resourcePath);
         }
 
         final Source source;

src/main/java/org/truffleruby/language/loader/ResourceLoader.java

@@ -48,7 +48,6 @@
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.annotations.Split;
-import org.truffleruby.aot.ParserCache;
 import org.truffleruby.core.CoreLibrary;
 import org.truffleruby.core.DummyNode;
 import org.truffleruby.core.binding.BindingNodes;
@@ -158,22 +157,13 @@ public RootCallTarget parse(RubySource rubySource, ParserContext parserContext,
 
         final String sourcePath = rubySource.getSourcePath(language).intern();
 
-        // Only use the cache while loading top-level core library files, as eval() later could use
-        // the same Source name but should not use the cache. For instance,
-        // TOPLEVEL_BINDING.eval("self") would use the cache which is wrong.
-        final ParseResult parseResult;
-        if (ParserCache.INSTANCE != null && parserContext == ParserContext.TOP_LEVEL &&
-                ParserCache.INSTANCE.containsKey(source.getName())) {
-            parseResult = ParserCache.INSTANCE.get(source.getName()).getLeft();
-        } else {
-            printParseTranslateExecuteMetric("before-parsing", context, source);
-            parseResult = context.getMetricsProfiler().callWithMetrics(
-                    "parsing",
-                    source.getName(),
-                    () -> parseToYARPAST(rubySource, sourcePath, yarpSource, localsInScopes,
-                            language.options.FROZEN_STRING_LITERALS));
-            printParseTranslateExecuteMetric("after-parsing", context, source);
-        }
+        printParseTranslateExecuteMetric("before-parsing", context, source);
+        final ParseResult parseResult = context.getMetricsProfiler().callWithMetrics(
+                "parsing",
+                source.getName(),
+                () -> parseToYARPAST(rubySource, sourcePath, yarpSource, localsInScopes,
+                        language.options.FROZEN_STRING_LITERALS));
+        printParseTranslateExecuteMetric("after-parsing", context, source);
 
         handleWarningsErrorsPrimitives(context, parseResult, rubySource, sourcePath, parseEnvironment, rubyWarnings);
 
@@ -458,20 +448,6 @@ public static void handleWarningsErrorsPrimitives(RubyContext context, ParseResu
         parseEnvironment.allowTruffleRubyPrimitives = allowTruffleRubyPrimitives;
     }
 
-    public static void handleWarningsErrorsNoContext(ParseResult parseResult, String sourcePath,
-            Nodes.Source yarpSource) {
-        if (parseResult.errors.length > 0) {
-            var error = parseResult.errors[0];
-            throw CompilerDirectives.shouldNotReachHere("Parse error in " +
-                    sourcePath + ":" + yarpSource.line(error.location.startOffset) + ": " + error.message);
-        }
-
-        for (var warning : parseResult.warnings) {
-            throw CompilerDirectives.shouldNotReachHere("Warning in " +
-                    sourcePath + ":" + yarpSource.line(warning.location.startOffset) + ": " + warning.message);
-        }
-    }
-
     public static Nodes.Source createYARPSource(byte[] sourceBytes) {
         return new Nodes.Source(sourceBytes);
     }