Use the new inner context APIs

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:
 

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/main/java/org/truffleruby/interop/PolyglotNodes.java

@@ -19,6 +19,8 @@
 import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.builtins.Primitive;
 import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
+import org.truffleruby.core.array.ArrayOperations;
+import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.core.encoding.RubyEncoding;
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.proc.RubyProc;
@@ -170,14 +172,35 @@ public abstract static class InnerContextNewNode extends PrimitiveArrayArguments
 
         @TruffleBoundary
         @Specialization
-        protected RubyInnerContext newInnerContext(RubyClass rubyClass, RubyProc onCancelledCallback) {
-            final TruffleContext innerContext = getContext()
-                    .getEnv()
-                    .newContextBuilder()
-                    .onCancelled(() -> {
-                        CallBlockNode.getUncached().yield(onCancelledCallback);
-                    })
+        protected RubyInnerContext newInnerContext(
+                RubyClass rubyClass,
+                RubyArray languages,
+                RubyArray languageOptions,
+                boolean inheritAllAccess,
+                Object codeSharing,
+                RubyProc onCancelledCallback) {
+            String[] permittedLanguages = new String[languages.size];
+            int i = 0;
+            for (Object language : ArrayOperations.toIterable(languages)) {
+                permittedLanguages[i++] = RubyGuards.getJavaString(language);
+            }
+
+            var builder = getContext().getEnv().newInnerContextBuilder(permittedLanguages);
+
+            var iterator = ArrayOperations.toIterable(languageOptions).iterator();
+            while (iterator.hasNext()) {
+                Object key = iterator.next();
+                Object value = iterator.next();
+                builder.option(RubyGuards.getJavaString(key), RubyGuards.getJavaString(value));
+            }
+
+            Boolean codeSharingBoolean = codeSharing == nil ? null : (boolean) codeSharing;
+
+            final TruffleContext innerContext = builder
                     .initializeCreatorContext(false)
+                    .inheritAllAccess(inheritAllAccess)
+                    .forceSharing(codeSharingBoolean)
+                    .onCancelled(() -> CallBlockNode.getUncached().yield(onCancelledCallback))
                     .build();
 
             return new RubyInnerContext(

src/main/ruby/truffleruby/core/truffle/polyglot.rb

@@ -14,11 +14,18 @@ class UnsupportedMessageError < StandardError
   end
 
   class InnerContext
+    DEFAULT_ON_CANCELLED = -> { raise RuntimeError, 'Polyglot::InnerContext was terminated forcefully' }
+    private_constant :DEFAULT_ON_CANCELLED
+
     # Create a new isolated inner context to eval code in any available public language
     # (those languages can be listed with +Polyglot.languages+).
     # Automatically closes the context when given a block.
-    def self.new(on_cancelled: -> { raise RuntimeError, 'Polyglot::InnerContext was terminated forcefully' })
-      inner_context = Primitive.inner_context_new(self, on_cancelled)
+    def self.new(languages: [], language_options: {}, inherit_all_access: true, code_sharing: true, on_cancelled: DEFAULT_ON_CANCELLED)
+      languages = languages.map { |language| StringValue(language) }
+      language_options = language_options.flat_map { |k, v| [StringValue(k), StringValue(v)] }
+      code_sharing = code_sharing == :inherit ? nil : Primitive.as_boolean(code_sharing)
+
+      inner_context = Primitive.inner_context_new(self, languages, language_options, inherit_all_access, code_sharing, on_cancelled)
       if block_given?
         begin
           yield inner_context