Always inline Module#using and main.using to not need to lookup the caller frame

eregon · eregon · commit ee84d2896efb · 2021-02-22T13:19:34.000+01:00
diff --git a/spec/truffle/always_inlined_spec.rb b/spec/truffle/always_inlined_spec.rb
@@ -64,6 +64,12 @@
         }.should raise_error(FrozenError) { |e| e.backtrace_locations[0].label.should == 'foo=' }
       end
     end
+
+    it "for main.using" do
+      -> do
+        eval('using "foo"', TOPLEVEL_BINDING)
+      end.should raise_error(TypeError) { |e| e.backtrace_locations[0].label.should == 'using' }
+    end
   end
 
   describe "are not part of the backtrace if the error happens in a different method" do
diff --git a/src/main/java/org/truffleruby/core/MainNodes.java b/src/main/java/org/truffleruby/core/MainNodes.java
@@ -15,22 +15,19 @@
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.builtins.CoreMethod;
-import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.core.inlined.AlwaysInlinedMethodNode;
 import org.truffleruby.core.module.ModuleNodes;
-import org.truffleruby.core.module.RubyModule;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.control.RaiseException;
+import org.truffleruby.language.methods.InternalMethod;
 import org.truffleruby.language.methods.UsingNode;
-import org.truffleruby.language.methods.UsingNodeGen;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.Frame;
-import com.oracle.truffle.api.frame.FrameInstance.FrameAccess;
 import com.oracle.truffle.api.profiles.BranchProfile;
 
 @CoreModule(value = "main", isClass = true)
@@ -58,31 +55,30 @@ protected Object forward(Frame callerFrame, Object self, Object[] args, Object b
         }
     }
 
