rubocop-ast 1.32.3 → 1.38.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 289c6acb690241440018fb6d23e23759c6cf52100b2bf373b47226ee71cad215
-  data.tar.gz: 45cd10ff396ddf599ac11277b5d14a2e7cede79b267a40b2e53a83ccd2580479
+  metadata.gz: c7fd9852873f22808386ddc6962f7373509ec03930f3e5c667475d512480b705
+  data.tar.gz: b6d36926cd045b8486679af378d1fdd21875b941d3f5916fbb6876f04ef75e11
 SHA512:
-  metadata.gz: 137d5b737b87e1a136b23c6ae6b591334e5971e923c01727c37280b42e96a0a41fc534b54e8ea1b83074256b5d6645f86c079977fd72ffd6404d9f4eb61d92c6
-  data.tar.gz: d7c4e19d909f3591b4f7460a54e50f77555d37b517baa86359c635a2b32eeb119804464fb17c95adc69f23147f3023322142d44117f0e9ea0262e8c1fdd3aec2
+  metadata.gz: b83bb3a5b3c20a8831d6ad8e075d536b3ff8042d873ce6062161fbe1556e80da5fc4646499dc0432864ecb034ffe3ade83f7ac2f37562a9df22620b486e61e5a
+  data.tar.gz: d6f98f800797330d515911991c9215e8fa616cdcde7a73666aa0d25ff05b70b9274a1f0df689f8a820a6573c391bca487100a258a142c21a60f3fd8ea6e5c5e8

data/lib/rubocop/ast/builder.rb

@@ -63,8 +63,11 @@ module RuboCop
         irange:              RangeNode,
         erange:              RangeNode,
         kwargs:              HashNode,
+        kwbegin:             KeywordBeginNode,
         kwsplat:             KeywordSplatNode,
         lambda:              LambdaNode,
+        masgn:               MasgnNode,
+        mlhs:                MlhsNode,
         module:              ModuleNode,
         next:                NextNode,
         op_asgn:             OpAsgnNode,
@@ -87,6 +90,10 @@ module RuboCop
         sym:                 SymbolNode,
         until:               UntilNode,
         until_post:          UntilNode,
+        lvar:                VarNode,
+        ivar:                VarNode,
+        cvar:                VarNode,
+        gvar:                VarNode,
         when:                WhenNode,
         while:               WhileNode,
         while_post:          WhileNode,

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

@@ -32,7 +32,7 @@ module RuboCop
       #
       # @return [Array<Node>] array of argument nodes.
       def argument_list
-        each_descendant(*ARGUMENT_TYPES).to_a.freeze
+        each_descendant(:argument).to_a.freeze
       end
     end
   end

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

@@ -7,8 +7,8 @@ module RuboCop
     # to all `array` nodes within RuboCop.
     class ArrayNode < Node
       PERCENT_LITERAL_TYPES = {
-        string: /^%[wW]/,
-        symbol: /^%[iI]/
+        string: /\A%[wW]/,
+        symbol: /\A%[iI]/
       }.freeze
       private_constant :PERCENT_LITERAL_TYPES
 
@@ -34,7 +34,7 @@ module RuboCop
       #
       # @return [Boolean] whether the array is enclosed in square brackets
       def square_brackets?
-        loc.begin&.is?('[')
+        loc_is?(:begin, '[')
       end
 
       # Checks whether the `array` literal is delimited by percent brackets.
@@ -50,7 +50,7 @@ module RuboCop
       # @return [Boolean] whether the array is enclosed in percent brackets
       def percent_literal?(type = nil)
         if type
-          loc.begin && loc.begin.source =~ PERCENT_LITERAL_TYPES[type]
+          loc.begin&.source&.match?(PERCENT_LITERAL_TYPES.fetch(type))
         else
           loc.begin&.source&.start_with?('%')
         end

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

@@ -12,6 +12,7 @@ module RuboCop
       def name
         node_parts[0]
       end
+      alias lhs name
 
       # The expression being assigned to the variable.
       #
@@ -19,6 +20,7 @@ module RuboCop
       def expression
         node_parts[1]
       end
+      alias rhs expression
     end
   end
 end

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

@@ -90,14 +90,14 @@ module RuboCop
       #
       # @return [Boolean] whether the `block` literal is enclosed in braces
       def braces?
