[GR-15990] Move emptyDeclarationDescriptor to RubyLanguage

PullRequest: truffleruby/2871

Author: eregon

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

@@ -23,6 +23,8 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.ContextThreadLocal;
 import com.oracle.truffle.api.TruffleFile;
+import com.oracle.truffle.api.frame.FrameDescriptor;
+import com.oracle.truffle.api.frame.FrameSlot;
 import com.oracle.truffle.api.instrumentation.AllocationReporter;
 import com.oracle.truffle.api.instrumentation.Instrumenter;
 import com.oracle.truffle.api.nodes.Node;
@@ -95,6 +97,7 @@
 import org.truffleruby.core.string.ImmutableRubyString;
 import org.truffleruby.interop.RubyInnerContext;
 import org.truffleruby.language.LexicalScope;
+import org.truffleruby.language.Nil;
 import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.RubyDynamicObject;
 import org.truffleruby.language.RubyEvalInteractiveRootNode;
@@ -280,6 +283,13 @@ private static final class ThreadLocalState {
 
     public final ThreadLocal<ParsingParameters> parsingRequestParams = new ThreadLocal<>();
 
+    /* Some things (such as procs created from symbols) require a declaration frame, and this should include a slot for
+     * special variable storage. This frame descriptor should be used for those frames to provide a constant frame
+     * descriptor in those cases. */
+    public final FrameDescriptor emptyDeclarationDescriptor = new FrameDescriptor(Nil.INSTANCE);
+    public final FrameSlot emptyDeclarationSpecialVariableSlot = emptyDeclarationDescriptor
+            .addFrameSlot(Layouts.SPECIAL_VARIABLES_STORAGE);
+
     private static final LanguageReference<RubyLanguage> REFERENCE = LanguageReference.create(RubyLanguage.class);
 
     public static RubyLanguage get(Node node) {

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

@@ -26,7 +26,6 @@
 import org.graalvm.collections.Pair;
 import org.jcodings.specific.USASCIIEncoding;
 import org.jcodings.transcode.EConvFlags;
-import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.SuppressFBWarnings;
@@ -79,7 +78,6 @@
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.TruffleOptions;
 import com.oracle.truffle.api.frame.FrameDescriptor;
-import com.oracle.truffle.api.frame.FrameSlot;
 import com.oracle.truffle.api.object.DynamicObjectLibrary;
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.SourceSection;
@@ -232,11 +230,6 @@ public class CoreLibrary {
     public final BindingLocalVariablesObject interactiveBindingLocalVariablesObject;
 
     public final FrameDescriptor emptyDescriptor;
-    /* Some things (such as procs created from symbols) require a declaration frame, and this should include a slot for
-     * special variable storage. This frame descriptor should be used for those frames to provide a constant frame
-     * descriptor in those cases. */
-    public final FrameDescriptor emptyDeclarationDescriptor;
-    public final FrameSlot emptyDeclarationSpecialVariableSlot;
 
     @CompilationFinal private RubyClass eagainWaitReadable;
     @CompilationFinal private RubyClass eagainWaitWritable;
@@ -546,9 +539,6 @@ public CoreLibrary(RubyContext context, RubyLanguage language) {
 
         mainObject = new RubyBasicObject(objectClass, language.basicObjectShape);
         emptyDescriptor = new FrameDescriptor(Nil.INSTANCE);
-        emptyDeclarationDescriptor = new FrameDescriptor(Nil.INSTANCE);
-        emptyDeclarationSpecialVariableSlot = emptyDeclarationDescriptor
-                .addFrameSlot(Layouts.SPECIAL_VARIABLES_STORAGE);
         argv = new RubyArray(arrayClass, language.arrayShape, ArrayStoreLibrary.INITIAL_STORE, 0);
 
         globalVariables = new GlobalVariables(context);

src/main/java/org/truffleruby/core/method/MethodNodes.java

@@ -302,9 +302,9 @@ private RubyProc createProc(RootCallTarget callTarget, InternalMethod method, Ob
                     .pack(null, null, method, null, receiver, nil, EMPTY_ARGUMENTS);
             final MaterializedFrame declarationFrame = Truffle
                     .getRuntime()
-                    .createMaterializedFrame(packedArgs, coreLibrary().emptyDeclarationDescriptor);
+                    .createMaterializedFrame(packedArgs, getLanguage().emptyDeclarationDescriptor);
             SpecialVariableStorage variables = new SpecialVariableStorage();
-            declarationFrame.setObject(coreLibrary().emptyDeclarationSpecialVariableSlot, variables);
+            declarationFrame.setObject(getLanguage().emptyDeclarationSpecialVariableSlot, variables);
             return ProcOperations.createRubyProc(
                     coreLibrary().procClass,
                     getLanguage().procShape,

src/main/java/org/truffleruby/core/symbol/SymbolNodes.java

@@ -202,10 +202,10 @@ public static RubyProc createProc(RubyContext context, RubyLanguage language,
             // binding as this simplifies the logic elsewhere in the runtime.
             final MaterializedFrame declarationFrame = Truffle
                     .getRuntime()
-                    .createVirtualFrame(args, context.getCoreLibrary().emptyDeclarationDescriptor)
+                    .createVirtualFrame(args, language.emptyDeclarationDescriptor)
                     .materialize();
             SpecialVariableStorage variables = new SpecialVariableStorage();
-            declarationFrame.setObject(context.getCoreLibrary().emptyDeclarationSpecialVariableSlot, variables);
+            declarationFrame.setObject(language.emptyDeclarationSpecialVariableSlot, variables);
 
             return ProcOperations.createRubyProc(
                     context.getCoreLibrary().procClass,

src/main/java/org/truffleruby/extra/TruffleGraalNodes.java

@@ -117,9 +117,9 @@ protected RubyProc copyCapturedLocals(RubyProc proc) {
             // declaration frame (to allow Proc#binding) so we shall create an empty one.
             final MaterializedFrame newDeclarationFrame = Truffle
                     .getRuntime()
-                    .createMaterializedFrame(args, coreLibrary().emptyDeclarationDescriptor);
+                    .createMaterializedFrame(args, getLanguage().emptyDeclarationDescriptor);
 
-            newDeclarationFrame.setObject(coreLibrary().emptyDeclarationSpecialVariableSlot, variables);
+            newDeclarationFrame.setObject(getLanguage().emptyDeclarationSpecialVariableSlot, variables);
 
             return new RubyProc(
                     coreLibrary().procClass,