rubocop 0.49.1 → 0.52.0

data/lib/rubocop/ast/builder.rb

@@ -19,6 +19,7 @@ module RuboCop
         ArrayNode        => [:array],
         BlockNode        => [:block],
         CaseNode         => [:case],
+        DefNode          => %i[def defs],
         EnsureNode       => [:ensure],
         ForNode          => [:for],
         HashNode         => [:hash],
@@ -26,12 +27,16 @@ module RuboCop
         KeywordSplatNode => [:kwsplat],
         OrNode           => [:or],
         PairNode         => [:pair],
+        RegexpNode       => [:regexp],
         ResbodyNode      => [:resbody],
         SendNode         => %i[csend send],
+        StrNode          => %i[str dstr xstr],
         SuperNode        => %i[super zsuper],
+        SymbolNode       => [:sym],
         UntilNode        => %i[until until_post],
         WhenNode         => [:when],
-        WhileNode        => %i[while while_post]
+        WhileNode        => %i[while while_post],
+        YieldNode        => [:yield]
       }.freeze
 
       # Generates {Node} from the given information.

data/lib/rubocop/ast/node.rb

@@ -20,8 +20,11 @@ module RuboCop
     #
     class Node < Parser::AST::Node # rubocop:disable Metrics/ClassLength
       include RuboCop::AST::Sexp
+      extend NodePattern::Macros
 
-      COMPARISON_OPERATORS = %i[! == === != <= >= > < <=>].freeze
+      # <=> isn't included here, because it doesn't return a boolean.
+      COMPARISON_OPERATORS = %i[== === != <= >= > <].freeze
+      ARITHMETIC_OPERATORS = %i[+ - * / % **].freeze
 
       TRUTHY_LITERALS = %i[str dstr xstr int float sym dsym array
                            hash regexp true irange erange complex
@@ -44,19 +47,6 @@ module RuboCop
       OPERATOR_KEYWORDS = %i[and or].freeze
       SPECIAL_KEYWORDS = %w[__FILE__ __LINE__ __ENCODING__].freeze
 
-      # def_matcher can be used to define a pattern-matching method on Node
-      class << self
-        def def_matcher(method_name, pattern_str)
-          compiler = RuboCop::NodePattern::Compiler.new(pattern_str, 'self')
-          src = "def #{method_name}(" \
-                "#{compiler.emit_param_list});" \
-                "#{compiler.emit_method_code};end"
-
-          location = caller_locations(1, 1).first
-          class_eval(src, location.path, location.lineno)
-        end
-      end
-
       # @see http://rubydoc.info/gems/ast/AST/Node:initialize
       def initialize(type, children = [], properties = {})
         @mutable_attributes = {}
@@ -271,12 +261,17 @@ module RuboCop
 
       ## Destructuring
 
-      def_matcher :receiver,    '{(send $_ ...) (block (send $_ ...) ...)}'
-      def_matcher :method_name, '{(send _ $_ ...) (block (send _ $_ ...) ...)}'
-      def_matcher :method_args, '{(send _ _ $...) (block (send _ _ $...) ...)}'
+      def_node_matcher :receiver, <<-PATTERN
+        {(send $_ ...) (block (send $_ ...) ...)}
+      PATTERN
+
+      def_node_matcher :method_name, <<-PATTERN
+        {(send _ $_ ...) (block (send _ $_ ...) ...)}
+      PATTERN
+
       # Note: for masgn, #asgn_rhs will be an array node
-      def_matcher :asgn_rhs, '[assignment? (... $_)]'
-      def_matcher :str_content, '(str $_)'
+      def_node_matcher :asgn_rhs, '[assignment? (... $_)]'
+      def_node_matcher :str_content, '(str $_)'
 
       def const_name
         return unless const_type?
@@ -288,11 +283,11 @@ module RuboCop
         end
       end
 
-      def_matcher :defined_module0, <<-PATTERN
+      def_node_matcher :defined_module0, <<-PATTERN
         {(class (const $_ $_) ...)
          (module (const $_ $_) ...)
-         (casgn $_ $_        (send (const nil {:Class :Module}) :new ...))
-         (casgn $_ $_ (block (send (const nil {:Class :Module}) :new ...) ...))}
+         (casgn $_ $_        (send (const nil? {:Class :Module}) :new ...))
+         (casgn $_ $_ (block (send (const nil? {:Class :Module}) :new ...) ...))}
       PATTERN
       private :defined_module0
 
@@ -320,11 +315,28 @@ module RuboCop
       ## Predicates
 
       def multiline?
-        source_range && (source_range.first_line != source_range.last_line)
+        line_count > 1
       end
 
       def single_line?
-        !multiline?
+        line_count == 1
+      end
+
+      def line_count
+        return 0 unless source_range
+        source_range.last_line - source_range.first_line + 1
+      end
+
+      def nonempty_line_count
+        source.lines.grep(/\S/).size
+      end
+
+      def empty?
+        length.zero?
+      end
+
+      def length
+        source_range ? source_range.size : 0
       end
 
       def asgn_method_call?
