Fix anonymous parameter modeling and merging

[Morriar]

Summary

Fixes Shopify/spoom#928.

This updates RBI’s parameter model to represent Ruby anonymous parameters faithfully instead of approximating anonymity through parameter names.

Ruby supports anonymous rest, keyword rest, and block parameters:

def foo(*); end
def foo(**); end
def foo(&); end

Prism represents these with name == nil. RBI now preserves that information in the model instead of assigning synthetic names.

Previous behavior

Before this change, every RBI::Param had a non-nil name, and anonymity was tracked through an @anonymous ivar derived from the name:

@anonymous = name.start_with?("_")

That meant names starting with _ were treated as anonymous, even though they are still real Ruby parameter names.

However, this was name-based, not syntax-based. True Ruby anonymous parameters could not be represented directly because the model required a string name. The parser had to synthesize names instead:

def foo(*); end   # RestParam name became "*args"
def foo(**); end  # KwRestParam name became "**kwargs"
def foo(&); end   # BlockParam name became ""

Merge behavior was also somewhat surprising:

• _-prefixed names acted as wildcards for parameters of the same kind.
• Anonymous compatibility was all-or-nothing at the method level.
• Mixed anonymous/named parameter lists could conflict even when individual params were otherwise compatible.
• Merge could prefer/adopt parameter names from the other side depending on which side had signatures.
• The result could be asymmetric depending on which tree was merged into which.

What changed

• RBI::Param is now more abstract and no longer stores a required name.
• Named parameter classes own non-nil names:
  • ReqParam
  • OptParam
  • KwParam
  • KwOptParam
• Optionally-anonymous parameter classes own nilable names:
  • RestParam
  • KwRestParam
  • BlockParam
• Anonymous params no longer carry an @anonymous ivar.
  • Anonymous-ness is derived from the parameter shape and whether the name is nil.
• Parser preserves nil names for anonymous Ruby params:
  • *
  • **
  • &
• Sig generation still uses printable projection names for anonymous params:
  • anonymous rest → "*"
  • anonymous kwrest → "**"
  • anonymous block → "&"
• Sig parsing/printing handles those quoted projection names correctly.

Merge behavior

Method merging now treats anonymous params as compatible with named params only when the parameter kind is compatible.

Anonymous params are not a wildcard for arbitrary parameter shapes. They only mean “this parameter has no name.”

For example:

• RestParam(nil) is compatible with RestParam("args")
• KwRestParam(nil) is compatible with KwRestParam("kwargs")
• BlockParam(nil) is compatible with BlockParam("block")
• RestParam(nil) is not compatible with ReqParam("arg")

When one side has an anonymous parameter and the other side has a named parameter of the same kind, merge prefers the non-anonymous name.

Example:

sig { params("*": Integer, "**": T::Hash[Symbol, String], "&": T.proc.void).void }
def foo(*, **, &); end

merged with:

sig { params(args: Integer, kwargs: T::Hash[Symbol, String], block: T.proc.void).void }
def foo(*args, **kwargs, &block); end

produces:

sig { params(args: Integer, kwargs: T::Hash[Symbol, String], block: T.proc.void).void }
def foo(*args, **kwargs, &block); end

This also updates sig merging so anonymous sig projection names are renamed to match the final merged method parameters.

Breaking changes

This is a breaking API change for consumers of the RBI model.

Previously, callers could generally assume every parameter had a non-nil name-like value. That is no longer true:

• RBI::Param itself no longer stores a required name.
• RestParam#name, KwRestParam#name, and BlockParam#name can now be nil.
• Anonymous parameters are no longer represented by synthesized names.
• _-prefixed parameter names are no longer considered anonymous by default.
• Code that previously compared anonymous params by placeholder names must now handle nil names or call anonymous?.

Merge behavior changed as well:

• anonymous-vs-named params of the same kind can now merge
• the merged method prefers the non-anonymous name
• anonymous params are not considered compatible across different parameter kinds
• _-prefixed named params no longer act as anonymous wildcards

This makes the model more accurate, but downstream code assuming anonymous params have stable synthetic names, or assuming _-prefixed names are anonymous, will need to be updated.

[rafaelfranca]

Override of what? This class has no subclass

[Morriar]

It's an override of Node#compatible_with?.

Param and the other nodes in this files are all subclasses of Node, though they are just reopenings so we didn't specify the superclass again.

[rafaelfranca]

though they are just reopenings so we didn't specify the superclass again.

We should never do that. If you are reopening keep the inheritance correct.

[amomchilov]

Forgot to submit my draft review. 🤦

Small comments.

[amomchilov]

Can use map! instead

[amomchilov]

It's already a string, likewise below

Suggested change

	@name = name.to_s #: String
	@name = name

[amomchilov]

BTW This breaks for unusual sigs, like params("a": Integer)

I have a wip to fix this across the repo