[GR-7505] Implement parse(InlineParsingRequest request).

PullRequest: truffleruby/800

Author: chrisseaton

.rubocop.yml

@@ -9,6 +9,7 @@ AllCops:
     - 'lib/truffle/socket/mri.rb' # taken from MRI
     - 'lib/truffle/ffi/library.rb' # taken from FFI gem
     - 'src/test/ruby/types.rb' # deliberately strange code for debugging purposes
+    - 'src/test/ruby/lexical-context.rb' # deliberately strange code for debugging purposes
 
 # Type 'Layout' (166):
 # Supports --auto-correct

src/main/java/org/truffleruby/RubyLanguage.java

@@ -15,13 +15,15 @@
 import com.oracle.truffle.api.TruffleLogger;
 import com.oracle.truffle.api.instrumentation.ProvidedTags;
 import com.oracle.truffle.api.instrumentation.StandardTags;
+import com.oracle.truffle.api.nodes.ExecutableNode;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
 import org.graalvm.options.OptionDescriptor;
 import org.graalvm.options.OptionDescriptors;
 import org.truffleruby.cext.ValueWrapper;
 import org.truffleruby.core.kernel.TraceManager;
-import org.truffleruby.language.LazyRubyRootNode;
+import org.truffleruby.language.RubyInlineParsingRequestNode;
+import org.truffleruby.language.RubyParsingRequestNode;
 import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.RubyGuards;
 import org.truffleruby.shared.BuildInformationImpl;
@@ -121,8 +123,13 @@ public static ContextReference<RubyContext> getCurrentContextReference() {
     }
 
     @Override
-    protected RootCallTarget parse(ParsingRequest request) throws Exception {
-        return Truffle.getRuntime().createCallTarget(new LazyRubyRootNode(this, null, null, request.getSource(), request.getArgumentNames()));
+    protected RootCallTarget parse(ParsingRequest request) {
+        return Truffle.getRuntime().createCallTarget(new RubyParsingRequestNode(this, request.getSource(), request.getArgumentNames().toArray(new String[]{})));
+    }
+
+    @Override
+    protected ExecutableNode parse(InlineParsingRequest request) {
+        return new RubyInlineParsingRequestNode(this, request.getSource(), request.getFrame());
     }
 
     @SuppressWarnings("deprecation")

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2015, 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:
+ *
+ * Eclipse Public License version 1.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.language;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+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.nodes.ExecutableNode;
+import com.oracle.truffle.api.source.Source;
+
+import org.truffleruby.RubyContext;
+import org.truffleruby.RubyLanguage;
+import org.truffleruby.language.arguments.RubyArguments;
+import org.truffleruby.language.methods.DeclarationContext;
+import org.truffleruby.language.methods.InternalMethod;
+import org.truffleruby.language.methods.SharedMethodInfo;
+import org.truffleruby.language.objects.shared.SharedObjects;
+import org.truffleruby.parser.ParserContext;
+import org.truffleruby.parser.RubySource;
+import org.truffleruby.parser.TranslatorDriver;
+
+public class RubyInlineParsingRequestNode extends ExecutableNode {
+
+    private final TruffleLanguage.ContextReference<RubyContext> contextReference;
+    private final Source source;
+    private final MaterializedFrame currentFrame;
+
+    @CompilationFinal private RubyContext cachedContext;
+    @CompilationFinal private InternalMethod method;
+
+    @Child private DirectCallNode callNode;
+
+    public RubyInlineParsingRequestNode(RubyLanguage language, Source source, MaterializedFrame currentFrame) {
+        super(language);
+        contextReference = language.getContextReference();
+        this.source = source;
+        this.currentFrame = currentFrame;
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+        final RubyContext context = contextReference.get();
+
+        if (cachedContext == null) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
+            cachedContext = context;
+        }
+
+        if (callNode == null || context != cachedContext) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
+
+            final TranslatorDriver translator = new TranslatorDriver(context);
+
+            // 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 RootCallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
+
+            callNode = insert(Truffle.getRuntime().createDirectCallNode(callTarget));
+            callNode.forceInlining();
+
+            final SharedMethodInfo sharedMethodInfo = rootNode.getSharedMethodInfo();
+            method = new InternalMethod(context, sharedMethodInfo, sharedMethodInfo.getLexicalScope(), DeclarationContext.topLevel(context),
+                    sharedMethodInfo.getName(), context.getCoreLibrary().getObjectClass(), Visibility.PUBLIC, callTarget);
+        }
+
+        // We run the Ruby code as if it was written in a block
+
+        final Object[] arguments = RubyArguments.pack(
+                frame.materialize(),
+                null,
+                method,
+                null,
+                RubyArguments.getSelf(frame),
+                RubyArguments.getBlock(frame),
+                new Object[]{});
+
+        final Object value = callNode.call(arguments);
+
+        // The return value will be leaked to Java, share it.
+        if (context.getOptions().SHARED_OBJECTS_ENABLED) {
+            SharedObjects.writeBarrier(context, value);
+        }
+
+        return value;
+    }
+
+}

