[GR-19220] Basics of building a static keyword arguments descriptor at call-sites (#2637)

PullRequest: truffleruby/3267

Author: eregon

spec/truffle/arguments_descriptor_spec.rb

@@ -38,7 +38,7 @@ def descriptor(*)
       splat = [1, 2]
       descriptor(*splat).should == []
 
-      descriptor(a: 1).should == [:keywords]
+      descriptor(a: 1).should == [:keywords, :a]
       kw = { b: 2 }
       descriptor(**kw).should == [:keywords]
       empty_kw = {}
@@ -64,7 +64,7 @@ def no_kws(a, b)
   it "contain keyword arguments" do
     info = only_kws(a: 1, b: 2)
     info.values.should == [1, 2]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a, :b] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
   end
 
@@ -75,12 +75,12 @@ def only_kws_and_opt(a:, b: 101)
 
     info = only_kws_and_opt(a: 1, b: 2)
     info.values.should == [1, 2]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a, :b] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
 
     info = only_kws_and_opt(a: 1)
     info.values.should == [1, 101]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a] if truffleruby?
     info.arguments.should == [{a: 1}] if truffleruby?
   end
 
@@ -91,7 +91,7 @@ def posn_kws(a, b:)
 
     info = posn_kws(1, b: 2)
     info.values.should == [1, 2]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :b] if truffleruby?
     info.arguments.should == [1, {b: 2}] if truffleruby?
   end
 
@@ -102,34 +102,34 @@ def posn_kws_defaults(a, b: 101, c: 102)
   it "contain optional keyword arguments with positional arguments" do
     info = posn_kws_defaults(1, b: 2, c: 3)
     info.values.should == [1, 2, 3]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :b, :c] if truffleruby?
     info.arguments.should == [1, {b: 2, c: 3}] if truffleruby?
   end
 
   it "do not contain missing optional keyword arguments" do
     info = posn_kws_defaults(1, b: 2)
     info.values.should == [1, 2, 102]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :b] if truffleruby?
     info.arguments.should == [1, {b: 2}] if truffleruby?
 
     info = posn_kws_defaults(1, c: 3)
     info.values.should == [1, 101, 3]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :c] if truffleruby?
     info.arguments.should == [1, {c: 3}] if truffleruby?
   end
 
   it "do not contain the name of distant explicitly splatted keyword arguments" do
     distant = {b: 2}
     info = only_kws(a: 1, **distant)
     info.values.should == [1, 2]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
   end
 
   it "do not contain the name of near explicitly splatted keyword arguments" do
     info = only_kws(a: 1, **{b: 2})
     info.values.should == [1, 2]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
   end
 
@@ -140,7 +140,7 @@ def opt_and_kws(a, b=2, c: nil)
 
     info = opt_and_kws(1, c: 3)
     info.values.should == [1, 2, 3]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :c] if truffleruby?
     info.arguments.should == [1, {c: 3}] if truffleruby?
   end
 
@@ -197,7 +197,7 @@ def struct_new_like(a, *b, c: 101)
 
     info = struct_new_like('A', :a, :b, c: 1)
     info.values.should == ['A', [:a, :b], 1]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :c] if truffleruby?
     info.arguments.should == ['A', :a, :b, {c: 1}] if truffleruby?
 
     info = struct_new_like('A', :a, :b, {c: 1})
@@ -240,7 +240,7 @@ def describe_like(a, b = nil)
 
     info = describe_like(1, b: 2)
     info.values.should == [1, {b: 2}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :b] if truffleruby?
     info.arguments.should == [1, {b: 2}] if truffleruby?
   end
 
@@ -262,7 +262,7 @@ def rest(*a)
 
     info = rest(a: 1, b: 2)
     info.values.should == [[{a: 1, b: 2}]]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a, :b] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
   end
 
@@ -273,7 +273,7 @@ def kw_rest(**a)
 
     info = kw_rest(a: 1, b: 2)
     info.values.should == [{a: 1, b: 2}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a, :b] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
   end
 
@@ -284,17 +284,17 @@ def kw_and_kw_rest(a:, **b)
 
     info = kw_and_kw_rest(a: 1)
     info.values.should == [1, {}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a] if truffleruby?
     info.arguments.should == [{a: 1}] if truffleruby?
 
     info = kw_and_kw_rest(a: 1, b: 2, c: 3)
     info.values.should == [1, {b: 2, c: 3}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a, :b, :c] if truffleruby?
     info.arguments.should == [{a: 1, b: 2, c: 3}] if truffleruby?
 
     info = kw_and_kw_rest("abc" => 123, a: 1, b: 2)
     info.values.should == [1, {"abc" => 123, b: 2}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a, :b] if truffleruby?
     info.arguments.should == [{"abc" => 123, a: 1, b: 2}] if truffleruby?
   end
 
