Adopt NodeLibrary, deprecate scope

* Move scope classes top-level when possible.

Author: bjfish

spec/truffle/interop/node_library_spec.rb

@@ -0,0 +1,92 @@
+# truffleruby_primitives: true
+
+# Copyright (c) 2020 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 2.0, or
+# GNU General Public License version 2, or
+# GNU Lesser General Public License version 2.1.
+
+
+require_relative '../../ruby/spec_helper'
+require_relative 'fixtures/classes'
+
+describe "Truffle::Interop.scope" do
+
+  # rubocop:disable Lint/UselessAssignment
+  # rubocop:disable Lint/UnusedBlockArgument
+
+  it "returns the members" do
+    b = :test
+    def get_scope()
+      a = 42
+      Primitive.current_scope
+    end
+    scope = get_scope()
+    Truffle::Interop.read_member(scope, "a").should == 42
+    Truffle::Interop.members(scope).should == ["a", "self"]
+  end
+
+  it "has a parent scope with the correct members" do
+    def get_scopes()
+      scope = nil
+      a = :a
+      ["one"].each do |value|
+        b = :b
+        ["two"].each do |inner|
+          c = :c
+          scope = Primitive.current_scope
+        end
+      end
+      scope
+    end
+    scope = get_scopes()
+    Truffle::Interop.members(scope).should == ["inner", "c", "value", "b", "scope", "a", "self"]
+    scope["inner"].should == "two"
+    scope["c"].should == :c
+    scope["value"].should == "one"
+    scope["b"].should == :b
+    scope["a"].should == :a
+    parent_scope = Truffle::Interop.scope_parent(scope)
+    Truffle::Interop.members(parent_scope).should == ["value", "b", "scope", "a", "self"]
+    parent_scope["b"].should == :b
+    -> { parent_scope["missing"] }.should raise_error(NameError)
+    parent_parent_scope = Truffle::Interop.scope_parent(parent_scope)
+    Truffle::Interop.members(parent_parent_scope).should == ["scope", "a", "self"]
+  end
+
+  it "allows reading and writing scope members" do
+    def get_scopes()
+      scope = nil
+      a = :a
+      ["one"].each do |value|
+        b = :b
+        ["two"].each do |inner|
+          c = :c
+          scope = Primitive.current_scope
+        end
+      end
+      scope
+    end
+    scope = get_scopes()
+    scope["inner"].should == "two"
+    scope["inner"] = "three"
+    scope["inner"].should == "three"
+
+    scope["c"].should == :c
+    scope["c"] = :d
+    scope["c"].should == "d"
+
+    scope["a"].should == :a
+    scope["a"] = :b
+    scope["a"].should == "b"
+
+    -> { scope["missing"] = "missing" }.should raise_error(NameError)
+  end
+
+
+  # rubocop:enable Lint/UselessAssignment
+  # rubocop:enable Lint/UnusedBlockArgument
+
+end

spec/truffle/interop/node_library_top_scope_spec.rb

@@ -0,0 +1,31 @@
+# truffleruby_primitives: true
+
+# Copyright (c) 2020 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 2.0, or
+# GNU General Public License version 2, or
+# GNU Lesser General Public License version 2.1.
+#
+
+# rubocop:disable Lint/UselessAssignment
+
+a = "a"
+
+describe "NodeLibrary top scope" do
+  it "returns the members" do
+    b = "b"
+    def get_top_scope
+      c = "c"
+      Primitive.top_scope
+    end
+    top_scope = get_top_scope()
+    scope_members = Truffle::Interop.members(top_scope)
+    ["$stdout", "is_a?"].all? { |m| scope_members.include?(m) }.should == true
+    top_scope["$stdout"].should == $stdout
+    top_scope["is_a?"].should be_kind_of(Method)
+  end
+end
+
+# rubocop:enable Lint/UselessAssignment

src/main/java/org/truffleruby/RubyContext.java

