Support arity syntax in definition patterns

[rodrigues]

Definition patterns can now be constrained by argument count with name/arity syntax. /N is an exact arity, /_ matches any arity, and the name is either captured or ignored with _:

Pattern	Matches
def name/2	any 2-arity def, capturing the name
def _/0	any 0-arity def, name ignored
def name/_	a def of any arity, capturing the name
defp name/1	only private 1-arity defs
defmacro name/2	only 2-arity macro definitions

Works across def/defp/defmacro/defmacrop, respects the definition kind (defp name/1 won't match a public def), and looks through guard clauses (def clamp(x) when x > 0 is arity 1). Empty-paren heads like def ping() are treated as arity 0.

Before

$ mix ex_ast.search --count "def name/4 do ... end" lib
0

name/2 was matched literally as a / operator, so it never lined up with a definition head.

After

$ mix ex_ast.search --count "def name/4 do ... end" lib
8

$ mix ex_ast.search "def name/0 do ... end" lib
lib/ex_ast/cli/selector_options.ex:69
  def switches, do: @switches
  name: :switches

lib/ex_ast/selector.ex:239
  def piped, do: predicate(:piped, nil)
  name: :piped

lib/ex_ast/selector.ex:243
  def first, do: predicate(:first, nil)
  name: :first

lib/ex_ast/selector.ex:247
  def last, do: predicate(:last, nil)
  name: :last


4 match(es)

_ on the name is a non-capturing arity constraint — same matches, no name: binding:

$ mix ex_ast.search "def _/0 do ... end" lib/ex_ast/selector.ex
lib/ex_ast/selector.ex:239
def piped, do: predicate(:piped, nil)

lib/ex_ast/selector.ex:243
def first, do: predicate(:first, nil)

lib/ex_ast/selector.ex:247
def last, do: predicate(:last, nil)

3 match(es)

$ mix ex_ast.search --count "defp _/_ do ... end"
783

Fixed-shape definition patterns (def name(a, b), def ()) are unchanged. _(_) doesn't count when there are guards, Maybe we want to change that?

$ mix ex_ast.search --count "defp _(_) do ... end"
254

$ mix ex_ast.search --count "defp _/1 do ... end"
361

Arity constraints are opt-in via the / syntax.

[dannote]

I like the arity syntax, but there are two consistency issues to sort out.

[dannote]

The examples say def name/2 should work on its own, but prest is empty in that case and srest contains the body, so it never matches a normal definition:

Patcher.find_all(
  "def apply(a, b), do: {a, b}",
  "def name/2"
)
# []

Could you either make the short form ignore the body or update the API/docs to require def name/2 do ... end?

[dannote]

This changes the capture from the identifier AST ({:foo, nil, nil}) to :foo. Besides being inconsistent with existing definition captures, it breaks repeated captures:

Patcher.find_all(
  "def foo(foo), do: foo",
  "def name/1 do name end"
)
# []

Could we keep the same capture shape as existing definition patterns?