Basic static keyword argument descriptors

Author: chrisseaton

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/cext/CExtNodes.java

@@ -319,7 +319,8 @@ protected Object sendWithoutCExtLock(
                 return sendWithoutCExtLock(frame, receiver, method, block, EmptyArgumentsDescriptor.INSTANCE, args,
                         dispatchNode, ownedProfile);
             } else {
-                return sendWithoutCExtLock(frame, receiver, method, block, getLanguage().keywordArgumentsDescriptorManager.EMPTY, args,
+                return sendWithoutCExtLock(frame, receiver, method, block,
+                        getLanguage().keywordArgumentsDescriptorManager.EMPTY, args,
                         dispatchNode, ownedProfile);
             }
         }

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

@@ -616,8 +616,8 @@ private RubyArray descriptorToArray(ArgumentsDescriptor descriptor) {
                 final KeywordArgumentsDescriptor keywordArgumentsDescriptor = (KeywordArgumentsDescriptor) descriptor;
 
                 final Stream<RubySymbol> keywords = Stream.concat(
-                                Stream.of("keywords"),
-                                Arrays.stream(keywordArgumentsDescriptor.getKeywords()))
+                        Stream.of("keywords"),
+                        Arrays.stream(keywordArgumentsDescriptor.getKeywords()))
                         .map(getLanguage()::getSymbol);
 
                 return createArray(keywords.toArray());

src/main/java/org/truffleruby/parser/BodyTranslator.java

@@ -3127,23 +3127,32 @@ private static ArgumentsDescriptor getKeywordArgumentsDescriptor(RubyLanguage la
             return EmptyArgumentsDescriptor.INSTANCE;
         }
 
+        final List<String> keywords = new ArrayList<>();
+        boolean splat = false;
+        boolean nonKeywordKeys = false;
+
         for (ParseNodeTuple pair : keywordHashArgumentNode.getPairs()) {
             final ParseNode key = pair.getKey();
             final ParseNode value = pair.getValue();
 
             if (key instanceof SymbolParseNode &&
                     ((SymbolParseNode) key).getName() != null) {
-                return language.keywordArgumentsDescriptorManager.EMPTY;
+                keywords.add(((SymbolParseNode) key).getName());
             } else if (key == null && value != null) {
                 // A splat keyword hash
-                return language.keywordArgumentsDescriptorManager.EMPTY;
+                splat = true;
             } else {
                 // For non-symbol keys
-                return language.keywordArgumentsDescriptorManager.EMPTY;
+                nonKeywordKeys = true;
             }
         }
 
-        return EmptyArgumentsDescriptor.INSTANCE;
+        if (splat || nonKeywordKeys || !keywords.isEmpty()) {
+            return language.keywordArgumentsDescriptorManager
+                    .getArgumentsDescriptor(keywords.toArray(n -> new String[n]));
+        } else {
+            return EmptyArgumentsDescriptor.INSTANCE;
+        }
     }
 
     /* This is carefully written so ArrayParseNode is only considered if it is the argsNode itself, or as the RHS of an