Interactive sources should share the same binding

Author: chrisseaton

CHANGELOG.md

@@ -12,6 +12,10 @@ Compatibility:
 * Added missing `Enumerable#filter` and `Enumerator::Lazy#filter` aliases to the respective `select` method (#1610).
 * Implement more `Ripper` methods as no-ops (#1694).
 
+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,20 @@ 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 Polyglot API 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.
+
+Not that parsing Ruby is dependent on the current state of the top-level
+binding. If you parse an interactive source with the binding at one point in
+time, and then execute against the binding after it has been modified, the
+code will not be re-parsed with the modified binding. You may even find that
+you create a race condition, or parse against a binding in a state during the
+execution of another source.
+
 ## Loading code written in foreign languages
 
 `Polyglot.eval(id, string)` executes code in a foreign language identified by

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

@@ -15,10 +15,12 @@
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.TruffleLanguage;
+import com.oracle.truffle.api.frame.MaterializedFrame;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.DirectCallNode;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.Source;
+import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.language.arguments.RubyArguments;
@@ -41,6 +43,7 @@ public class RubyParsingRequestNode extends RubyBaseRootNode implements Internal
     @CompilationFinal private RubyContext cachedContext;
     @CompilationFinal private DynamicObject mainObject;
     @CompilationFinal private InternalMethod method;
+    @CompilationFinal private MaterializedFrame declarationFrame;
 
     @Child private DirectCallNode callNode;
 
@@ -66,12 +69,20 @@ public Object execute(VirtualFrame frame) {
 
             final TranslatorDriver translator = new TranslatorDriver(context);
 
+            final boolean interactive = source.isInteractive();
+
+            if (interactive) {
+                declarationFrame = Layouts.BINDING.getFrame(
+                        (DynamicObject) Layouts.MODULE.getFields(context.getCoreLibrary().getTruffleBootModule())
+                                .getConstant("INTERACTIVE_BINDING").getValue());
+            }
+
             final RubyRootNode rootNode = translator.parse(
                     new RubySource(source),
-                    ParserContext.TOP_LEVEL,
+                    interactive ? ParserContext.EVAL : ParserContext.TOP_LEVEL,
                     argumentNames,
-                    null,
-                    true,
+                    declarationFrame,
+                    !interactive,
                     null);
 
             final RootCallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
@@ -87,7 +98,7 @@ public Object execute(VirtualFrame frame) {
         }
 
         final Object value = callNode.call(RubyArguments.pack(
-                null,
+                declarationFrame,
                 null,
                 method,
                 null,

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

@@ -14,6 +14,12 @@
 
 module Truffle::Boot
 
+  def self.create_interactive_binding
+    binding
+  end
+
+  INTERACTIVE_BINDING = create_interactive_binding
+
   def self.check_syntax(source_or_file)
     inner_check_syntax source_or_file
     STDOUT.puts 'Syntax OK'

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,28 @@ 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());
+        }
+    }
+
 }