-        loc.end&.is?('}')
+        loc.end.is?('}')
       end
 
       # Checks whether the `block` literal is delimited by `do`-`end` keywords.
       #
       # @return [Boolean] whether the `block` literal is enclosed in `do`-`end`
       def keywords?
-        loc.end&.is?('end')
+        loc.end.is?('end')
       end
 
       # The delimiters for this `block` literal.

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

@@ -6,19 +6,10 @@ module RuboCop
     # This will be used in place of a plain node when the builder constructs
     # the AST, making its methods available to all assignment nodes within RuboCop.
     class CasgnNode < Node
-      # The namespace of the constant being assigned.
-      #
-      # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
-      def namespace
-        node_parts[0]
-      end
+      include ConstantNode
 
-      # The name of the variable being assigned as a symbol.
-      #
-      # @return [Symbol] the name of the variable being assigned
-      def name
-        node_parts[1]
-      end
+      alias name short_name
+      alias lhs short_name
 
       # The expression being assigned to the variable.
       #
@@ -26,6 +17,7 @@ module RuboCop
       def expression
         node_parts[2]
       end
+      alias rhs expression
     end
   end
 end

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

@@ -4,58 +4,7 @@ module RuboCop
   module AST
     # A node extension for `const` nodes.
     class ConstNode < Node
-      # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
-      def namespace
-        children[0]
-      end
-
-      # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar
-      def short_name
-        children[1]
-      end
-
-      # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
-      #                   Note: some classes might have uppercase in which case this method
-      #                         returns false
-      def module_name?
-        short_name.match?(/[[:lower:]]/)
-      end
-      alias class_name? module_name?
-
-      # @return [Boolean] if the constant starts with `::` (aka s(:cbase))
-      def absolute?
-        return false unless namespace
-
-        each_path.first.cbase_type?
-      end
-
-      # @return [Boolean] if the constant does not start with `::` (aka s(:cbase))
-      def relative?
-        !absolute?
-      end
-
-      # Yield nodes for the namespace
-      #
-      #   For `::Foo::Bar::BAZ` => yields:
-      #      s(:cbase), then
-      #      s(:const, :Foo), then
-      #      s(:const, s(:const, :Foo), :Bar)
-      def each_path(&block)
-        return to_enum(__method__) unless block
-
-        descendants = []
-        last = self
-        loop do
-          last = last.children.first
-          break if last.nil?
-
-          descendants << last
-          break unless last.const_type?
-        end
-        descendants.reverse_each(&block)
-
-        self
-      end
+      include ConstantNode
     end
   end
 end

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

@@ -9,10 +9,25 @@ module RuboCop
       # Returns the body of the `ensure` clause.
       #
       # @return [Node, nil] The body of the `ensure`.
+      # @deprecated Use `EnsureNode#branch`
       def body
+        branch
+      end
+
+      # Returns an the ensure branch in the exception handling statement.
+      #
+      # @return [Node, nil] the body of the ensure branch.
+      def branch
         node_parts[1]
       end
 
+      # Returns the `rescue` node of the `ensure`, if present.
+      #
+      # @return [Node, nil] The `rescue` node.
+      def rescue_node
+        node_parts[0] if node_parts[0].rescue_type?
+      end
+
       # Checks whether this node body is a void context.
       # Always `true` for `ensure`.
       #

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

@@ -17,7 +17,7 @@ module RuboCop
       #
       # @return [Boolean] whether the `for` node has a `do` keyword
       def do?
-        loc.begin&.is?('do')
+        loc_is?(:begin, 'do')
       end
 
       # Checks whether this node body is a void context.

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

@@ -115,7 +115,7 @@ module RuboCop
       #
       # @return [Boolean] whether the `hash` literal is enclosed in braces
       def braces?
-        loc.end&.is?('}')
+        loc_is?(:end, '}')
       end
     end
   end

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

@@ -25,6 +25,13 @@ module RuboCop
         keyword == 'unless'
       end
 
+      # Checks whether the `if` node has an `then` clause.
+      #
+      # @return [Boolean] whether the node has an `then` clause
+      def then?
+        loc_is?(:begin, 'then')
+      end
+
       # Checks whether the `if` is an `elsif`. Parser handles these by nesting
       # `if` nodes in the `else` branch.
       #