@@ -824,6 +824,10 @@ public String getPathRelativeToHome(String path) {
         }
     }
 
+    public Object getTopScopeObject() {
+        return coreLibrary.topScopeObject;
+    }
+
     @TruffleBoundary
     public static String fileLine(SourceSection section) {
         if (section == null) {

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

@@ -64,8 +64,6 @@
 import org.truffleruby.core.thread.RubyThread;
 import org.truffleruby.core.time.RubyTime;
 import org.truffleruby.core.tracepoint.RubyTracePoint;
-import org.truffleruby.debug.GlobalScope;
-import org.truffleruby.debug.LexicalScope;
 import org.truffleruby.extra.RubyAtomicReference;
 import org.truffleruby.extra.ffi.RubyPointer;
 import org.truffleruby.language.NotProvided;
@@ -85,16 +83,13 @@
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.RootCallTarget;
-import com.oracle.truffle.api.Scope;
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.TruffleLanguage;
 import com.oracle.truffle.api.TruffleLanguage.ContextPolicy;
 import com.oracle.truffle.api.TruffleLogger;
-import com.oracle.truffle.api.frame.Frame;
 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.nodes.Node;
 import com.oracle.truffle.api.utilities.CyclicAssumption;
 import org.truffleruby.stdlib.bigdecimal.RubyBigDecimal;
 import org.truffleruby.stdlib.digest.RubyDigest;
@@ -398,15 +393,8 @@ protected void disposeThread(RubyContext context, Thread thread) {
     }
 
     @Override
-    protected Iterable<Scope> findLocalScopes(RubyContext context, Node node, Frame frame) {
-        return LexicalScope.getLexicalScopeFor(context, node, frame == null ? null : frame.materialize());
-    }
-
-    @Override
-    protected Iterable<Scope> findTopScopes(RubyContext context) {
-        return Arrays.asList(
-                GlobalScope.getGlobalScope(context.getCoreLibrary().globalVariables),
-                Scope.newBuilder("main", context.getCoreLibrary().mainObject).build());
+    protected Object getScope(RubyContext context) {
+        return context.getTopScopeObject();
     }
 
     public String getTruffleLanguageHome() {

src/main/java/org/truffleruby/core/CoreLibrary.java

@@ -46,6 +46,8 @@
 import org.truffleruby.core.string.RubyString;
 import org.truffleruby.core.string.StringOperations;
 import org.truffleruby.core.symbol.RubySymbol;
+import org.truffleruby.debug.GlobalVariablesObject;
+import org.truffleruby.debug.TopScopeObject;
 import org.truffleruby.extra.ffi.Pointer;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.NotProvided;
@@ -242,6 +244,7 @@ public class CoreLibrary {
     @CompilationFinal private GlobalVariableReader stderrReader;
 
     @CompilationFinal public RubyBinding topLevelBinding;
+    @CompilationFinal public TopScopeObject topScopeObject;
 
     private final ConcurrentMap<String, Boolean> patchFiles;
 
@@ -588,6 +591,8 @@ public CoreLibrary(RubyContext context) {
         argv = new RubyArray(arrayClass, RubyLanguage.arrayShape, ArrayStoreLibrary.INITIAL_STORE, 0);
 
         globalVariables = new GlobalVariables();
+        topScopeObject = new TopScopeObject(
+                new Object[]{ new GlobalVariablesObject(globalVariables), mainObject });
 
         patchFiles = initializePatching(context);
     }

src/main/java/org/truffleruby/core/binding/BindingNodes.java

@@ -12,11 +12,13 @@
 import java.util.LinkedHashSet;
 import java.util.Set;
 
+import com.oracle.truffle.api.dsl.CachedContext;
+import com.oracle.truffle.api.dsl.GenerateNodeFactory;
+import com.oracle.truffle.api.dsl.GenerateUncached;
 import org.jcodings.specific.UTF8Encoding;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.builtins.CoreMethod;
-import org.truffleruby.builtins.CoreMethodNode;
 import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.builtins.Primitive;
 import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
@@ -30,6 +32,7 @@
 import org.truffleruby.core.string.StringNodes.MakeStringNode;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.RubyNode;
+import org.truffleruby.language.RubySourceNode;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.arguments.ReadCallerFrameNode;
 import org.truffleruby.language.arguments.RubyArguments;
@@ -153,10 +156,18 @@ protected RubyBinding dup(RubyBinding binding) {
     }
 
     @ImportStatic({ BindingNodes.class, FindDeclarationVariableNodes.class })
+    @GenerateUncached
+    @GenerateNodeFactory
     @CoreMethod(names = "local_variable_defined?", required = 1)
     @NodeChild(value = "binding", type = RubyNode.class)
     @NodeChild(value = "name", type = RubyNode.class)
-    public abstract static class LocalVariableDefinedNode extends CoreMethodNode {
+    public abstract static class LocalVariableDefinedNode extends RubySourceNode {
+
+        public static LocalVariableDefinedNode create() {
+            return BindingNodesFactory.LocalVariableDefinedNodeFactory.create(null, null);
+        }
+
+        public abstract boolean execute(RubyBinding binding, String name);
 
         @CreateCast("name")
         protected RubyNode coerceToString(RubyNode name) {
@@ -177,30 +188,39 @@ protected boolean localVariableDefinedCached(RubyBinding binding, String name,
         }
 
         @TruffleBoundary
-        @Specialization(guards = "!isHiddenVariable(name)")
+        @Specialization(guards = "!isHiddenVariable(name)", replaces = "localVariableDefinedCached")
         protected boolean localVariableDefinedUncached(RubyBinding binding, String name) {
             return FindDeclarationVariableNodes.findFrameSlotOrNull(name, binding.getFrame()) != null;
         }
 
         @TruffleBoundary
         @Specialization(guards = "isHiddenVariable(name)")
-        protected Object localVariableDefinedLastLine(RubyBinding binding, String name) {
+        protected Object localVariableDefinedLastLine(RubyBinding binding, String name,
+                @CachedContext(RubyLanguage.class) RubyContext context) {
             throw new RaiseException(
-                    getContext(),
-                    coreExceptions().nameError("Bad local variable name", binding, name, this));
+                    context,
+                    context.getCoreExceptions().nameError("Bad local variable name", binding, name, this));
         }
 
         protected int getCacheLimit() {
-            return getContext().getOptions().BINDING_LOCAL_VARIABLE_CACHE;
+            return RubyLanguage.getCurrentContext().getOptions().BINDING_LOCAL_VARIABLE_CACHE;
         }
 
     }
 
-    @CoreMethod(names = "local_variable_get", required = 1)
+    @GenerateUncached
+    @GenerateNodeFactory
     @NodeChild(value = "binding", type = RubyNode.class)
     @NodeChild(value = "name", type = RubyNode.class)
     @ImportStatic(BindingNodes.class)
-    public abstract static class LocalVariableGetNode extends CoreMethodNode {
+    @CoreMethod(names = "local_variable_get", required = 1)
+    public abstract static class LocalVariableGetNode extends RubySourceNode {
+
+        public abstract Object execute(RubyBinding binding, String name);
+
+        public static LocalVariableGetNode create() {
+            return BindingNodesFactory.LocalVariableGetNodeFactory.create(null, null);
+        }
 
         @CreateCast("name")
         protected RubyNode coerceToString(RubyNode name) {
@@ -209,38 +229,48 @@ protected RubyNode coerceToString(RubyNode name) {
 
         @Specialization(guards = "!isHiddenVariable(name)")
         protected Object localVariableGet(RubyBinding binding, String name,
-                @Cached FindAndReadDeclarationVariableNode readNode) {
+                @Cached FindAndReadDeclarationVariableNode readNode,
+                @CachedContext(RubyLanguage.class) RubyContext context) {
             MaterializedFrame frame = binding.getFrame();
-            Object result = readNode.execute(frame, name);
+            Object result = readNode.execute(frame, name, null);
             if (result == null) {
                 throw new RaiseException(
-                        getContext(),
-                        coreExceptions().nameErrorLocalVariableNotDefined(name, binding, this));
+                        context,
+                        context.getCoreExceptions().nameErrorLocalVariableNotDefined(name, binding, this));
             }
             return result;
         }
 
         @TruffleBoundary
         @Specialization(guards = "isHiddenVariable(name)")
-        protected Object localVariableGetLastLine(RubyBinding binding, String name) {
+        protected Object localVariableGetLastLine(RubyBinding binding, String name,
+                @CachedContext(RubyLanguage.class) RubyContext context) {
             throw new RaiseException(
-                    getContext(),
-                    coreExceptions().nameError("Bad local variable name", binding, name, this));
+                    context,
+                    context.getCoreExceptions().nameError("Bad local variable name", binding, name, this));
         }
 
         protected int getCacheLimit() {
-            return getContext().getOptions().BINDING_LOCAL_VARIABLE_CACHE;
+            return RubyLanguage.getCurrentContext().getOptions().BINDING_LOCAL_VARIABLE_CACHE;
         }
 
     }
 
     @ReportPolymorphism
+    @GenerateUncached
+    @GenerateNodeFactory
     @CoreMethod(names = "local_variable_set", required = 2)
     @NodeChild(value = "binding", type = RubyNode.class)
     @NodeChild(value = "name", type = RubyNode.class)
     @NodeChild(value = "value", type = RubyNode.class)
     @ImportStatic({ BindingNodes.class, FindDeclarationVariableNodes.class })
-    public abstract static class LocalVariableSetNode extends CoreMethodNode {
+    public abstract static class LocalVariableSetNode extends RubySourceNode {
+
+        public static LocalVariableSetNode create() {
+            return BindingNodesFactory.LocalVariableSetNodeFactory.create(null, null, null);
+        }
+
+        public abstract Object execute(RubyBinding binding, String name, Object value);
 
         @CreateCast("name")
         protected RubyNode coerceToString(RubyNode name) {
@@ -285,7 +315,9 @@ protected Object localVariableSetNewCached(RubyBinding binding, String name, Obj
         }
 
         @TruffleBoundary
-        @Specialization(guards = "!isHiddenVariable(name)")
+        @Specialization(
+                guards = "!isHiddenVariable(name)",
+                replaces = { "localVariableSetCached", "localVariableSetNewCached" })
         protected Object localVariableSetUncached(RubyBinding binding, String name, Object value) {
             MaterializedFrame frame = binding.getFrame();
             final FrameSlotAndDepth frameSlot = FindDeclarationVariableNodes.findFrameSlotOrNull(name, frame);
@@ -303,18 +335,19 @@ protected Object localVariableSetUncached(RubyBinding binding, String name, Obje
 
         @TruffleBoundary
         @Specialization(guards = "isHiddenVariable(name)")
-        protected Object localVariableSetLastLine(RubyBinding binding, String name, Object value) {
+        protected Object localVariableSetLastLine(RubyBinding binding, String name, Object value,
+                @CachedContext(RubyLanguage.class) RubyContext context) {
             throw new RaiseException(
-                    getContext(),
-                    coreExceptions().nameError("Bad local variable name", binding, name, this));
+                    context,
+                    context.getCoreExceptions().nameError("Bad local variable name", binding, name, this));
         }
 
         protected WriteFrameSlotNode createWriteNode(FrameSlotAndDepth frameSlot) {
             return WriteFrameSlotNodeGen.create(frameSlot.slot);
         }
 
         protected int getCacheLimit() {
-            return getContext().getOptions().BINDING_LOCAL_VARIABLE_CACHE;
+            return RubyLanguage.getCurrentContext().getOptions().BINDING_LOCAL_VARIABLE_CACHE;
         }
     }