All specializations of inlined nodes are static

Author: horakivo

src/main/java/org/truffleruby/language/objects/ForeignClassNode.java

@@ -31,7 +31,7 @@
 @ReportPolymorphism
 @GenerateUncached
 @GenerateCached(false)
-@GenerateInline(inlineByDefault = true)
+@GenerateInline
 public abstract class ForeignClassNode extends RubyBaseNode {
 
     // Specs for traits are in
@@ -75,21 +75,21 @@ boolean isSet(int traits) {
     public abstract RubyClass execute(Node node, Object value);
 
     @Specialization(guards = "getTraits(object, interop) == cachedTraits", limit = "getInteropCacheLimit()")
-    protected RubyClass cached(Object object,
+    protected static RubyClass cached(Node node, Object object,
             @CachedLibrary("object") InteropLibrary interop,
             @Cached("getTraits(object, interop)") int cachedTraits) {
         assert RubyGuards.isForeignObject(object);
-        return classForTraits(cachedTraits);
+        return classForTraits(node, cachedTraits);
     }
 
     @Specialization(replaces = "cached", limit = "getInteropCacheLimit()")
-    protected RubyClass uncached(Object object,
+    protected static RubyClass uncached(Node node, Object object,
             @CachedLibrary("object") InteropLibrary interop) {
         assert RubyGuards.isForeignObject(object);
-        return classForTraits(getTraits(object, interop));
+        return classForTraits(node, getTraits(object, interop));
     }
 
-    protected int getTraits(Object object, InteropLibrary interop) {
+    protected static int getTraits(Object object, InteropLibrary interop) {
         return (interop.hasHashEntries(object) ? Trait.HASH.bit : 0) +
                 (interop.hasArrayElements(object) ? Trait.ARRAY.bit : 0) +
                 (interop.isException(object) ? Trait.EXCEPTION.bit : 0) +
@@ -104,25 +104,25 @@ protected int getTraits(Object object, InteropLibrary interop) {
                 (interop.isString(object) ? Trait.STRING.bit : 0);
     }
 
-    private RubyClass classForTraits(int traits) {
-        RubyClass rubyClass = coreLibrary().polyglotForeignClasses[traits];
+    private static RubyClass classForTraits(Node node, int traits) {
+        RubyClass rubyClass = coreLibrary(node).polyglotForeignClasses[traits];
         if (rubyClass == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
-            rubyClass = resolvePolyglotForeignClass(traits);
-            coreLibrary().polyglotForeignClasses[traits] = rubyClass;
+            rubyClass = resolvePolyglotForeignClass(node, traits);
+            coreLibrary(node).polyglotForeignClasses[traits] = rubyClass;
         }
         return rubyClass;
     }
 
-    private RubyClass resolvePolyglotForeignClass(int traits) {
+    private static RubyClass resolvePolyglotForeignClass(Node node, int traits) {
         final ArrayList<RubySymbol> traitsList = new ArrayList<>();
         for (Trait trait : Trait.VALUES) {
             if (trait.isSet(traits)) {
-                traitsList.add(getSymbol(trait.name));
+                traitsList.add(getSymbol(node, trait.name));
             }
         }
         final Object[] traitSymbols = traitsList.toArray();
-        return (RubyClass) DispatchNode.getUncached().call(coreLibrary().truffleInteropOperationsModule,
+        return (RubyClass) DispatchNode.getUncached().call(coreLibrary(node).truffleInteropOperationsModule,
                 "resolve_polyglot_class", traitSymbols);
     }
 }

src/main/java/org/truffleruby/language/objects/MetaClassNode.java

@@ -44,14 +44,14 @@ public final RubyClass executeCached(Object value) {
     @Specialization(
             guards = { "isSingleContext()", "object == cachedObject", "metaClass.isSingleton" },
             limit = "1")
-    protected RubyClass singleton(RubyDynamicObject object,
+    protected static RubyClass singleton(Node node, RubyDynamicObject object,
             @Cached("object") RubyDynamicObject cachedObject,
             @Cached("object.getMetaClass()") RubyClass metaClass) {
         return metaClass;
     }
 
     @Specialization(replaces = "singleton")
-    protected RubyClass object(RubyDynamicObject object) {
+    protected static RubyClass object(RubyDynamicObject object) {
         return object.getMetaClass();
     }