Call Truffle::Boot.INTERACTIVE_BINDING.eval(code) for interactive sources

* Fixes the ignored test and problems with Truffle-level caching.
* The caching is done correctly in Binding#eval, updating and checking
  the Binding's FrameDescriptor.
* Significantly simpler and easier to understand.

Author: eregon

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

@@ -15,14 +15,16 @@
 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.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;
@@ -38,19 +40,21 @@ 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;
-    @CompilationFinal private MaterializedFrame declarationFrame;
 
     @Child private DirectCallNode callNode;
 
     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;
     }
 
@@ -59,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;
@@ -69,20 +86,12 @@ 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),
-                    interactive ? ParserContext.EVAL : ParserContext.TOP_LEVEL,
+                    ParserContext.TOP_LEVEL,
                     argumentNames,
-                    declarationFrame,
-                    !interactive,
+                    null,
+                    true,
                     null);
 
             final RootCallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
@@ -98,7 +107,7 @@ public Object execute(VirtualFrame frame) {
         }
 
         final Object value = callNode.call(RubyArguments.pack(
-                declarationFrame,
+                null,
                 null,
                 method,
                 null,

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

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

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

@@ -12,7 +12,6 @@
 import org.graalvm.polyglot.Context;
 import org.graalvm.polyglot.Source;
 import org.graalvm.polyglot.Value;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.truffleruby.fixtures.FluidForce;
 import org.truffleruby.shared.TruffleRuby;
@@ -175,7 +174,6 @@ public void testLocalVariablesSharedBetweenInteractiveEval() {
         }
     }
 
-    @Ignore
     @Test
     public void testLocalVariablesSharedBetweenInteractiveEvalChangesParsing() {
         try (Context polyglot = Context.newBuilder()