@@ -332,10 +344,19 @@ module RuboCop
           method_name.to_s.end_with?('='.freeze)
       end
 
-      def_matcher :equals_asgn?, '{lvasgn ivasgn cvasgn gvasgn casgn masgn}'
-      def_matcher :shorthand_asgn?, '{op_asgn or_asgn and_asgn}'
-      def_matcher :assignment?,
-                  '{equals_asgn? shorthand_asgn? asgn_method_call?}'
+      def arithmetic_operation?
+        ARITHMETIC_OPERATORS.include?(method_name)
+      end
+
+      def_node_matcher :equals_asgn?, <<-PATTERN
+        {lvasgn ivasgn cvasgn gvasgn casgn masgn}
+      PATTERN
+
+      def_node_matcher :shorthand_asgn?, '{op_asgn or_asgn and_asgn}'
+
+      def_node_matcher :assignment?, <<-PATTERN
+        {equals_asgn? shorthand_asgn? asgn_method_call?}
+      PATTERN
 
       def literal?
         LITERALS.include?(type)
@@ -368,7 +389,7 @@ module RuboCop
           case type
           when :send
             receiver, method_name, *args = *self
-            COMPARISON_OPERATORS.include?(method_name) &&
+            [*COMPARISON_OPERATORS, :!, :<=>].include?(method_name) &&
               receiver.send(recursive_kind) &&
               args.all?(&recursive_kind)
           when :begin, :pair, *OPERATOR_KEYWORDS, *COMPOSITE_LITERALS
@@ -439,24 +460,25 @@ module RuboCop
         int_type? || float_type?
       end
 
-      def_matcher :guard_clause?, <<-PATTERN
-        [{(send nil {:raise :fail} ...) return break next} single_line?]
+      def_node_matcher :guard_clause?, <<-PATTERN
+        [{(send nil? {:raise :fail} ...) return break next} single_line?]
       PATTERN
 
-      def_matcher :lambda?, '(block (send nil :lambda) ...)'
-      def_matcher :proc?, <<-PATTERN
-        {(block (send nil :proc) ...)
-         (block (send (const nil :Proc) :new) ...)
-         (send (const nil :Proc) :new)}
+      def_node_matcher :proc?, <<-PATTERN
+        {(block (send nil? :proc) ...)
+         (block (send (const nil? :Proc) :new) ...)
+         (send (const nil? :Proc) :new)}
       PATTERN
-      def_matcher :lambda_or_proc?, '{lambda? proc?}'
 
-      def_matcher :class_constructor?, <<-PATTERN
-        {       (send (const nil {:Class :Module}) :new ...)
-         (block (send (const nil {:Class :Module}) :new ...) ...)}
+      def_node_matcher :lambda?, '(block (send nil? :lambda) ...)'
+      def_node_matcher :lambda_or_proc?, '{lambda? proc?}'
+
+      def_node_matcher :class_constructor?, <<-PATTERN
+        {       (send (const nil? {:Class :Module}) :new ...)
+         (block (send (const nil? {:Class :Module}) :new ...) ...)}
       PATTERN
 
-      def_matcher :module_definition?, <<-PATTERN
+      def_node_matcher :module_definition?, <<-PATTERN
         {class module (casgn _ _ class_constructor?)}
       PATTERN
 
@@ -468,7 +490,7 @@ module RuboCop
       # So, does the return value of this node matter? If we changed it to
       # `(...; nil)`, might that affect anything?
       #
-      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
       def value_used?
         # Be conservative and return true if we're not sure.
         return false if parent.nil?
@@ -490,7 +512,7 @@ module RuboCop
           true
         end
       end
-      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       # Some expressions are evaluated for their value, some for their side
       # effects, and some for both.
@@ -596,15 +618,9 @@ module RuboCop
         end
       end
 
-      def new_class_or_module_block?(block_node)
-        receiver = block_node.receiver
-
-        block_node.method_name == :new &&
-          receiver && receiver.const_type? &&
-          (receiver.const_name == 'Class' || receiver.const_name == 'Module') &&
-          block_node.parent &&
-          block_node.parent.casgn_type?
-      end
+      def_node_matcher :new_class_or_module_block?, <<-PATTERN
+        ^(casgn _ _ (block (send (const _ {:Class :Module}) :new) ...))
+      PATTERN
     end
   end
 end

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

@@ -6,18 +6,23 @@ module RuboCop
     # node when the builder constructs the AST, making its methods available
     # to all `args` nodes within RuboCop.
     class ArgsNode < Node
-      # Whether this `args` node has any arguments.
-      #
-      # @return [Boolean] whether this `args` node has any arguments
-      def empty?
-        to_a.empty?
-      end
+      include CollectionNode
 
-      # The number of arguments in this `args` node.
+      # It returns true if arguments are empty, and delimiters do not exist.
+      # @example:
+      #   # true
+      #   def x; end
+      #   x { }
+      #   -> {}
       #
-      # @return [Integer] the number of arguments in this `args` node
-      def size
-        to_a.size
+      #   # false
+      #   def x(); end
+      #   def x a; end
+      #   x { || }
+      #   -> () {}
+      #   -> a {}
+      def empty_and_without_delimiters?
+        loc.expression.nil?
       end
     end
   end

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

