rubocop 0.49.1 → 0.52.0

data/lib/rubocop/ast/node/mixin/method_dispatch_node.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that are a kind of method dispatch:
+    # `send`, `csend`, `super`, `zsuper`, `yield`
+    module MethodDispatchNode
+      extend NodePattern::Macros
+      include MethodIdentifierPredicates
+
+      # The receiving node of the method dispatch.
+      #
+      # @return [Node, nil] the receiver of the dispatched method or `nil`
+      def receiver
+        node_parts[0]
+      end
+
+      # The name of the dispatched method as a symbol.
+      #
+      # @return [Symbol] the name of the dispatched method
+      def method_name
+        node_parts[1]
+      end
+
+      # An array containing the arguments of the dispatched method.
+      #
+      # @return [Array<Node>] the arguments of the dispatched method
+      def arguments
+        node_parts[2..-1]
+      end
+
+      # Checks whether the dispatched method is a macro method. A macro method
+      # is defined as a method that sits in a class, module, or block body and
+      # has an implicit receiver.
+      #
+      # @note This does not include DSLs that use nested blocks, like RSpec
+      #
+      # @return [Boolean] whether the dispatched method is a macro method
+      def macro?
+        !receiver && macro_scope?
+      end
+
+      # Checks whether the dispatched method is a bare access modifier affects
+      # all methods defined after the macro.
+      #
+      # @return [Boolean] whether the dispatched method is access modifier
+      def access_modifier?
+        macro? && bare_access_modifier?
+      end
+
+      # Checks whether the name of the dispatched method matches the argument
+      # and has an implicit receiver.
+      #
+      # @param [Symbol, String] name the method name to check for
+      # @return [Boolean] whether the method name matches the argument
+      def command?(name)
+        !receiver && method?(name)
+      end
+
+      # Checks whether the dispatched method is a setter method.
+      #
+      # @return [Boolean] whether the dispatched method is a setter
+      def setter_method?
+        loc.respond_to?(:operator) && loc.operator
+      end
+
+      # Checks whether the dispatched method uses a dot to connect the
+      # receiver and the method name.
+      #
+      # This is useful for comparison operators, which can be called either
+      # with or without a dot, i.e. `foo == bar` or `foo.== bar`.
+      #
+      # @return [Boolean] whether the method was called with a connecting dot
+      def dot?
+        loc.respond_to?(:dot) && loc.dot && loc.dot.is?('.')
+      end
+
+      # Checks whether the dispatched method uses a double colon to connect the
+      # receiver and the method name.
+      #
+      # @return [Boolean] whether the method was called with a connecting dot
+      def double_colon?
+        loc.respond_to?(:dot) && loc.dot && loc.dot.is?('::')
+      end
+
+      # Checks whether the *explicit* receiver of this method dispatch is
+      # `self`.
+      #
+      # @return [Boolean] whether the receiver of this method dispatch is `self`
+      def self_receiver?
+        receiver && receiver.self_type?
+      end
+
+      # Checks whether the *explicit* receiver of this method dispatch is a
+      # `const` node.
+      #
+      # @return [Boolean] whether the receiver of this method dispatch
+      #                   is a `const` node
+      def const_receiver?
+        receiver && receiver.const_type?
+      end
+
+      # Checks whether the method dispatch is the implicit form of `#call`,
+      # e.g. `foo.(bar)`.
+      #
+      # @return [Boolean] whether the method is the implicit form of `#call`
+      def implicit_call?
+        method?(:call) && !loc.selector
+      end
+
+      # Whether this method dispatch has an explicit block.
+      #
+      # @return [Boolean] whether the dispatched method has a block
+      def block_literal?
+        parent && parent.block_type? && eql?(parent.send_node)
+      end
+
+      # The `block` node associated with this method dispatch, if any.
+      #
+      # @return [BlockNode, nil] the `block` node associated with this method
+      #                          call or `nil`
+      def block_node
+        parent if block_literal?
+      end
+
+      # Checks if this node is part of a chain of `def` modifiers.
+      #
+      # @example
+      #
+      #   private def foo; end
+      #
+      # @return [Boolean] whether the dispatched method is a `def` modifier
+      def def_modifier?
+        send_type? &&
+          [self, *each_descendant(:send)].any?(&:adjacent_def_modifier?)
+      end
+
+      private
+
+      def_node_matcher :macro_scope?, <<-PATTERN
+        {^{({sclass class module block} ...) class_constructor?}
+         ^^{({sclass class module block} ... (begin ...)) class_constructor?}
+         ^#macro_kwbegin_wrapper?
+         #root_node?}
+      PATTERN
+
+      # Check if a node's parent is a kwbegin wrapper within a macro scope
+      #
+      # @param parent [Node] parent of the node being checked
+      #
+      # @return [Boolean] true if the parent is a kwbegin in a macro scope
+      def macro_kwbegin_wrapper?(parent)
+        parent.kwbegin_type? && macro_scope?(parent)
+      end
+
+      # Check if a node does not have a parent
+      #
+      # @param node [Node]
+      #
+      # @return [Boolean] if the parent is nil
+      def root_node?(node)
+        node.parent.nil?
+      end
+
+      def_node_matcher :adjacent_def_modifier?, <<-PATTERN
+        (send nil? _ ({def defs} ...))
+      PATTERN
+
+      def_node_matcher :bare_access_modifier?, <<-PATTERN
+        (send nil? {:public :protected :private :module_function})
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common predicates for nodes that reference method identifiers:
+    # `send`, `csend`, `def`, `defs`, `super`, `zsuper`
+    #
+    # @note this mixin expects `#method_name` and `#receiver` to be implemented
+    module MethodIdentifierPredicates
+      ENUMERATOR_METHODS = %i[collect collect_concat detect downto each
+                              find find_all find_index inject loop map!
+                              map reduce reject reject! reverse_each select
+                              select! times upto].freeze
+
+      # Checks whether the method name matches the argument.
+      #
+      # @param [Symbol, String] name the method name to check for
+      # @return [Boolean] whether the method name matches the argument
+      def method?(name)
+        method_name == name.to_sym
+      end
+
+      # Checks whether the method is an operator method.
+      #
+      # @return [Boolean] whether the method is an operator
+      def operator_method?
+        RuboCop::Cop::Util::OPERATOR_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a comparison method.
+      #
+      # @return [Boolean] whether the method is a comparison
+      def comparison_method?
+        Node::COMPARISON_OPERATORS.include?(method_name)
+      end
+
+      # Checks whether the method is an assignment method.
+      #
+      # @return [Boolean] whether the method is an assignment
+      def assignment_method?
+        !comparison_method? && method_name.to_s.end_with?('=')
+      end
+
+      # Checks whether the method is an enumerator method.
+      #
+      # @return [Boolean] whether the method is an enumerator
+      def enumerator_method?
+        ENUMERATOR_METHODS.include?(method_name) ||
+          method_name.to_s.start_with?('each_')
+      end
+
+      # Checks whether the method is a predicate method.
+      #
+      # @return [Boolean] whether the method is a predicate method
+      def predicate_method?
+        method_name.to_s.end_with?('?')
+      end
+
+      # Checks whether the method is a bang method.
+      #
+      # @return [Boolean] whether the method is a bang method
+      def bang_method?
+        method_name.to_s.end_with?('!')
+      end
+
+      # Checks whether the method is a camel case method,
+      # e.g. `Integer()`.
+      #
+      # @return [Boolean] whether the method is a camel case method
+      def camel_case_method?
+        method_name.to_s =~ /\A[A-Z]/
+      end
+
+      # Checks whether the *explicit* receiver of this node is `self`.
+      #
+      # @return [Boolean] whether the receiver of this node is `self`
+      def self_receiver?
+        receiver && receiver.self_type?
+      end
+
+      # Checks whether the *explicit* receiver of node is a `const` node.
+      #
+      # @return [Boolean] whether the receiver of this node is a `const` node
+      def const_receiver?
+        receiver && receiver.const_type?
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/mixin/parameterized_node.rb

@@ -3,71 +3,58 @@
 module RuboCop
   module AST
     # Common functionality for nodes that are parameterized:
-    # `send`, `super`, `zsuper` ...
+    # `send`, `super`, `zsuper`, `def`, `defs`
     module ParameterizedNode
-      # Checks whether this super invocation's arguments are wrapped in
-      # parentheses.
+      # Checks whether this node's arguments are wrapped in parentheses.
       #
-      # @return [Boolean] whether this super invocation's arguments are
+      # @return [Boolean] whether this node's arguments are
       #                   wrapped in parentheses
       def parenthesized?
         loc.end && loc.end.is?(')')
       end
 
-      # A shorthand for getting the first argument of the method invocation.
+      # A shorthand for getting the first argument of the node.
       # Equivalent to `arguments.first`.
       #
-      # @return [Node, nil] the first argument of the method invocation,
+      # @return [Node, nil] the first argument of the node,
       #                     or `nil` if there are no arguments
       def first_argument
         arguments[0]
       end
 
-      # A shorthand for getting the last argument of the method invocation.
+      # A shorthand for getting the last argument of the node.
       # Equivalent to `arguments.last`.
       #
-      # @return [Node, nil] the last argument of the method invocation,
+      # @return [Node, nil] the last argument of the node,
       #                     or `nil` if there are no arguments
       def last_argument
         arguments[-1]
       end
 
-      # Checks whether this method was invoked with arguments.
+      # Checks whether this node has any arguments.
       #
-      # @return [Boolean] whether this method was invoked with arguments
+      # @return [Boolean] whether this node has any arguments
       def arguments?
         !arguments.empty?
       end
 
-      # Checks whether any argument of the method invocation is a splat
+      # Checks whether any argument of the node is a splat
       # argument, i.e. `*splat`.
       #
-      # @return [Boolean] whether the invoked method is a splat argument
+      # @return [Boolean] whether the node is a splat argument
       def splat_argument?
-        arguments? && arguments.any?(&:splat_type?)
+        arguments? &&
+          (arguments.any?(&:splat_type?) || arguments.any?(&:restarg_type?))
       end
+      alias rest_argument? splat_argument?
 
-      # Whether the last argument of the method invocation is a block pass,
+      # Whether the last argument of the node is a block pass,
       # i.e. `&block`.
       #
-      # @return [Boolean] whether the invoked method is a block pass
+      # @return [Boolean] whether the last argument of the node is a block pass
       def block_argument?
-        arguments? && last_argument.block_pass_type?
-      end
-
-      # Whether this method invocation has an explicit block.
-      #
-      # @return [Boolean] whether the invoked method has a block
-      def block_literal?
-        parent && parent.block_type? && eql?(parent.send_node)
-      end
-
-      # The block node associated with this method call, if any.
-      #
-      # @return [BlockNode, nil] the `block` node associated with this method
-      #                          call or `nil`
-      def block_node
-        parent if block_literal?
+        arguments? &&
+          (last_argument.block_pass_type? || last_argument.blockarg_type?)
       end
     end
   end

data/lib/rubocop/ast/node/regexp_node.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `regexp` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `regexp` nodes within RuboCop.
+    class RegexpNode < Node
+      OPTIONS = {
+        x: Regexp::EXTENDED,
+        i: Regexp::IGNORECASE,
+        m: Regexp::MULTILINE,
+        n: Regexp::NOENCODING
+      }.freeze
+
+      # @return [Regexp] a regexp of this node
+      def to_regexp
+        option = regopt.children.map { |opt| OPTIONS[opt] }.inject(:|)
+        Regexp.new(content, option)
+      end
+
+      # @return [RuboCop::AST::Node] a regopt node
+      def regopt
+        first, second = *self
+        first.regopt_type? ? first : second
+      end
+
+      # @return [String] a string of regexp content
+      def content
+        str = children.first
+        str.str_content || ''
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/send_node.rb

@@ -7,168 +7,39 @@ module RuboCop
     # to all `send` nodes within RuboCop.
     class SendNode < Node
       include ParameterizedNode
+      include MethodDispatchNode
+      ARROW = '->'.freeze
 
-      ENUMERATOR_METHODS = %i[collect collect_concat detect downto each
-                              find find_all find_index inject loop map!
-                              map reduce reject reject! reverse_each select
-                              select! times upto].freeze
-
-      # The receiving node of the method invocation.
-      #
-      # @return [Node, nil] the receiver of the invoked method or `nil`
-      def receiver
-        node_parts[0]
-      end
-
-      # The name of the invoked method called as a string.
-      #
-      # @return [Symbol] the name of the invoked method
-      def method_name
-        node_parts[1]
-      end
-
-      # An array containing the arguments of the method invocation.
-      #
-      # @return [Array<Node>] the arguments of the method invocation or `nil`
-      def arguments
-        node_parts[2..-1]
-      end
-
-      # Checks whether the method name matches the argument.
-      #
-      # @param [Symbol, String] name the method name to check for
-      # @return [Boolean] whether the method name matches the argument
-      def method?(name)
-        method_name == name.to_sym
-      end
-
-      # Checks whether the method is a macro method. A macro method is defined
-      # as a method that sits in a class- or module body and has an implicit
-      # receiver.
-      #
-      # @note This does not include DSLs that use nested blocks, like RSpec
-      #
-      # @return [Boolean] whether the method is a macro method
-      def macro?
-        !receiver && macro_scope?
-      end
-
-      # Checks whether the method name matches the argument and has an
-      # implicit receiver.
-      #
-      # @param [Symbol, String] name the method name to check for
-      # @return [Boolean] whether the method name matches the argument
-      def command?(name)
-        !receiver && method?(name)
-      end
-
-      # Checks whether the invoked method is a setter method.
-      #
-      # @return [Boolean] whether the invoked method is a setter
-      def setter_method?
-        loc.operator
-      end
-
-      # Checks whether the invoked method is an operator method.
-      #
-      # @return [Boolean] whether the invoked method is an operator
-      def operator_method?
-        RuboCop::Cop::Util::OPERATOR_METHODS.include?(method_name)
-      end
-
-      # Checks whether the invoked method is a comparison method.
-      #
-      # @return [Boolean] whether the involed method is a comparison
-      def comparison_method?
-        COMPARISON_OPERATORS.include?(method_name)
-      end
-
-      # Checks whether the invoked method is an assignment method.
-      #
-      # @return [Boolean] whether the invoked method is an assignment.
-      def assignment_method?
-        !comparison_method? && method_name.to_s.end_with?('=')
-      end
-
-      # Checks whether the invoked method is an enumerator method.
-      #
-      # @return [Boolean] whether the invoked method is an enumerator.
-      def enumerator_method?
-        ENUMERATOR_METHODS.include?(method_name) ||
-          method_name.to_s.start_with?('each_')
-      end
-
-      # Checks whether the method call uses a dot to connect the receiver and
-      # the method name.
-      #
-      # This is useful for comparison operators, which can be called either
-      # with or without a dot, i.e. `foo == bar` or `foo.== bar`.
-      #
-      # @return [Boolean] whether the method was called with a connecting dot
-      def dot?
-        loc.dot && loc.dot.is?('.')
-      end
-
-      # Checks whether the method call uses a double colon to connect the
-      # receiver and the method name.
-      #
-      # @return [Boolean] whether the method was called with a connecting dot
-      def double_colon?
-        loc.dot && loc.dot.is?('::')
-      end
-
-      # Checks whether the receiver of this method invocation is `self`.
-      #
-      # @return [Boolean] whether the receiver of this method invocation
-      #                   is `self`
-      def self_receiver?
-        receiver && receiver.self_type?
-      end
-
-      # Checks whether the method call is of the implicit form of `#call`,
-      # e.g. `foo.(bar)`.
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
       #
-      # @return [Boolean] whether the method is an implicit form of `#call`
-      def implicit_call?
-        method_name == :call && !loc.selector
+      # @return [Array] the different parts of the `send` node
+      def node_parts
+        to_a
       end
 
-      # Checks whether the invoked method is a predicate method.
+      # Checks whether this is a negation method, i.e. `!` or keyword `not`.
       #
-      # @return [Boolean] whether the invoked method is a predicate method
-      def predicate_method?
-        method_name.to_s.end_with?('?')
+      # @return [Boolean] whether this method is a negation method
+      def negation_method?
+        keyword_bang? || keyword_not?
       end
 
-      # Checks whether the invoked method is a bang method.
+      # Checks whether this is a lambda. Some versions of parser parses
+      # non-literal lambdas as a method send.
       #
-      # @return [Boolean] whether the invoked method is a bang method
-      def bang_method?
-        method_name.to_s.end_with?('!')
+      # @return [Boolean] whether this method is a lambda
+      def lambda?
+        parent && parent.block_type? && method?(:lambda)
       end
 
-      # Checks whether the invoked method is a camel case method,
-      # e.g. `Integer()`.
+      # Checks whether this is a stabby lambda. e.g. `-> () {}`
       #
-      # @return [Boolean] whether the invoked method is a camel case method
-      def camel_case_method?
-        method_name.to_s =~ /\A[A-Z]/
+      # @return [Boolean] whether this method is a staby lambda
+      def stabby_lambda?
+        selector = loc.selector
+        selector && selector.source == ARROW
       end
-
-      # Custom destructuring method. This can be used to normalize
-      # destructuring for different variations of the node.
-      #
-      # @return [Array] the different parts of the `send` node
-      def node_parts
-        to_a
-      end
-
-      private
-
-      def_matcher :macro_scope?, <<-PATTERN
-        {^({class module} ...)
-         ^^({class module} ... (begin ...))}
-      PATTERN
     end
   end
 end