@@ -40,14 +47,14 @@ module RuboCop
       #
       # @return [Boolean] whether the node has an `else` clause
       def else?
-        loc.respond_to?(:else) && loc.else
+        loc?(:else)
       end
 
       # Checks whether the `if` node is a ternary operator.
       #
       # @return [Boolean] whether the `if` node is a ternary operator
       def ternary?
-        loc.respond_to?(:question)
+        loc?(:question)
       end
 
       # Returns the keyword of the `if` statement as a string. Returns an empty
@@ -102,7 +109,7 @@ module RuboCop
       #
       # @return [Boolean] whether the `if` node has at least one `elsif` branch
       def elsif_conditional?
-        else_branch&.if_type? && else_branch&.elsif?
+        else_branch&.if_type? && else_branch.elsif?
       end
 
       # Returns the branch of the `if` node that gets evaluated when its

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

@@ -24,7 +24,7 @@ module RuboCop
       #
       # @return [Boolean] whether the `in` node has a `then` keyword
       def then?
-        loc.begin&.is?('then')
+        loc_is?(:begin, 'then')
       end
 
       # Returns the body of the `in` node.

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `kwbegin` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `kwbegin` nodes within RuboCop.
+    class KeywordBeginNode < Node
+      # Returns the body of the `kwbegin` block. Returns `self` if the `kwbegin` contains
+      # multiple nodes.
+      #
+      # @return [Node, nil] The body of the `kwbegin`.
+      def body
+        return unless node_parts.any?
+
+        if rescue_node
+          rescue_node.body
+        elsif ensure_node
+          ensure_node.node_parts[0]
+        elsif node_parts.one?
+          node_parts[0]
+        else
+          self
+        end
+      end
+
+      # Returns the `rescue` node of the `kwbegin` block, if one is present.
+      #
+      # @return [Node, nil] The `rescue` node within `kwbegin`.
+      def ensure_node
+        node_parts[0] if node_parts[0]&.ensure_type?
+      end
+
+      # Returns the `rescue` node of the `kwbegin` block, if one is present.
+      #
+      # @return [Node, nil] The `rescue` node within `kwbegin`.
+      def rescue_node
+        return ensure_node&.rescue_node if ensure_node&.rescue_node
+
+        node_parts[0] if node_parts[0]&.rescue_type?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `masgn` nodes.
+    # This will be used in place of a plain node when the builder constructs
+    # the AST, making its methods available to all assignment nodes within RuboCop.
+    class MasgnNode < Node
+      # @return [MlhsNode] the `mlhs` node
+      def lhs
+        # The first child is a `mlhs` node
+        node_parts[0]
+      end
+
+      # @return [Array<Node>] the assignment nodes of the multiple assignment
+      def assignments
+        lhs.assignments
+      end
+
+      # @return [Array<Symbol>] names of all the variables being assigned
+      def names
+        assignments.map do |assignment|
+          if assignment.type?(:send, :indexasgn)
+            assignment.method_name
+          else
+            assignment.name
+          end
+        end
+      end
+
+      # The RHS (right hand side) of the multiple assignment. This returns
+      # the nodes as parsed: either a single node if the RHS has a single value,
+      # or an `array` node containing multiple nodes.
+      #
+      # NOTE: Due to how parsing works, `expression` will return the same for
+      # `a, b = x, y` and `a, b = [x, y]`.
+      #
+      # @return [Node] the right hand side of a multiple assignment.
+      def expression
+        node_parts[1]
+      end
+      alias rhs expression
+
+      # In contrast to `expression`, `values` always returns a Ruby array
+      # containing all the nodes being assigned on the RHS.
+      #
+      # Literal arrays are considered a singular value; but unlike `expression`,
+      # implied `array` nodes from assigning multiple values on the RHS are treated
+      # as separate.
+      #
+      # @return [Array<Node>] individual values being assigned on the RHS of the multiple assignment
+      def values
+        multiple_rhs? ? expression.children : [expression]
+      end
+
+      private
+
+      def multiple_rhs?
+        expression.array_type? && !expression.bracketed?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that deal with constants:
+    # `const`, `casgn`.
+    module ConstantNode
+      # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
+      def namespace
+        children[0]
+      end
+
+      # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar
+      def short_name
+        children[1]
+      end
+
+      # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
+      #                   Note: some classes might have uppercase in which case this method
+      #                         returns false
+      def module_name?
+        short_name.match?(/[[:lower:]]/)
+      end
+      alias class_name? module_name?
+
+      # @return [Boolean] if the constant starts with `::` (aka s(:cbase))
+      def absolute?
+        return false unless namespace
+
+        each_path.first.cbase_type?
+      end
+
+      # @return [Boolean] if the constant does not start with `::` (aka s(:cbase))
+      def relative?
+        !absolute?
+      end
+
+      # Yield nodes for the namespace
+      #
+      #   For `::Foo::Bar::BAZ` => yields:
+      #      s(:cbase), then
+      #      s(:const, :Foo), then
+      #      s(:const, s(:const, :Foo), :Bar)
+      def each_path(&block)
+        return to_enum(__method__) unless block
+
+        descendants = []
+        last = self
+        loop do
+          last = last.children.first
+          break if last.nil?
+
+          descendants << last
+          break unless last.const_type?
+        end
+        descendants.reverse_each(&block)
+
+        self
+      end
+    end
+  end
+end

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

