ruby27: Support forwarding arguments syntax

[Morriar]

Motivation

Ruby 2.7 introduced the argument forwarding syntax:

def foo(...)
  target(...)
end

And if I'm following this documentation correctly, it would be comparable to...

def foo(*args, **kwargs, &block)
  target(*args, **kwargs, &block)
end

This PR imports the whitequark tests, updates the parser and introduces desugaring/resolving support for the forwarding syntax.

Approach

1. During parsing we store ... calls as a FORWARD(ED)_ARG node in the AST:

     DefMethod {
       name = <U foo>
       args = ForwardArgs {
       }
       body = Send {
         receiver = NULL
         method = <U bar>
         args = [
           ForwardedArgs {
           }
         ]
       }
     }
   

2. During desugar the ... node are transformed into *args, **kwargs, &block:

   def foo<<C <todo sym>>>(*<args>, **<kargs>:, &<blk>)
     ::<Magic>.<call-with-splat-and-block>(<self>, :"bar", ::T.unsafe(<args>).to_a().concat([<kargs>.to_hash()]), <blk>)
   end
   

3. During resolve, nothing change regarding local variables and arguments resolution:

       MethodDef{
         flags = {}
         name = <U foo><<U foo>>
         args = [Local{
             localVariable = <U <args>>
           }, Local{
             localVariable = <U <kargs>>
           }, Local{
             localVariable = <U <blk>>
           }]
   

   But if a signature if provided we check that it contains the right parameters:

   sig do
    params(
      x: T.untyped
    ).returns(String)
   end # error: Malformed `sig` for argument forwarding. Signature must declare exactly `3` parameters named `args`, `kargs` and `block`
   def foo(...)
   end

   Then rename the args to <args> to match the desugared signature (and avoid someone using the args when it's not really declared:

   sig do
     params(
       args: Integer,
       kargs: T::Hash[Symbol, String],
       block: T.proc.returns(Integer)
     ).void
   end
   def foo(...)
     puts args # error: Method `args` does not exist on `Foo`
     puts kargs # error: Method `kargs` does not exist on `Foo`
     puts block # error: Method `block` does not exist on `Foo`
     target(...)
   end

Test plan

See included automated tests.

[Morriar]

Rebased on master

[jez]

The parser and desugar changes look great. I think we'd like to omit the resolver & sig changes for now.

[Morriar]

Removed the resolver part but left the test to show the current behaviour.

As you can see in test/testdata/resolver/forward_args.rb test, not handling the signature makes things even more confusing.

[jez]

Removed the resolver part but left the test to show the current behaviour.

As you can see in test/testdata/resolver/forward_args.rb test, not handling the signature makes things even more confusing.

Sorry for not being clear. My suggestion was that we keep desugaring to *<args>, **<kwargs>, &<blk> (i.e., with those unwritable names) so that it isn't possible to reference those arguments as local variables in the body of a method, and then we add some code to prevent people from writing a signature when we detect that the method definition came from a forward_args node.

[Morriar]

Oh sorry for the confusion!

I added an error if you try to provide a signature for a method declared with argument forwarding syntax:

sig { void } # error:  Unsupported `sig` for argument forwarding syntax. Rewrite the method as `def A#foo(*args, **kwargs, &blk)` to use a signature
def foo(...); end

It's less confusing that way 👍

[jez]

nice i like these names!

[jez]

Thanks so much for being patient through all the back and forth!