@@ -31,7 +31,7 @@ module RuboCop
       #   Check for any percent literal.
       #
       # @overload percent_literal?(type)
-      #   Check for percent literaly of type `type`.
+      #   Check for percent literal of type `type`.
       #
       #   @param type [Symbol] an optional percent literal type
       #
@@ -43,6 +43,15 @@ module RuboCop
           loc.begin && loc.begin.source.start_with?('%')
         end
       end
+
+      # Checks whether the `array` literal is delimited by either percent or
+      # square brackets
+      #
+      # @return [Boolean] whether the array is enclosed in percent or square
+      # brackets
+      def bracketed?
+        square_brackets? || percent_literal?
+      end
     end
   end
 end

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

@@ -9,6 +9,8 @@ module RuboCop
     # A `block` node is essentially a method send with a block. Parser nests
     # the `send` node inside the `block` node.
     class BlockNode < Node
+      VOID_CONTEXT_METHODS = %i[each].freeze
+
       # The `send` node associated with this block.
       #
       # @return [SendNode] the `send` node associated with the `block` node
@@ -95,6 +97,13 @@ module RuboCop
         send_node.method?(:lambda)
       end
 
+      # Checks whether this node body is a void context.
+      #
+      # @return [Boolean] whether the `block` node body is a void context
+      def void_context?
+        VOID_CONTEXT_METHODS.include?(send_node.method_name)
+      end
+
       # Custom destructuring method. This can be used to normalize
       # destructuring for different variations of the node.
       #

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `def` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `def` nodes within RuboCop.
+    class DefNode < Node
+      include ParameterizedNode
+      include MethodIdentifierPredicates
+
+      # Checks whether this node body is a void context.
+      #
+      # @return [Boolean] whether the `def` node body is a void context
+      def void_context?
+        method?(:initialize) || assignment_method?
+      end
+
+      # The name of the defined method as a symbol.
+      #
+      # @return [Symbol] the name of the defined method
+      def method_name
+        node_parts[2]
+      end
+
+      # An array containing the arguments of the method definition.
+      #
+      # @return [Array<Node>] the arguments of the method definition
+      def arguments
+        node_parts[1]
+      end
+
+      # The body of the method definition.
+      #
+      # @note this can be either a `begin` node, if the method body contains
+      #       multiple expressions, or any other node, if it contains a single
+      #       expression.
+      #
+      # @return [Node] the body of the method definition
+      def body
+        node_parts[0]
+      end
+
+      # The receiver of the method definition, if any.
+      #
+      # @return [Node, nil] the receiver of the method definition, or `nil`.
+      def receiver
+        node_parts[3]
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # In this case, the `def` node destructures into:
+      #
+      #   `method_name, arguments, body`
+      #
+      # while the `defs` node destructures into:
+      #
+      #   `receiver, method_name, arguments, body`
+      #
+      # so we reverse the destructured array to get the optional receiver
+      # at the end, where it can be discarded.
+      #
+      # @return [Array] the different parts of the `def` or `defs` node
+      def node_parts
+        to_a.reverse
+      end
+    end
+  end
+end

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

@@ -20,6 +20,14 @@ module RuboCop
         loc.begin && loc.begin.is?('do')
       end
 
+      # Checks whether this node body is a void context.
+      # Always `true` for `for`.
+      #
+      # @return [true] whether the `for` node body is a void context
+      def void_context?
+        true
+      end
+
       # Returns the iteration variable of the `for` loop.
       #
       # @return [Node] The iteration variable of the `for` loop

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

@@ -82,10 +82,10 @@ module RuboCop
         (if? || unless?) && super
       end
 
-      # Chackes whether the `if` node has nested `if` nodes in any of its
+      # Chacks whether the `if` node has nested `if` nodes in any of its
       # branches.
       #
-      # @note This is a shallow search.
+      # @note This performs a shallow search.
       #
       # @return [Boolean] whether the `if` node contains nested conditionals
       def nested_conditional?
@@ -98,6 +98,14 @@ module RuboCop
         false
       end
 
+      # Checks whether the `if` node has at least one `elsif` branch. Returns
+      # true if this `if` node itself is an `elsif`.
+      #
+      # @return [Boolean] whether the `if` node has at least one `elsif` branch
+      def elsif_conditional?
+        else_branch && else_branch.if_type? && else_branch.elsif?
+      end
+
       # Returns the branch of the `if` node that gets evaluated when its
       # condition is truthy.
       #

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for primitive literal nodes: `sym`, `str`,
+    # `int`, `float`, ...
+    module BasicLiteralNode
+      # Returns the value of the literal.
+      #
+      # @return [mixed] the value of the literal
+      def value
+        node_parts[0]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A mixin that helps give collection nodes array polymorphism.
+    module CollectionNode
+      extend Forwardable
+
+      ARRAY_METHODS =
+        (Array.instance_methods - Object.instance_methods - [:to_a]).freeze
+
+      def_delegators :to_a, *ARRAY_METHODS
+    end
+  end
+end