[GR-18411] Update graal import and adopt new APIs

PullRequest: truffleruby/3475

Author: eregon

CHANGELOG.md

@@ -6,6 +6,7 @@ New features:
 * Add `Java.add_to_classpath` method to add jar paths at runtime (#2693, @bjfish).
 * Add support for Ruby 3.1's Hash shorthand/punning syntax (@nirvdrum).
 * Add support for Ruby 3.1's anonymous block forwarding syntax (@nirvdrum).
+* Added the following keyword arguments to `Polyglot::InnerContext.new`: `languages, language_options, inherit_all_access, code_sharing` (@eregon).
 
 Bug fixes:
 

common.json

@@ -30,8 +30,10 @@
   "devkits": {
     "windows-jdk11":      { "packages" : { "devkit:VS2017-15.9.24+1" : "==0" }},
     "windows-jdk17":      { "packages" : { "devkit:VS2019-16.9.3+1"  : "==0" }},
+    "windows-jdk19":      { "packages" : { "devkit:VS2022-17.1.0+1"  : "==0" }},
     "linux-jdk11":      { "packages" : { "devkit:gcc7.3.0-OEL6.4+1"  : "==1" }},
-    "linux-jdk17":      { "packages" : { "devkit:gcc10.3.0-OL6.4+1"  : "==0" }}
+    "linux-jdk17":      { "packages" : { "devkit:gcc10.3.0-OL6.4+1"  : "==0" }},
+    "linux-jdk19":      { "packages" : { "devkit:gcc11.2.0-OL6.4+1"  : "==0" }}
   },
 
   "catch_files" : [

lib/mri/monitor.rb

@@ -217,6 +217,7 @@ def mon_owned?
   def mon_synchronize(&block)
     Primitive.monitor_synchronize(@mon_mutex, block)
   end
+  Truffle::Graal.always_split instance_method(:mon_synchronize)
   alias synchronize mon_synchronize
 
   #

lib/truffle/truffle/cext.rb

@@ -12,6 +12,8 @@
 require_relative 'cext_constants'
 require_relative 'cext_structs'
 
+# TODO (eregon, 1 Sep 2022): should we always_split or use separate CallTargets for usages of Primitive.call_with* in this file?
+
 module Truffle::CExt
   DATA_TYPE = Primitive.object_hidden_var_create :data_type
   DATA_HOLDER = Primitive.object_hidden_var_create :data_holder
@@ -981,6 +983,7 @@ def rb_hash_foreach(hash, func, farg)
       end
     end
   end
+  Truffle::Graal.always_split instance_method(:rb_hash_foreach)
 
   def rb_path_to_class(path)
     begin
@@ -1049,6 +1052,7 @@ def rb_protect(function, arg, write_status, status)
     Truffle::Interop.execute_without_conversion(write_status, status, pos)
     res
   end
+  Truffle::Graal.always_split instance_method(:rb_protect)
 
   def rb_jump_tag(pos)
     if pos > 0
@@ -1062,10 +1066,12 @@ def rb_jump_tag(pos)
   def rb_yield(value)
     Primitive.interop_execute(rb_block_proc, [value])
   end
+  Truffle::Graal.always_split instance_method(:rb_yield)
 
   def rb_yield_splat(values)
     Primitive.interop_execute(rb_block_proc, values)
   end
+  Truffle::Graal.always_split instance_method(:rb_yield_splat)
 
   def rb_ivar_lookup(object, name, default_value)
     # TODO CS 24-Jul-16 races - needs a new primitive or be defined in Java?
@@ -1394,6 +1400,7 @@ def rb_mutex_synchronize(mutex, func, arg)
       Primitive.cext_unwrap(Primitive.interop_execute(func, [Primitive.cext_wrap(arg)]))
     end
   end
+  Truffle::Graal.always_split instance_method(:rb_mutex_synchronize)
 
   def rb_gc_enable
     GC.enable
@@ -1545,6 +1552,7 @@ def rb_ensure(b_proc, data1, e_proc, data2)
       Primitive.interop_execute(e_proc, [data2])
     end
   end
+  Truffle::Graal.always_split instance_method(:rb_ensure)
 
   def rb_rescue(b_proc, data1, r_proc, data2)
     begin
@@ -1557,6 +1565,7 @@ def rb_rescue(b_proc, data1, r_proc, data2)
       end
     end
   end
+  Truffle::Graal.always_split instance_method(:rb_rescue)
 
   def rb_rescue2(b_proc, data1, r_proc, data2, rescued)
     begin
@@ -1565,6 +1574,7 @@ def rb_rescue2(b_proc, data1, r_proc, data2, rescued)
       Primitive.interop_execute(r_proc, [data2, Primitive.cext_wrap(e)])
     end
   end
+  Truffle::Graal.always_split instance_method(:rb_rescue2)
 
   def rb_exec_recursive(func, obj, arg)
     result = nil
@@ -1579,6 +1589,7 @@ def rb_exec_recursive(func, obj, arg)
       result
     end
   end
+  Truffle::Graal.always_split instance_method(:rb_exec_recursive)
 
   def rb_catch_obj(tag, func, data)
     catch tag do |caught|

mx.truffleruby/suite.py

@@ -7,7 +7,7 @@
             {
                 "name": "regex",
                 "subdir": True,
-                "version": "f9726d7f20f5fce7b26578886a01e3750807d5d6",
+                "version": "1fd25b8c637ea052ff7bea8dcbd5a779f5240833",
                 "urls": [
                     {"url": "https://github.com/oracle/graal.git", "kind": "git"},
                     {"url": "https://curio.ssw.jku.at/nexus/content/repositories/snapshots", "kind": "binary"},
@@ -16,7 +16,7 @@
             {
                 "name": "sulong",
                 "subdir": True,
-                "version": "f9726d7f20f5fce7b26578886a01e3750807d5d6",
+                "version": "1fd25b8c637ea052ff7bea8dcbd5a779f5240833",
                 "urls": [
                     {"url": "https://github.com/oracle/graal.git", "kind": "git"},
                     {"url": "https://curio.ssw.jku.at/nexus/content/repositories/snapshots", "kind": "binary"},

spec/truffle/interop/polyglot/inner_context_spec.rb

@@ -23,6 +23,24 @@
     end
   end
 
+  it "can specify languages explicitly" do
+    Polyglot::InnerContext.new(languages: ['ruby']) do |context|
+      context.eval('ruby', '6 * 7').should == 42
+    end
+  end
+
+  it "can specify language options" do
+    Polyglot::InnerContext.new(language_options: { 'ruby.debug' => 'true' }) do |context|
+      context.eval('ruby', '$DEBUG').should == true
+    end
+  end
+
+  it "can specify whether to inherit access" do
+    Polyglot::InnerContext.new(inherit_all_access: false, language_options: { 'ruby.core-load-path' => 'resource:/truffleruby' }) do |context|
+      context.eval('ruby', 'Truffle::POSIX::NATIVE').should == false
+    end
+  end
+
   it "treats Ruby objects from the inner context as foreign" do
     Polyglot::InnerContext.new do |context|
       obj = context.eval('ruby', "Object.new")

src/annotations/java/org/truffleruby/builtins/CoreMethod.java

@@ -51,6 +51,13 @@
      * RubyHash, and the arguments descriptor will tell if it was kwargs or positional, as always. */
     boolean rest() default false;
 
+    /** Passes the optional block as an argument to the node. Also causes {@link Split#DEFAULT} to be resolved to
+     * {@link Split#ALWAYS}, unless {@link #split()} is set to a non-default value, since if a block is passed and the
+     * block is called it is necessary to split for the best performance. Splitting eagerly instead of lazily via the
+     * heuristic avoids an extra copy and works better with {@code RubyRootNode#getParentFrameDescriptor()} when the
+     * possible loop in this core method does many iterations on the first method call as it then preserves the
+     * single-caller chain from the beginning, instead of breaking it until split and executed again for the first and
+     * second call sites. {@link Split#NEVER} should be used if this method never calls the block but just stores it. */
     boolean needsBlock() default false;
 
     /** Try to lower argument <code>i</code> (starting at 0) to an int if its value is a long. The 0 is reserved for
@@ -73,6 +80,6 @@
     /** Use these names in Ruby core methods stubs, ignore argument names in Java specializations. */
     String[] argumentNames() default {};
 
-    Split split() default Split.HEURISTIC;
+    Split split() default Split.DEFAULT;
 
 }

src/annotations/java/org/truffleruby/language/methods/Split.java

@@ -10,6 +10,8 @@
 package org.truffleruby.language.methods;
 
 public enum Split {
+    /** Special value for the CoreMethod annotation, resolved to either HEURISTIC or ALWAYS, based on needsBlock */
+    DEFAULT,
     ALWAYS,
     HEURISTIC,
     /** Disallow splitting for this CallTarget, which avoids making a eager uninitialized copy of the AST. Useful

src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java

@@ -121,6 +121,16 @@ private RubyClass getSingletonClass(Object object) {
         return SingletonClassNode.getUncached().executeSingletonClass(object);
     }
 
+    private Split effectiveSplit(Split split, boolean needsBlock) {
+        if (context.getOptions().CORE_ALWAYS_CLONE) {
+            return Split.ALWAYS;
+        } else if (split == Split.DEFAULT) {
+            return needsBlock ? Split.ALWAYS : Split.HEURISTIC;
+        } else {
+            return split;
+        }
+    }
+
     private void addCoreMethod(RubyModule module, MethodDetails methodDetails) {
         final CoreMethod annotation = methodDetails.getMethodAnnotation();
 
@@ -134,7 +144,7 @@ private void addCoreMethod(RubyModule module, MethodDetails methodDetails) {
         final NodeFactory<? extends RubyBaseNode> nodeFactory = methodDetails.getNodeFactory();
         final boolean onSingleton = annotation.onSingleton() || annotation.constructor();
         final boolean isModuleFunc = annotation.isModuleFunction();
-        final Split split = context.getOptions().CORE_ALWAYS_CLONE ? Split.ALWAYS : annotation.split();
+        final Split split = effectiveSplit(annotation.split(), annotation.needsBlock());
 
         final Function<SharedMethodInfo, RootCallTarget> callTargetFactory = sharedMethodInfo -> {
             return createCoreMethodRootNode(nodeFactory, language, sharedMethodInfo, split, annotation);
@@ -164,6 +174,7 @@ public void addLazyCoreMethod(
             int required,
             int optional,
             boolean rest,
+            boolean needsBlock,
             String... names) {
 
         final RubyModule module = getModule(moduleName, isClass);
@@ -172,7 +183,7 @@ public void addLazyCoreMethod(
         if (alwaysInlined) {
             finalSplit = Split.NEVER;
         } else {
-            finalSplit = context.getOptions().CORE_ALWAYS_CLONE ? Split.ALWAYS : split;
+            finalSplit = effectiveSplit(split, needsBlock);
         }
 
         final Function<SharedMethodInfo, RootCallTarget> callTargetFactory = sharedMethodInfo -> {
@@ -329,7 +340,7 @@ public RootCallTarget createCoreMethodRootNode(NodeFactory<? extends RubyBaseNod
 
             if (method.lowerFixnum().length > 0 || method.raiseIfFrozenSelf() || method.raiseIfNotMutableSelf() ||
                     method.returnsEnumeratorIfNoBlock() || !method.enumeratorSize().isEmpty() ||
-                    method.split() != Split.HEURISTIC) {
+                    method.split() != Split.DEFAULT) {
                 throw new Error("Always-inlined methods do not support all @CoreMethod attributes for " + nodeClass);
             }
 

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

@@ -662,7 +662,6 @@ protected RubyArray concatManyGeneral(RubyArray array, Object first, Object[] re
 
     @CoreMethod(names = "delete", required = 1, needsBlock = true)
     @ImportStatic(ArrayGuards.class)
-    @ReportPolymorphism
     public abstract static class DeleteNode extends YieldingCoreMethodNode {
 
         @Child private SameOrEqualNode sameOrEqualNode = SameOrEqualNode.create();
@@ -823,7 +822,6 @@ protected Object deleteAtCopying(RubyArray array, int index,
 
     @CoreMethod(names = "each", needsBlock = true, enumeratorSize = "size")
     @ImportStatic(ArrayGuards.class)
-    @ReportPolymorphism
     public abstract static class EachNode extends YieldingCoreMethodNode implements ArrayElementConsumerNode {
 
         @Specialization
@@ -841,7 +839,6 @@ public void accept(RubyArray array, RubyProc block, Object element, int index) {
 
     @Primitive(name = "array_each_with_index")
     @ImportStatic(ArrayGuards.class)
-    @ReportPolymorphism
     public abstract static class EachWithIndexNode extends PrimitiveArrayArgumentsNode
             implements ArrayElementConsumerNode {
 
@@ -1007,7 +1004,6 @@ protected Object eqlNotArray(RubyArray a, Object b) {
     }
 
     @CoreMethod(names = "fill", rest = true, needsBlock = true, raiseIfFrozenSelf = true)
-    @ReportPolymorphism
     public abstract static class FillNode extends ArrayCoreMethodNode {
 
         @Specialization(
@@ -1333,21 +1329,18 @@ protected RubyArray initializeCopy(RubyArray self, RubyArray from,
 
     @Primitive(name = "array_inject")
     @ImportStatic(ArrayGuards.class)
-    @ReportPolymorphism
     public abstract static class InjectNode extends YieldingCoreMethodNode {
 
         @Child private DispatchNode dispatch = DispatchNode.create(PUBLIC);
 
         // Uses block
 
         @Specialization(guards = { "isEmptyArray(array)", "wasProvided(initialOrSymbol)" })
-        @ReportPolymorphism.Exclude
         protected Object injectEmptyArray(RubyArray array, Object initialOrSymbol, NotProvided symbol, RubyProc block) {
             return initialOrSymbol;
         }
 
         @Specialization(guards = { "isEmptyArray(array)" })
-        @ReportPolymorphism.Exclude
         protected Object injectEmptyArrayNoInitial(
                 RubyArray array, NotProvided initialOrSymbol, NotProvided symbol, RubyProc block) {
             return nil;
@@ -1486,7 +1479,6 @@ public Object injectSymbolHelper(VirtualFrame frame, RubyArray array, String sym
 
     @CoreMethod(names = { "map", "collect" }, needsBlock = true, enumeratorSize = "size")
     @ImportStatic(ArrayGuards.class)
-    @ReportPolymorphism
     public abstract static class MapNode extends YieldingCoreMethodNode {
 
         @Specialization(limit = "storageStrategyLimit()")
@@ -1759,7 +1751,6 @@ protected RubyArray pushMany(VirtualFrame frame, RubyArray array, Object value,
 
     @CoreMethod(names = "reject", needsBlock = true, enumeratorSize = "size")
     @ImportStatic(ArrayGuards.class)
-    @ReportPolymorphism
     public abstract static class RejectNode extends YieldingCoreMethodNode {
 
         @Specialization(limit = "storageStrategyLimit()")
@@ -1794,7 +1785,6 @@ protected Object reject(RubyArray array, RubyProc block,
 
     @CoreMethod(names = "reject!", needsBlock = true, enumeratorSize = "size", raiseIfFrozenSelf = true)
     @ImportStatic(ArrayGuards.class)
-    @ReportPolymorphism
     public abstract static class RejectInPlaceNode extends YieldingCoreMethodNode {
 
         @Child private BooleanCastNode booleanCastNode = BooleanCastNode.create();
@@ -2050,7 +2040,6 @@ private void reverse(ArrayStoreLibrary stores,
 
     @CoreMethod(names = { "select", "filter" }, needsBlock = true, enumeratorSize = "size")
     @ImportStatic(ArrayGuards.class)
-    @ReportPolymorphism
     public abstract static class SelectNode extends YieldingCoreMethodNode {
 
         @Specialization(limit = "storageStrategyLimit()")
@@ -2161,11 +2150,9 @@ protected int size(RubyArray array,
 
     @CoreMethod(names = "sort", needsBlock = true)
     @ImportStatic(ArrayGuards.class)
-    @ReportPolymorphism
     public abstract static class SortNode extends ArrayCoreMethodNode {
 
         @Specialization(guards = "isEmptyArray(array)")
-        @ReportPolymorphism.Exclude
         protected RubyArray sortEmpty(RubyArray array, Object unusedBlock) {
             return createEmptyArray();
         }