-    @CoreMethod(names = "using", required = 1, needsSelf = false)
-    public abstract static class MainUsingNode extends CoreMethodArrayArgumentsNode {
-
-        @Child private UsingNode usingNode = UsingNodeGen.create();
-
+    @GenerateUncached
+    @CoreMethod(names = "using", required = 1, alwaysInlined = true)
+    public abstract static class MainUsingNode extends UsingNode {
         @Specialization
-        protected Object mainUsing(RubyModule refinementModule,
+        protected Object mainUsing(Frame callerFrame, Object self, Object[] args, Object block, RootCallTarget target,
+                @CachedContext(RubyLanguage.class) RubyContext context,
                 @Cached BranchProfile errorProfile) {
-            if (!isCalledFromTopLevel()) {
+            final Object refinementModule = args[0];
+            final InternalMethod callerMethod = RubyArguments.getMethod(callerFrame);
+            if (!isCalledFromTopLevel(callerMethod)) {
                 errorProfile.enter();
                 throw new RaiseException(
-                        getContext(),
-                        coreExceptions().runtimeError("main.using is permitted only at toplevel", this));
+                        context,
+                        context.getCoreExceptions().runtimeError("main.using is permitted only at toplevel", this));
             }
-            usingNode.executeUsing(refinementModule);
+            using(context, callerFrame, refinementModule, errorProfile);
             return nil;
         }
 
         @TruffleBoundary
-        private boolean isCalledFromTopLevel() {
-            final Frame callerFrame = getContext().getCallStack().getCallerFrame(FrameAccess.READ_ONLY);
-            final String name = RubyArguments.getMethod(callerFrame).getSharedMethodInfo().getBacktraceName();
+        private boolean isCalledFromTopLevel(InternalMethod callerMethod) {
+            final String name = callerMethod.getSharedMethodInfo().getBacktraceName();
             return name.equals("<main>") || name.startsWith("<top ");
         }
-
     }
 
 }
diff --git a/src/main/java/org/truffleruby/core/module/ModuleNodes.java b/src/main/java/org/truffleruby/core/module/ModuleNodes.java
@@ -105,7 +105,6 @@
 import org.truffleruby.language.methods.SharedMethodInfo;
 import org.truffleruby.language.methods.Split;
 import org.truffleruby.language.methods.UsingNode;
-import org.truffleruby.language.methods.UsingNodeGen;
 import org.truffleruby.language.objects.AllocationTracing;
 import org.truffleruby.language.objects.IsANode;
 import org.truffleruby.language.objects.SingletonClassNode;
@@ -2264,32 +2263,33 @@ private RubyModule newRefinementModule(RubyModule namespace, RubyModule moduleTo
 
     }
 
-    @CoreMethod(names = "using", required = 1, visibility = Visibility.PRIVATE)
-    public abstract static class ModuleUsingNode extends CoreMethodArrayArgumentsNode {
-
-        @Child private UsingNode usingNode = UsingNodeGen.create();
-
-        @TruffleBoundary
+    @CoreMethod(names = "using", required = 1, visibility = Visibility.PRIVATE, alwaysInlined = true)
+    public abstract static class ModuleUsingNode extends UsingNode {
         @Specialization
-        protected RubyModule moduleUsing(RubyModule self, RubyModule refinementModule) {
-            final Frame callerFrame = getContext().getCallStack().getCallerFrame(FrameAccess.READ_ONLY);
+        protected Object moduleUsing(Frame callerFrame, Object self, Object[] args, Object block, RootCallTarget target,
+                @CachedContext(RubyLanguage.class) RubyContext context,
+                @Cached BranchProfile errorProfile) {
+            final Object refinementModule = args[0];
             if (self != RubyArguments.getSelf(callerFrame)) {
+                errorProfile.enter();
                 throw new RaiseException(
-                        getContext(),
-                        coreExceptions().runtimeError("Module#using is not called on self", this));
+                        context,
+                        context.getCoreExceptions().runtimeError("Module#using is not called on self", this));
             }
-            if (!isCalledFromClassOrModule(callerFrame)) {
+            final InternalMethod callerMethod = RubyArguments.getMethod(callerFrame);
+            if (!isCalledFromClassOrModule(callerMethod)) {
+                errorProfile.enter();
                 throw new RaiseException(
-                        getContext(),
-                        coreExceptions().runtimeError("Module#using is not permitted in methods", this));
+                        context,
+                        context.getCoreExceptions().runtimeError("Module#using is not permitted in methods", this));
             }
-            usingNode.executeUsing(refinementModule);
+            using(context, callerFrame, refinementModule, errorProfile);
             return self;
         }
 
         @TruffleBoundary
-        private boolean isCalledFromClassOrModule(Frame callerFrame) {
-            final String name = RubyArguments.getMethod(callerFrame).getSharedMethodInfo().getBacktraceName();
+        private boolean isCalledFromClassOrModule(InternalMethod callerMethod) {
+            final String name = callerMethod.getSharedMethodInfo().getBacktraceName();
             // Handles cases: <main> | <top | <class: | <module: | <singleton
             return name.startsWith("<");
         }
diff --git a/src/main/java/org/truffleruby/language/methods/DeclarationContext.java b/src/main/java/org/truffleruby/language/methods/DeclarationContext.java
@@ -131,7 +131,6 @@ public static void setCurrentVisibility(Frame callerFrame, Visibility visibility
         changeVisibility(callerFrame, visibility);
     }
 
-    @TruffleBoundary
     public static void setRefinements(Frame callerFrame, DeclarationContext declarationContext,
             Map<RubyModule, RubyModule[]> refinements) {
         RubyArguments.setDeclarationContext(callerFrame, declarationContext.withRefinements(refinements));
diff --git a/src/main/java/org/truffleruby/language/methods/UsingNode.java b/src/main/java/org/truffleruby/language/methods/UsingNode.java
@@ -15,39 +15,36 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentMap;
 
+import com.oracle.truffle.api.profiles.BranchProfile;
+import org.truffleruby.RubyContext;
 import org.truffleruby.core.array.ArrayUtils;
-import org.truffleruby.core.klass.RubyClass;
+import org.truffleruby.core.inlined.AlwaysInlinedMethodNode;
 import org.truffleruby.core.module.RubyModule;
-import org.truffleruby.language.RubyContextNode;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.control.RaiseException;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
-import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.Frame;
-import com.oracle.truffle.api.frame.FrameInstance.FrameAccess;
 
-public abstract class UsingNode extends RubyContextNode {
+public abstract class UsingNode extends AlwaysInlinedMethodNode {
 
-    public abstract void executeUsing(RubyModule module);
-
-    @TruffleBoundary
-    @Specialization
-    protected void using(RubyModule module) {
-        if (module instanceof RubyClass) {
-            throw new RaiseException(getContext(), coreExceptions().typeErrorWrongArgumentType(module, "Module", this));
+    protected void using(RubyContext context, Frame callerFrame, Object refinementModule, BranchProfile errorProfile) {
+        if (refinementModule.getClass() != RubyModule.class) {
+            errorProfile.enter();
+            throw new RaiseException(
+                    context,
+                    context.getCoreExceptions().typeErrorWrongArgumentType(refinementModule, "Module", this));
         }
-
-        final Frame callerFrame = getContext().getCallStack().getCallerFrame(FrameAccess.READ_WRITE);
+        final RubyModule module = (RubyModule) refinementModule;
         final DeclarationContext declarationContext = RubyArguments.getDeclarationContext(callerFrame);
         final Map<RubyModule, RubyModule[]> newRefinements = usingModule(declarationContext, module);
-        if (!newRefinements.isEmpty()) {
+        if (newRefinements != null) {
             DeclarationContext.setRefinements(callerFrame, declarationContext, newRefinements);
         }
     }
 
     @TruffleBoundary
-    private Map<RubyModule, RubyModule[]> usingModule(DeclarationContext declarationContext, RubyModule module) {
+    private static Map<RubyModule, RubyModule[]> usingModule(DeclarationContext declarationContext, RubyModule module) {
         final Map<RubyModule, RubyModule[]> newRefinements = new HashMap<>(declarationContext.getRefinements());
 
         // Iterate ancestors in reverse order so refinements upper in the chain have precedence
@@ -64,7 +61,7 @@ private Map<RubyModule, RubyModule[]> usingModule(DeclarationContext declaration
             }
         }
 
-        return newRefinements;
+        return newRefinements.isEmpty() ? null : newRefinements;
     }
 
     private static void applyRefinements(RubyModule refinedModule, RubyModule refinementModule,

Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,6 @@ public static void setCurrentVisibility(Frame callerFrame, Visibility visibility`
`131`	`131`	`changeVisibility(callerFrame, visibility);`
`132`	`132`	`}`
`133`	`133`
`134`		`- @TruffleBoundary`
`135`	`134`	`public static void setRefinements(Frame callerFrame, DeclarationContext declarationContext,`
`136`	`135`	`Map<RubyModule, RubyModule[]> refinements) {`
`137`	`136`	`RubyArguments.setDeclarationContext(callerFrame, declarationContext.withRefinements(refinements));`