@@ -310,7 +310,7 @@ def mixture(a, b = nil, c = nil, d, e: nil, **f)
 
     info = mixture(1, 2, e: 3)
     info.values.should == [1, nil, nil, 2, 3, {}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :e] if truffleruby?
     info.arguments.should == [1, 2, {e: 3}] if truffleruby?
 
     info = mixture(1, 2, {foo: :bar})
@@ -345,7 +345,7 @@ def self.new(a:, b:)
 
     info = new_kw.new(a: 1, b: 2)
     info.values.should == [1, 2]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a, :b] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
   end
 
@@ -358,11 +358,26 @@ def self.new(*a)
 
     info = new_rest.new(a: 1, b: 2)
     info.values.should == [[{a: 1, b: 2}]]
+    info.descriptor.should == [:keywords, :a, :b] if truffleruby?
+    info.arguments.should == [{a: 1, b: 2}] if truffleruby?
+  end
+
+  it "work through delegation, but by reifying the keyword argument hash" do
+    def delegator(...)
+      delegated(...)
+    end
+
+    def delegated(a:, b:)
+      ArgumentsDescriptorSpecs::Info.new([a, b], Primitive.arguments_descriptor, Primitive.arguments)
+    end
+
+    info = delegator(a: 1, b: 2)
+    info.values.should == [1, 2]
     info.descriptor.should == [:keywords] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
   end
 
-  it "work through implicit super" do
+  it "work through implicit super, but by reifying the keyword argument hash" do
     parent = Class.new do
       def implicit_super(a:, b:)
         ArgumentsDescriptorSpecs::Info.new([a, b], Primitive.arguments_descriptor, Primitive.arguments)
@@ -396,7 +411,7 @@ def explicit_super(a:, b:)
 
     info = child.new.explicit_super(a: 1, b: 2)
     info.values.should == [1, 2]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a, :b] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
   end
 
@@ -413,7 +428,7 @@ def use_yielder(x, y)
 
     info = use_yielder(1, 2)
     info.values.should == [1, 2]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a, :b] if truffleruby?
     info.arguments.should == [{a: 1, b: 2}] if truffleruby?
   end
 
@@ -422,7 +437,7 @@ def use_yielder(x, y)
       info([args, kwargs], Primitive.arguments_descriptor, Primitive.arguments)
     end
     info.values.should == [[], {a: 1}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a] if truffleruby?
     info.arguments.should == [{a: 1}] if truffleruby?
   end
 
@@ -431,7 +446,7 @@ def use_yielder(x, y)
       ArgumentsDescriptorSpecs::Info.new([args, kwargs], Primitive.arguments_descriptor, Primitive.arguments)
     end
     info.values.should == [[], {a: 1}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a] if truffleruby?
     info.arguments.should == [{a: 1}] if truffleruby?
   end
 
@@ -440,11 +455,11 @@ def use_yielder(x, y)
       ArgumentsDescriptorSpecs::Info.new([args, kwargs], Primitive.arguments_descriptor, Primitive.arguments)
     end.call(a: 1)
     info.values.should == [[], {a: 1}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a] if truffleruby?
     info.arguments.should == [{a: 1}] if truffleruby?
   end
 
-  it "work through Thread#new" do
+  it "work through Thread#new, but by reifying the keyword argument hash" do
     info = Thread.new(a: 1) do |*args, **kwargs|
       ArgumentsDescriptorSpecs::Info.new([args, kwargs], Primitive.arguments_descriptor, Primitive.arguments)
     end.value
@@ -458,7 +473,7 @@ def use_yielder(x, y)
       ArgumentsDescriptorSpecs::Info.new([args, kwargs], Primitive.arguments_descriptor, Primitive.arguments)
     end.resume(a: 1)
     info.values.should == [[], {a: 1}]
-    info.descriptor.should == [:keywords] if truffleruby?
+    info.descriptor.should == [:keywords, :a] if truffleruby?
     info.arguments.should == [{a: 1}] if truffleruby?
 
     Fiber.new(&-> { true }).resume(**{}).should == true

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

@@ -105,6 +105,7 @@
 import org.truffleruby.language.RubyEvalInteractiveRootNode;
 import org.truffleruby.language.RubyInlineParsingRequestNode;
 import org.truffleruby.language.RubyParsingRequestNode;
+import org.truffleruby.language.arguments.KeywordArgumentsDescriptorManager;
 import org.truffleruby.language.objects.RubyObjectType;
 import org.truffleruby.language.objects.classvariables.ClassVariableStorage;
 import org.truffleruby.language.threadlocal.SpecialVariableStorage;