@@ -25,7 +25,7 @@ module RuboCop
         children.each do |child|
           next unless child.is_a?(::AST::Node)
 
-          yield child if types.empty? || types.include?(child.type)
+          yield child if types.empty? || child.type?(*types)
         end
 
         self
@@ -95,7 +95,7 @@ module RuboCop
       def each_node(*types, &block)
         return to_enum(__method__, *types) unless block
 
-        yield self if types.empty? || types.include?(type)
+        yield self if types.empty? || type?(*types)
 
         visit_descendants(types, &block)
 
@@ -108,7 +108,7 @@ module RuboCop
         children.each do |child|
           next unless child.is_a?(::AST::Node)
 
-          yield child if types.empty? || types.include?(child.type)
+          yield child if types.empty? || child.type?(*types)
           child.visit_descendants(types, &block)
         end
       end

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

@@ -99,7 +99,9 @@ module RuboCop
 
         def valid_argument_types?
           [first, second].all? do |argument|
+            # rubocop:disable InternalAffairs/NodeTypeMultiplePredicates
             argument.pair_type? || argument.kwsplat_type?
+            # rubocop:enable InternalAffairs/NodeTypeMultiplePredicates
           end
         end
 

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

@@ -105,7 +105,7 @@ module RuboCop
       #
       # @return [Boolean] whether the dispatched method is a setter
       def setter_method?
-        loc.respond_to?(:operator) && loc.operator
+        loc?(:operator)
       end
       alias assignment? setter_method?
 
@@ -117,7 +117,7 @@ module RuboCop
       #
       # @return [Boolean] whether the method was called with a connecting dot
       def dot?
-        loc.respond_to?(:dot) && loc.dot && loc.dot.is?('.')
+        loc_is?(:dot, '.')
       end
 
       # Checks whether the dispatched method uses a double colon to connect the
@@ -125,7 +125,7 @@ module RuboCop
       #
       # @return [Boolean] whether the method was called with a connecting dot
       def double_colon?
-        loc.respond_to?(:dot) && loc.dot && loc.dot.is?('::')
+        loc_is?(:dot, '::')
       end
 
       # Checks whether the dispatched method uses a safe navigation operator to
@@ -133,7 +133,7 @@ module RuboCop
       #
       # @return [Boolean] whether the method was called with a connecting dot
       def safe_navigation?
-        loc.respond_to?(:dot) && loc.dot && loc.dot.is?('&.')
+        loc_is?(:dot, '&.')
       end
 
       # Checks whether the *explicit* receiver of this method dispatch is
@@ -165,7 +165,7 @@ module RuboCop
       #
       # @return [Boolean] whether the dispatched method has a block
       def block_literal?
-        (parent&.block_type? || parent&.numblock_type?) && eql?(parent.send_node)
+        parent&.any_block_type? && eql?(parent.send_node)
       end
 
       # Checks whether this node is an arithmetic operation
@@ -201,7 +201,7 @@ module RuboCop
 
         return unless node.send_type? && node.receiver.nil? && arg.is_a?(::AST::Node)
 
