Compile simple kwargs as a direct operand of call

headius · headius · commit fd7647d20977 · 2026-02-05T21:15:01.000-06:00
This confirms and compiles symbol-only, simple keyword arguments as
a direct operand of the call, to allow downstream optimizations to
prepare those keyword arguments in an appropriate way.

Normal literal hashes and any keyword-like hashes with splats are
compiled as before, with the Hash being built and stored and then
loaded when the argument list is being built. Keyword hashes that
are simple avoid the copy so they are associated directly with the
call.

Order continues to be preserved for the values of the simple kwargs
hash, but the hash itself with its literal keys and any literal
values are now both an operand of and
metadata for the call.
diff --git a/core/src/main/java/org/jruby/ir/builder/IRBuilderAST.java b/core/src/main/java/org/jruby/ir/builder/IRBuilderAST.java
@@ -2320,8 +2320,19 @@ Operand buildGlobalVar(Variable result, GlobalVarNode node) {
     }
 
     public Operand buildHash(HashNode hashNode) {
+        if (hashNode.isLiteral() || hashNode.hasRestKwarg()) {
+            // not kwargs or non-simple kwargs, build as a normal Hash
+            return buildLiteralHash(hashNode);
+        }
+
+        // simple kwargs, build as KeywordHash
+        return buildKeywordHash(hashNode);
+    }
+
+    private Variable buildLiteralHash(HashNode hashNode) {
         List<KeyValuePair<Operand, Operand>> args = new ArrayList<>(1);
         boolean hasAssignments = hashNode.containsVariableAssignment();
+
         Variable hash = null;
         // Duplication checks happen when **{} are literals and not **h variable references.
         Operand duplicateCheck = fals();
@@ -2360,6 +2371,20 @@ public Operand buildHash(HashNode hashNode) {
         return hash;
     }
 
+    public Operand buildKeywordHash(HashNode hashNode) {
+        List<KeyValuePair<Operand, Operand>> args = new ArrayList<>(1);
+        boolean hasAssignments = hashNode.containsVariableAssignment();
+
+        for (KeyValuePair<Node, Node> pair: hashNode.getPairs()) {
+            Node key = pair.getKey();
+            assert key instanceof SymbolNode : "simple kwargs should only have symbol keys";
+
+            args.add(new KeyValuePair<>(buildSymbol((SymbolNode) key), buildWithOrder(pair.getValue(), hasAssignments)));
+        }
+
+        return new Hash(args, true);
+    }
+
     public Operand buildIf(Variable result, final IfNode ifNode) {
         return buildConditional(result, ifNode.getCondition(), ifNode.getThenBody(), ifNode.getElseBody());
     }
diff --git a/core/src/main/java/org/jruby/ir/operands/Hash.java b/core/src/main/java/org/jruby/ir/operands/Hash.java
@@ -28,15 +28,25 @@
 // that actually build the hash
 public class Hash extends Operand {
     public final KeyValuePair<Operand, Operand>[] pairs;
+    public final boolean keywords;
 
     public Hash(List<KeyValuePair<Operand, Operand>> pairs) {
-        this(pairs.toArray(new KeyValuePair[pairs.size()]));
+        this(pairs, false);
+    }
+
+    public Hash(List<KeyValuePair<Operand, Operand>> pairs, boolean keywords) {
+        this(pairs.toArray(new KeyValuePair[pairs.size()]), keywords);
     }
 
     protected Hash(KeyValuePair<Operand, Operand>[] pairs) {
+        this(pairs, false);
+    }
+
+    protected Hash(KeyValuePair<Operand, Operand>[] pairs, boolean keywords) {
         super();
 
         this.pairs = pairs;
+        this.keywords = keywords;
     }
 
     @Override