src/main/java/org/truffleruby/language/LazyRubyRootNode.java renamed to src/main/java/org/truffleruby/language/RubyParsingRequestNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved. This
+ * Copyright (c) 2015, 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:
  *
@@ -15,13 +15,10 @@
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.TruffleLanguage;
-import com.oracle.truffle.api.frame.FrameDescriptor;
 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 com.oracle.truffle.api.source.SourceSection;
-
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.language.arguments.RubyArguments;
@@ -30,28 +27,25 @@
 import org.truffleruby.language.methods.InternalMethod;
 import org.truffleruby.language.methods.SharedMethodInfo;
 import org.truffleruby.language.objects.shared.SharedObjects;
-import org.truffleruby.shared.Metrics;
 import org.truffleruby.parser.ParserContext;
 import org.truffleruby.parser.RubySource;
 import org.truffleruby.parser.TranslatorDriver;
+import org.truffleruby.shared.Metrics;
 
-import java.util.List;
-
-public class LazyRubyRootNode extends RubyBaseRootNode implements InternalRootNode {
+public class RubyParsingRequestNode extends RubyBaseRootNode implements InternalRootNode {
 
     private final TruffleLanguage.ContextReference<RubyContext> contextReference;
     private final Source source;
-    private final List<String> argumentNames;
+    private final String[] argumentNames;
 
     @CompilationFinal private RubyContext cachedContext;
     @CompilationFinal private DynamicObject mainObject;
     @CompilationFinal private InternalMethod method;
 
     @Child private DirectCallNode callNode;
 
-    public LazyRubyRootNode(RubyLanguage language, SourceSection sourceSection, FrameDescriptor frameDescriptor, Source source,
-                            List<String> argumentNames) {
-        super(language, frameDescriptor, sourceSection);
+    public RubyParsingRequestNode(RubyLanguage language, Source source, String[] argumentNames) {
+        super(language, null, null);
         contextReference = language.getContextReference();
         this.source = source;
         this.argumentNames = argumentNames;
@@ -72,8 +66,7 @@ public Object execute(VirtualFrame frame) {
 
             final TranslatorDriver translator = new TranslatorDriver(context);
 
-            final String[] argumentsArray = argumentNames.toArray(new String[argumentNames.size()]);
-            final RubyRootNode rootNode = translator.parse(new RubySource(source), ParserContext.TOP_LEVEL, argumentsArray, 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);
 

src/test/java/org/truffleruby/RubyDebugTest.java

@@ -217,6 +217,26 @@ public void testEvalThrow() throws Throwable {
         assertExecutedOK("OK");
     }
 
+    @Test
+    public void testInlineModifiesFrame() throws Throwable {
+        Source source = getSource("src/test/ruby/modify.rb");
+        run.addLast(() -> {
+            assertNull(suspendedEvent);
+            assertNotNull(debuggerSession);
+            debuggerSession.suspendNextExecution();
+        });
+        stepOver(2);
+        run.addLast(() -> {
+            assertNotNull(suspendedEvent);
+            suspendedEvent.getTopStackFrame().eval("a = 22");
+            run.removeFirst().run();
+        });
+        continueExecution();
+        performWork();
+        Assert.assertEquals(22 + 2 + 3, context.eval(source).asInt());
+        assertExecutedOK("OK");
+    }
+
     @Ignore
     @Test
     public void testProperties() throws Throwable {

src/test/java/org/truffleruby/RubyTCKLanguageProvider.java

@@ -10,13 +10,16 @@
 package org.truffleruby;
 
 import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.PolyglotException;
 import org.graalvm.polyglot.Source;
 import org.graalvm.polyglot.Value;
+import org.graalvm.polyglot.tck.InlineSnippet;
 import org.graalvm.polyglot.tck.LanguageProvider;
 import org.graalvm.polyglot.tck.ResultVerifier;
 import org.graalvm.polyglot.tck.Snippet;
 import org.graalvm.polyglot.tck.TypeDescriptor;
 import org.junit.Assert;
+import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.shared.TruffleRuby;
 
 import java.io.File;
@@ -142,6 +145,39 @@ public Collection<? extends Snippet> createScripts(Context context) {
         return Collections.unmodifiableList(res);
     }
 
+    @Override
+    public Collection<? extends InlineSnippet> createInlineScripts(Context context) {
+        List<InlineSnippet> res = new ArrayList<>();
+        res.add(createInlineSnippet(
+                context,
+                getSource("src/test/ruby/lexical-context.rb"),
+                16,
+                "a + b + c",
+                14 + 2 + 6));
+        res.add(createInlineSnippet(
+                context,
+                getSource("src/test/ruby/lexical-context.rb"),
+                16,
+                "binding.local_variable_get(:a) + binding.local_variable_get(:b) + binding.local_variable_get(:c)",
+                14 + 2 + 6));
+        return Collections.unmodifiableList(res);
+    }
+
+    private InlineSnippet createInlineSnippet(Context context, Source mainSource, int line, String inlineSource, int expected) {
+        final Snippet mainSnippet = Snippet.newBuilder(mainSource.getName(), context.eval(mainSource), TypeDescriptor.ANY).build();
+
+        return InlineSnippet.newBuilder(mainSnippet, inlineSource)
+                .locationPredicate(sourceSection ->
+                        sourceSection.getSource().getName().endsWith(mainSource.getName()) && sourceSection.getStartLine() == line)
+                .resultVerifier(snippetRun -> {
+                    final PolyglotException exception = snippetRun.getException();
+                    if (exception != null) {
+                        throw exception;
+                    }
+                    Assert.assertEquals(expected, snippetRun.getResult().asInt());
+                }).build();
+    }
+
     private Snippet createValueConstructor(Context context, String value, TypeDescriptor type) {
         return Snippet.newBuilder(value, context.eval(getId(), String.format("-> { %s }", value)), type).build();
     }

src/test/ruby/lexical-context.rb

@@ -0,0 +1,19 @@
+# Copyright (c) 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:
+#
+# Eclipse Public License version 1.0, or
+# GNU General Public License version 2, or
+# GNU Lesser General Public License version 2.1.
+
+# Beware, RubyTCKLanguageProvider use hard-coded line numbers from this file!
+
+-> {
+  a = 14
+  3.times do
+    b = 2
+    [6].each do |c|
+      x = c
+    end
+  end
+}

src/test/ruby/modify.rb

@@ -0,0 +1,14 @@
+# Copyright (c) 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:
+#
+# Eclipse Public License version 1.0, or
+# GNU General Public License version 2, or
+# GNU Lesser General Public License version 2.1.
+
+# Beware, RubyDebugTest use hard-coded line numbers from this file!
+
+a = 14
+b = 2
+c = 3
+a + b + c