[GR-15916] Interactive sources should share the same binding.

PullRequest: truffleruby/885

Author: eregon

CHANGELOG.md

@@ -14,6 +14,10 @@ Compatibility:
 * Implement more `Ripper` methods as no-ops (#1694).
 * Implemented `rb_enc_sprintf` (#1702).
 
+Changes:
+
+* Interactive sources (like the GraalVM polyglot shell) now all share the same binding (#1695).
+
 # 20.0.0 beta 1
 
 Bug fixes:

doc/user/polyglot.md

@@ -12,6 +12,7 @@ If you are using the native configuration, you will need to use the `--polyglot`
 flag to get access to other languages. The JVM configuration automatically has
 access to other languages.
 
+* [Running Ruby code from another language](#running-ruby-code-from-another-language)
 * [Loading code written in foreign languages](#loading-code-written-in-foreign-languages)
 * [Exporting Ruby objects to foreign languages](#exporting-ruby-objects-to-foreign-languages)
 * [Importing foreign objects to Ruby](#importing-foreign-objects-to-ruby)
@@ -22,6 +23,17 @@ access to other languages.
 * [Threading and interop](#threading-and-interop)
 * [Embedded configuration](#embedded-configuration)
 
+## Running Ruby code from another language
+
+When you `eval` Ruby code from the [Context API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/Context.html)
+in another language and mark the `Source` as interactive, the same interactive
+top-level binding is used each time. This means that if you set a local variable
+in one `eval`, you will be able to use it from the next.
+
+The semantics are the same as the Ruby semantics of calling
+`INTERACTIVE_BINDING.eval(code)` for every `Context.eval()` call with an
+interactive `Source`. This is similar to most REPL semantics.
+
 ## Loading code written in foreign languages
 
 `Polyglot.eval(id, string)` executes code in a foreign language identified by

src/launcher/java/org/truffleruby/launcher/RubyLauncher.java

@@ -203,11 +203,13 @@ private int runRubyMain(Context.Builder contextBuilder, CommandLineOptions confi
             Metrics.printTime("before-run");
 
             if (config.executionAction == ExecutionAction.PATH) {
-                String path = context.eval(TruffleRuby.LANGUAGE_ID,
+                final Source source = Source.newBuilder(TruffleRuby.LANGUAGE_ID,
                         // language=ruby
-                        "-> name { Truffle::Boot.find_s_file(name) }").execute(config.toExecute).asString();
+                        "-> name { Truffle::Boot.find_s_file(name) }",
+                        TruffleRuby.BOOT_SOURCE_NAME).internal(true).buildLiteral();
+
                 config.executionAction = ExecutionAction.FILE;
-                config.toExecute = path;
+                config.toExecute = context.eval(source).execute(config.toExecute).asString();
             }
 
             final Source source = Source.newBuilder(TruffleRuby.LANGUAGE_ID,

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

@@ -64,7 +64,13 @@ public Object execute(VirtualFrame frame) {
 
             // We use the current frame as the lexical scope to parse, but then we may run with a new frame in the future
 
-            final RubyRootNode rootNode = translator.parse(new RubySource(source), ParserContext.INLINE, null, currentFrame, false, null);
+            final RubyRootNode rootNode = translator.parse(
+                    new RubySource(source),
+                    ParserContext.INLINE,
+                    null,
+                    currentFrame,
+                    false,
+                    null);
 
             final RootCallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
 

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

@@ -19,8 +19,12 @@
 import com.oracle.truffle.api.nodes.DirectCallNode;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.Source;
+import org.jcodings.specific.UTF8Encoding;
+import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
+import org.truffleruby.core.rope.Rope;
+import org.truffleruby.core.string.StringOperations;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.backtrace.InternalRootNode;
 import org.truffleruby.language.methods.DeclarationContext;
@@ -36,8 +40,10 @@ public class RubyParsingRequestNode extends RubyBaseRootNode implements Internal
 
     private final TruffleLanguage.ContextReference<RubyContext> contextReference;
     private final Source source;
+    private final boolean interactive;
     private final String[] argumentNames;
 
+    @CompilationFinal private Rope sourceRope;
     @CompilationFinal private RubyContext cachedContext;
     @CompilationFinal private DynamicObject mainObject;
     @CompilationFinal private InternalMethod method;
@@ -46,8 +52,9 @@ public class RubyParsingRequestNode extends RubyBaseRootNode implements Internal
 
     public RubyParsingRequestNode(RubyLanguage language, Source source, String[] argumentNames) {
         super(language, null, null);
-        contextReference = language.getContextReference();
+        this.contextReference = language.getContextReference();
         this.source = source;
+        this.interactive = source.isInteractive();
         this.argumentNames = argumentNames;
     }
 
@@ -56,6 +63,19 @@ public Object execute(VirtualFrame frame) {
         printTimeMetric("before-script");
         final RubyContext context = contextReference.get();
 
+        if (interactive) {
+            if (sourceRope == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                sourceRope = StringOperations.encodeRope(source.getCharacters().toString(), UTF8Encoding.INSTANCE);
+            }
+
+            // Just do Truffle::Boot.INTERACTIVE_BINDING.eval(code) for interactive sources.
+            // It's the semantics we want and takes care of caching correctly based on the Binding's FrameDescriptor.
+            final Object interactiveBinding = Layouts.MODULE.getFields(context.getCoreLibrary().getTruffleBootModule())
+                    .getConstant("INTERACTIVE_BINDING").getValue();
+            return context.send(interactiveBinding, "eval", StringOperations.createString(context, sourceRope));
+        }
+
         if (cachedContext == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
             cachedContext = context;
@@ -66,7 +86,13 @@ public Object execute(VirtualFrame frame) {
 
             final TranslatorDriver translator = new TranslatorDriver(context);
 
-            final RubyRootNode rootNode = translator.parse(new RubySource(source), ParserContext.TOP_LEVEL, argumentNames, null, true, null);
+            final RubyRootNode rootNode = translator.parse(
+                    new RubySource(source),
+                    ParserContext.TOP_LEVEL,
+                    argumentNames,
+                    null,
+                    true,
+                    null);
 
             final RootCallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
 
@@ -80,15 +106,14 @@ public Object execute(VirtualFrame frame) {
                     sharedMethodInfo.getName(), context.getCoreLibrary().getObjectClass(), Visibility.PUBLIC, callTarget);
         }
 
-        Object[] arguments = RubyArguments.pack(
+        final Object value = callNode.call(RubyArguments.pack(
                 null,
                 null,
                 method,
                 null,
                 mainObject,
                 null,
-                frame.getArguments());
-        final Object value = callNode.call(arguments);
+                frame.getArguments()));
 
         // The return value will be leaked to Java, so share it if the Context API is used.
         // We share conditionally on EMBEDDED to avoid sharing return values used in RubyLauncher.

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

@@ -96,7 +96,6 @@ public TranslatorDriver(RubyContext context) {
 
     public RubyRootNode parse(RubySource rubySource, ParserContext parserContext, String[] argumentNames,
                               MaterializedFrame parentFrame, boolean ownScopeForAssignments, Node currentNode) {
-
         assert parserContext.isTopLevel() == (parentFrame == null) : "A frame should be given iff the context is not toplevel: " + parserContext + " " + parentFrame;
 
         final Source source = rubySource.getSource();

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

@@ -12,6 +12,9 @@
 # as the TOPLEVEL_BINDING should be empty until the main script is executed.
 TOPLEVEL_BINDING = binding
 
+# The Binding used for sharing top-level locals of interactive Sources
+Truffle::Boot::INTERACTIVE_BINDING = binding
+
 module Truffle::Boot
 
   def self.check_syntax(source_or_file)

src/test/java/org/truffleruby/PolyglotInteropTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved. This
+ * Copyright (c) 2018, 2019 Oracle and/or its affiliates. All rights reserved. This
  * code is released under a tri EPL/GPL/LGPL license. You can use it,
  * redistribute it and/or modify it under the terms of the:
  *
@@ -10,6 +10,7 @@
 package org.truffleruby;
 
 import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.Source;
 import org.graalvm.polyglot.Value;
 import org.junit.Test;
 import org.truffleruby.fixtures.FluidForce;
@@ -21,6 +22,8 @@
 import java.util.function.IntConsumer;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 public class PolyglotInteropTest {
 
@@ -147,4 +150,59 @@ public void testParseOnceRunMany() {
         }
     }
 
+    @Test
+    public void testLocalVariablesNotSharedBetweenNonInteractiveEval() {
+        try (Context polyglot = Context.newBuilder()
+                .option(OptionsCatalog.HOME.getName(), System.getProperty("user.dir"))
+                .allowAllAccess(true)
+                .build()) {
+            polyglot.eval("ruby", "a = 14");
+            assertTrue(polyglot.eval("ruby", "defined?(a).nil?").asBoolean());
+        }
+    }
+
+    @Test
+    public void testLocalVariablesSharedBetweenInteractiveEval() {
+        try (Context polyglot = Context.newBuilder()
+                .option(OptionsCatalog.HOME.getName(), System.getProperty("user.dir"))
+                .allowAllAccess(true)
+                .build()) {
+            polyglot.eval(Source.newBuilder("ruby", "a = 14", "test").interactive(true).buildLiteral());
+            assertFalse(polyglot.eval(Source.newBuilder("ruby", "defined?(a).nil?", "test").interactive(true).buildLiteral()).asBoolean());
+            polyglot.eval(Source.newBuilder("ruby", "b = 2", "test").interactive(true).buildLiteral());
+            assertEquals(16, polyglot.eval(Source.newBuilder("ruby", "a + b", "test").interactive(true).buildLiteral()).asInt());
+        }
+    }
+
+    @Test
+    public void testLocalVariablesSharedBetweenInteractiveEvalChangesParsing() {
+        try (Context polyglot = Context.newBuilder()
+                .option(OptionsCatalog.HOME.getName(), System.getProperty("user.dir"))
+                .allowAllAccess(true)
+                .build()) {
+            polyglot.eval(Source.newBuilder("ruby", "def foo; 12; end", "test").interactive(true).buildLiteral());
+            assertEquals(12, polyglot.eval(Source.newBuilder("ruby", "foo", "test").interactive(true).buildLiteral()).asInt());
+            polyglot.eval(Source.newBuilder("ruby", "foo = 42", "test").interactive(true).buildLiteral());
+            assertEquals(42, polyglot.eval(Source.newBuilder("ruby", "foo", "test").interactive(true).buildLiteral()).asInt());
+        }
+    }
+
+    @Test
+    public void testLocalVariablesAreNotSharedBetweenInteractiveAndNonInteractive() {
+        try (Context polyglot = Context.newBuilder()
+                .option(OptionsCatalog.HOME.getName(), System.getProperty("user.dir"))
+                .allowAllAccess(true)
+                .build()) {
+            polyglot.eval(Source.newBuilder("ruby", "a = 14", "test").interactive(false).buildLiteral());
+            polyglot.eval(Source.newBuilder("ruby", "b = 2", "test").interactive(true).buildLiteral());
+            assertTrue(polyglot.eval(Source.newBuilder("ruby", "defined?(a).nil?", "test").interactive(true).buildLiteral()).asBoolean());
+            assertTrue(polyglot.eval(Source.newBuilder("ruby", "defined?(b).nil?", "test").interactive(false).buildLiteral()).asBoolean());
+            assertFalse(polyglot.eval(Source.newBuilder("ruby", "defined?(b).nil?", "test").interactive(true).buildLiteral()).asBoolean());
+            assertTrue(polyglot.eval(Source.newBuilder("ruby", "TOPLEVEL_BINDING.eval('defined?(a).nil?')", "test").interactive(false).buildLiteral()).asBoolean());
+            assertTrue(polyglot.eval(Source.newBuilder("ruby", "TOPLEVEL_BINDING.eval('defined?(b).nil?')", "test").interactive(false).buildLiteral()).asBoolean());
+            assertTrue(polyglot.eval(Source.newBuilder("ruby", "TOPLEVEL_BINDING.eval('defined?(a).nil?')", "test").interactive(true).buildLiteral()).asBoolean());
+            assertTrue(polyglot.eval(Source.newBuilder("ruby", "TOPLEVEL_BINDING.eval('defined?(b).nil?')", "test").interactive(true).buildLiteral()).asBoolean());
+        }
+    }
+
 }