为不带参数的方法splatting哈希时的不同行为

Question

I'm trying to write a helper_method type functionality. In doing so I encountered this weird behavior:

irb(main):001:0> def a; end
=> :a
irb(main):002:0> b = {}
=> {}
irb(main):003:0> a(**{})
=> nil
irb(main):004:0> a(**b)
ArgumentError: wrong number of arguments (given 1, expected 0)
  from (irb):1:in `a'
  from (irb):4
  from /home/vagrant/.rbenv/versions/2.3.1/bin/irb:11:in `<main>'

The method a takes no arguments. Calling it by splatting an empty hash works, but it that hash was stored in a variable it fails. This looks like a legit bug. Anyone has any ideas?

Answer 1

A bit of semi-informed guesswork: a method call with doublesplat in it will merge the argument of the doublesplat with any existing keyword arguments, and put it into the last argument as a hash. With a literal empty hash, the compiler can see that there are no keywords, and can skip creating a hash:

puts RubyVM::InstructionSequence.compile("b = {}; a(**{})").disasm
== disasm: #<ISeq:<compiled>@<compiled>>================================
local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1])
[ 2] b          
0000 trace            1                                               (   1)
0002 newhash          0
0004 setlocal_OP__WC__0 2
0006 putself          
0007 opt_send_without_block <callinfo!mid:a, argc:0, FCALL|ARGS_SIMPLE>, <callcache>
0010 leave            

You will get the same outcome as long as the total number of keywords is predictably zero. Thus, these two compile identically:

a()
a(**{})

With a variable hash (that happens to be empty), this assumption cannot be made, and the merge is always called, producing a hash argument:

puts RubyVM::InstructionSequence.compile("b = {}; a(**b)").disasm
== disasm: #<ISeq:<compiled>@<compiled>>================================
local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1])
[ 2] b          
0000 trace            1                                               (   1)
0002 newhash          0
0004 setlocal_OP__WC__0 2
0006 putself          
0007 putspecialobject 1
0009 getlocal_OP__WC__0 2
0011 opt_send_without_block <callinfo!mid:core#hash_merge_kwd, argc:1, ARGS_SIMPLE>, <callcache>
0014 opt_send_without_block <callinfo!mid:dup, argc:0, ARGS_SIMPLE>, <callcache>
0017 opt_send_without_block <callinfo!mid:a, argc:1, FCALL|ARGS_SIMPLE>, <callcache>
0020 leave    

So I guess 2.2.2 added some optimisation code that sees the futility of **{} , and skips generating extra code.

If you define your method to always collect the rest of the keywords, it will not break, as a hash will be created even if the sender did not pass it:

def a(**x); p x; end
a()         # works, x is {} - hash supplied by VM at receiver
a(**b)      # works, x is {} - hash supplied by sender as b.merge({})
a(**{})     # works, x is {} - hash supplied by VM at receiver, **{} ignored
a(b, **{})  # works, x is {} - hash supplied by sender, **{} ignored
a({}, **{}) # works, x is {} - hash supplied by sender, **{} ignored
a(b, **b)   # works, x is {} - hash supplied by sender as b.merge(b)
a({}, **b)  # works, x is {} - hash supplied by sender as b.merge({})