module RuboCop::AST::NodePattern::Macros

def def_node_matcher(method_name, pattern_str, **keyword_defaults)

return the captures, or `true` if there were none.
If the node matches, and no block is provided, the new method will
yield to the block (passing any captures as block arguments).
If the node matches, and a block is provided, the new method will
The new method will return nil if the node does not match.

Define a method which applies a pattern to an AST node
def def_node_matcher(method_name, pattern_str, **keyword_defaults)
  if NodePattern.lazy_compilation
    def_node_pattern_method_lazily(:def_node_matcher, method_name, pattern_str,
                                   keyword_defaults, caller_locations(1, 1).first)
  else
    NodePattern.new(pattern_str).def_node_matcher(self, method_name, **keyword_defaults)
  end
end

def def_node_pattern_method_lazily(definer, method_name, pattern_str, keyword_defaults,

calling `super` keep working.
instance method rather than a regular dispatch, so that overrides
first invocation. The compiled method is invoked through the owner's
Defines a stub that compiles the pattern and replaces itself on
def def_node_pattern_method_lazily(definer, method_name, pattern_str, keyword_defaults,
                                   location)
  base = self
  define_method(method_name) do |*args, **kwargs, &block|
    # Remove the stub before defining the compiled method in its
    # place, so that no method redefinition warning is emitted.
    begin
      base.send(:remove_method, method_name)
    rescue NameError
      nil # the method was already compiled concurrently
    end
    pattern = NodePattern.new(pattern_str)
    pattern.definition_location = location
    pattern.public_send(definer, base, method_name, **keyword_defaults)
    base.instance_method(method_name).bind_call(self, *args, **kwargs, &block)
  end
  method_name
end

def def_node_search(method_name, pattern_str, **keyword_defaults)

yield all descendants which match.
as soon as it finds a descendant which matches. Otherwise, it will
If the method name ends with '?', the new method will return `true`

checking whether any of them match the provided pattern
Define a method which recurses over the descendants of an AST node,
def def_node_search(method_name, pattern_str, **keyword_defaults)
  if NodePattern.lazy_compilation
    def_node_pattern_method_lazily(:def_node_search, method_name, pattern_str,
                                   keyword_defaults, caller_locations(1, 1).first)
  else
    NodePattern.new(pattern_str).def_node_search(self, method_name, **keyword_defaults)
  end
end