@@ -209,6 +210,7 @@ public static final class ThreadLocalState {
     public final RopeCache ropeCache;
     public final RegexpTable regexpTable;
     public final SymbolTable symbolTable;
+    public final KeywordArgumentsDescriptorManager keywordArgumentsDescriptorManager = new KeywordArgumentsDescriptorManager();
     public final FrozenStringLiterals frozenStringLiterals;
 
     public final ReferenceQueue<Object> sharedReferenceQueue = new ReferenceQueue<>();

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -90,6 +90,7 @@
 import org.truffleruby.language.arguments.ArgumentsDescriptor;
 import org.truffleruby.language.arguments.EmptyArgumentsDescriptor;
 import org.truffleruby.language.arguments.KeywordArgumentsDescriptor;
+import org.truffleruby.language.arguments.KeywordArgumentsDescriptorManager;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.backtrace.Backtrace;
 import org.truffleruby.language.constants.GetConstantNode;
@@ -319,7 +320,8 @@ protected Object sendWithoutCExtLock(
                 return sendWithoutCExtLock(frame, receiver, method, block, EmptyArgumentsDescriptor.INSTANCE, args,
                         dispatchNode, ownedProfile);
             } else {
-                return sendWithoutCExtLock(frame, receiver, method, block, KeywordArgumentsDescriptor.INSTANCE, args,
+                return sendWithoutCExtLock(frame, receiver, method, block,
+                        KeywordArgumentsDescriptorManager.EMPTY, args,
                         dispatchNode, ownedProfile);
             }
         }

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

@@ -37,7 +37,9 @@
  */
 package org.truffleruby.core;
 
+import java.util.Arrays;
 import java.util.Map.Entry;
+import java.util.stream.Stream;
 
 import com.oracle.truffle.api.TruffleStackTrace;
 import com.oracle.truffle.api.interop.InteropLibrary;
@@ -611,7 +613,14 @@ private RubyArray descriptorToArray(ArgumentsDescriptor descriptor) {
             if (descriptor == EmptyArgumentsDescriptor.INSTANCE) {
                 return createEmptyArray();
             } else if (descriptor instanceof KeywordArgumentsDescriptor) {
-                return createArray(new Object[]{ getLanguage().getSymbol("keywords") });
+                final KeywordArgumentsDescriptor keywordArgumentsDescriptor = (KeywordArgumentsDescriptor) descriptor;
+
+                final Stream<RubySymbol> keywords = Stream.concat(
+                        Stream.of("keywords"),
+                        Arrays.stream(keywordArgumentsDescriptor.getKeywords()))
+                        .map(getLanguage()::getSymbol);
+
+                return createArray(keywords.toArray());
             } else {
                 throw CompilerDirectives.shouldNotReachHere();
             }

src/main/java/org/truffleruby/core/hash/library/HashStoreLibrary.java

@@ -47,9 +47,14 @@ public static HashStoreLibrary createDispatched() {
         return FACTORY.createDispatched(HashGuards.hashStrategyLimit());
     }
 
+    public static HashStoreLibrary getUncached(RubyHash hash) {
+        final Object store = hash.store;
+        return FACTORY.getUncached(store);
+    }
+
     public static boolean verify(RubyHash hash) {
         final Object store = hash.store;
-        return FACTORY.getUncached(store).verify(store, hash);
+        return getUncached(hash).verify(store, hash);
     }
 
     /** Looks up the key in the hash and returns the associated value, or the result of calling {@code defaultNode} if

src/main/java/org/truffleruby/language/arguments/KeywordArgumentsDescriptor.java

@@ -9,14 +9,21 @@
  */
 package org.truffleruby.language.arguments;
 
+import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+
 /** An arguments descriptor that says that keyword arguments were passed (either foo(a: 1) or foo(**kw)). Note that
  * currently, if kw is empty, then this descriptor is used even though it is semantically the same as if no keyword
  * arguments were passed. The callee must handle that for now. */
 public class KeywordArgumentsDescriptor extends ArgumentsDescriptor {
 
-    public static final KeywordArgumentsDescriptor INSTANCE = new KeywordArgumentsDescriptor();
+    @CompilationFinal(dimensions = 1) private final String[] keywords;
 
-    private KeywordArgumentsDescriptor() {
+    /** Use {@link KeywordArgumentsDescriptorManager} to get an instance. */
+    KeywordArgumentsDescriptor(String[] keywords) {
+        this.keywords = keywords;
     }
 
+    public String[] getKeywords() {
+        return keywords;
+    }
 }