-        return arg if arg.def_type? || arg.defs_type?
+        return arg if arg.type?(:def, :defs)
 
         def_modifier(arg)
       end
@@ -260,7 +260,7 @@ module RuboCop
           ^{                                       # or the parent is...
             sclass class module class_constructor? # a class-like node
             [ {                                    # or some "wrapper"
-                kwbegin begin block numblock
+                kwbegin begin any_block
                 (if _condition <%0 _>)  # note: we're excluding the condition of `if` nodes
               }
               #in_macro_scope?                     # that is itself in a macro scope
@@ -281,7 +281,7 @@ module RuboCop
 
       # @!method non_bare_access_modifier_declaration?(node = self)
       def_node_matcher :non_bare_access_modifier_declaration?, <<~PATTERN
-        (send nil? {:public :protected :private :module_function} _)
+        (send nil? {:public :protected :private :module_function} _+)
       PATTERN
     end
   end

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

@@ -13,7 +13,7 @@ module RuboCop
       # @return [Boolean] whether this node's arguments are
       #                   wrapped in parentheses
       def parenthesized?
-        loc.end&.is?(')')
+        loc_is?(:end, ')')
       end
 
       # A shorthand for getting the first argument of the node.
@@ -57,7 +57,7 @@ module RuboCop
       # @return [Boolean] whether the last argument of the node is a block pass
       def block_argument?
         arguments? &&
-          (last_argument.block_pass_type? || last_argument.blockarg_type?)
+          last_argument.type?(:block_pass, :blockarg)
       end
 
       # A specialized `ParameterizedNode` for node that have a single child

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

@@ -14,6 +14,11 @@ module RuboCop
       SEMANTIC_OR = 'or'
       private_constant :SEMANTIC_OR
 
+      LOGICAL_OPERATORS = [LOGICAL_AND, LOGICAL_OR].freeze
+      private_constant :LOGICAL_OPERATORS
+      SEMANTIC_OPERATORS = [SEMANTIC_AND, SEMANTIC_OR].freeze
+      private_constant :SEMANTIC_OPERATORS
+
       # Returns the operator as a string.
       #
       # @return [String] the operator
@@ -25,14 +30,14 @@ module RuboCop
       #
       # @return [Boolean] whether this is a logical operator
       def logical_operator?
-        operator == LOGICAL_AND || operator == LOGICAL_OR
+        LOGICAL_OPERATORS.include?(operator)
       end
 
       # Checks whether this is a semantic operator.
       #
       # @return [Boolean] whether this is a semantic operator
       def semantic_operator?
-        operator == SEMANTIC_AND || operator == SEMANTIC_OR
+        SEMANTIC_OPERATORS.include?(operator)
       end
     end
   end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `mlhs` nodes.
+    # This will be used in place of a plain node when the builder constructs
+    # the AST, making its methods available to all assignment nodes within RuboCop.
+    class MlhsNode < Node
+      # Returns all the assignment nodes on the left hand side (LHS) of a multiple assignment.
+      # These are generally assignment nodes (`lvasgn`, `ivasgn`, `cvasgn`, `gvasgn`, `casgn`)
+      # but can also be `send` nodes in case of `foo.bar, ... =` or `foo[:bar], ... =`,
+      # or a `splat` node for `*, ... =`.
+      #
+      # @return [Array<Node>] the assignment nodes of the multiple assignment LHS
+      def assignments
+        child_nodes.flat_map do |node|
+          if node.splat_type?
+            # Anonymous splats have no children
+            node.child_nodes.first || node
+          elsif node.mlhs_type?
+            node.assignments
+          else
+            node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,12 +10,13 @@ module RuboCop
       def assignment_node
         node_parts[0]
       end
+      alias lhs assignment_node
 
       # The name of the variable being assigned as a symbol.
       #
       # @return [Symbol] the name of the variable being assigned
       def name
-        assignment_node.name
+        assignment_node.call_type? ? assignment_node.method_name : assignment_node.name
       end
 
       # The operator being used for assignment as a symbol.
@@ -31,6 +32,7 @@ module RuboCop
       def expression
         node_parts.last
       end
+      alias rhs expression
     end
   end
 end