rubocop-ast 0.4.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bf5651a5da2be43d773d152c2f2260dfd1850ce1075aca7c4d21c08dd31a92a
-  data.tar.gz: c9addcd67e29e797109dc2f523c9c2094f94908b40c2e60c56061d6a8bf0e0f5
+  metadata.gz: eae5a550b84ac088fb1065c539710b04b9885883c367ab0b26f8d3b455291ccb
+  data.tar.gz: 424d68c1b31693d5de3dc83aaf88823147ecf5a446c2b68f39c8e992f9b10c4e
 SHA512:
-  metadata.gz: 1aa33edeacd95a65468093b80248a5908c69d30bf7d19afd6141044d00830f31c12aa489caf8ef705364d63771cade73651d9697635ab22941137df467ce4e92
-  data.tar.gz: fb820b52d69df72ab17a5ee06d06bdf7256b3318d8094b96467f79d314bad1b52bcb3938cb2ef98ca07b300f56132ac14921ef24aadf299d4c5754bb118b119f
+  metadata.gz: e16362b75f0e898818a6bfd9a17fc83d86f682fd83328d07ed5bd71a561dfc4b8d3f9bab97e8175f367969dd2938666bb6b5d6ea21a18e65d9760fc83df1201e
+  data.tar.gz: c32c20ef1936d110845c9564680c57753cb2f22c0fc4a98b13a8a7e7dfe18f7920c8f2ef96f8a3fafcdaf566e0f41b3214d6988dad1dc1416b3c70437cee046f

data/lib/rubocop/ast.rb

@@ -6,7 +6,21 @@ require 'set'
 
 require_relative 'ast/ext/range'
 require_relative 'ast/ext/set'
+require_relative 'ast/node_pattern/method_definer'
 require_relative 'ast/node_pattern'
+require_relative 'ast/node/mixin/descendence'
+require_relative 'ast/node_pattern/builder'
+require_relative 'ast/node_pattern/comment'
+require_relative 'ast/node_pattern/compiler'
+require_relative 'ast/node_pattern/compiler/subcompiler'
+require_relative 'ast/node_pattern/compiler/atom_subcompiler'
+require_relative 'ast/node_pattern/compiler/binding'
+require_relative 'ast/node_pattern/compiler/node_pattern_subcompiler'
+require_relative 'ast/node_pattern/compiler/sequence_subcompiler'
+require_relative 'ast/node_pattern/lexer'
+require_relative 'ast/node_pattern/node'
+require_relative 'ast/node_pattern/parser'
+require_relative 'ast/node_pattern/sets'
 require_relative 'ast/sexp'
 require_relative 'ast/node'
 require_relative 'ast/node/mixin/method_identifier_predicates'
@@ -63,6 +77,10 @@ require_relative 'ast/node/while_node'
 require_relative 'ast/node/yield_node'
 require_relative 'ast/builder'
 require_relative 'ast/processed_source'
+require_relative 'ast/rubocop_compatibility'
 require_relative 'ast/token'
 require_relative 'ast/traversal'
 require_relative 'ast/version'
+
+::RuboCop::AST::NodePattern::Parser.autoload :WithMeta, "#{__dir__}/ast/node_pattern/with_meta"
+::RuboCop::AST::NodePattern::Compiler.autoload :Debug, "#{__dir__}/ast/node_pattern/compiler/debug"

data/lib/rubocop/ast/builder.rb

@@ -16,6 +16,7 @@ module RuboCop
     class Builder < Parser::Builders::Default
       self.emit_forward_arg = true
 
+      # @api private
       NODE_MAP = {
         and:          AndNode,
         alias:        AliasNode,

data/lib/rubocop/ast/node.rb

@@ -21,41 +21,67 @@ module RuboCop
     class Node < Parser::AST::Node # rubocop:disable Metrics/ClassLength
       include RuboCop::AST::Sexp
       extend NodePattern::Macros
+      include RuboCop::AST::Descendence
 
+      # @api private
       # <=> isn't included here, because it doesn't return a boolean.
-      COMPARISON_OPERATORS = %i[== === != <= >= > <].freeze
+      COMPARISON_OPERATORS = %i[== === != <= >= > <].to_set.freeze
 
+      # @api private
       TRUTHY_LITERALS = %i[str dstr xstr int float sym dsym array
                            hash regexp true irange erange complex
-                           rational regopt].freeze
-      FALSEY_LITERALS = %i[false nil].freeze
+                           rational regopt].to_set.freeze
+      # @api private
+      FALSEY_LITERALS = %i[false nil].to_set.freeze
+      # @api private
       LITERALS = (TRUTHY_LITERALS + FALSEY_LITERALS).freeze
+      # @api private
       COMPOSITE_LITERALS = %i[dstr xstr dsym array hash irange
-                              erange regexp].freeze
+                              erange regexp].to_set.freeze
+      # @api private
       BASIC_LITERALS = (LITERALS - COMPOSITE_LITERALS).freeze
+      # @api private
       MUTABLE_LITERALS = %i[str dstr xstr array hash
-                            regexp irange erange].freeze
+                            regexp irange erange].to_set.freeze
+      # @api private
       IMMUTABLE_LITERALS = (LITERALS - MUTABLE_LITERALS).freeze
 
+      # @api private
       EQUALS_ASSIGNMENTS = %i[lvasgn ivasgn cvasgn gvasgn
-                              casgn masgn rasgn mrasgn].freeze
-      SHORTHAND_ASSIGNMENTS = %i[op_asgn or_asgn and_asgn].freeze
+                              casgn masgn rasgn mrasgn].to_set.freeze
+      # @api private
+      SHORTHAND_ASSIGNMENTS = %i[op_asgn or_asgn and_asgn].to_set.freeze
+      # @api private
       ASSIGNMENTS = (EQUALS_ASSIGNMENTS + SHORTHAND_ASSIGNMENTS).freeze
 
-      BASIC_CONDITIONALS = %i[if while until].freeze
-      CONDITIONALS = [*BASIC_CONDITIONALS, :case].freeze
-      POST_CONDITION_LOOP_TYPES = %i[while_post until_post].freeze
+      # @api private
+      BASIC_CONDITIONALS = %i[if while until].to_set.freeze
+      # @api private
+      CONDITIONALS = (BASIC_CONDITIONALS + [:case]).freeze
+      # @api private
+      POST_CONDITION_LOOP_TYPES = %i[while_post until_post].to_set.freeze
+      # @api private
       LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + %i[while until for]).freeze
-      VARIABLES = %i[ivar gvar cvar lvar].freeze
-      REFERENCES = %i[nth_ref back_ref].freeze
+      # @api private
+      VARIABLES = %i[ivar gvar cvar lvar].to_set.freeze
+      # @api private
+      REFERENCES = %i[nth_ref back_ref].to_set.freeze
+      # @api private
       KEYWORDS = %i[alias and break case class def defs defined?
                     kwbegin do else ensure for if module next
                     not or postexe redo rescue retry return self
                     super zsuper then undef until when while
-                    yield].freeze
-      OPERATOR_KEYWORDS = %i[and or].freeze
-      SPECIAL_KEYWORDS = %w[__FILE__ __LINE__ __ENCODING__].freeze
-      ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].freeze
+                    yield].to_set.freeze
+      # @api private
+      OPERATOR_KEYWORDS = %i[and or].to_set.freeze
+      # @api private
+      SPECIAL_KEYWORDS = %w[__FILE__ __LINE__ __ENCODING__].to_set.freeze
+      # @api private
+      ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].to_set.freeze
+
+      LITERAL_RECURSIVE_METHODS = (COMPARISON_OPERATORS + %i[* ! <=>]).freeze
+      LITERAL_RECURSIVE_TYPES = (OPERATOR_KEYWORDS + COMPOSITE_LITERALS + %i[begin pair]).freeze
+      private_constant :LITERAL_RECURSIVE_METHODS, :LITERAL_RECURSIVE_TYPES
 
       # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize
       def initialize(type, children = [], properties = {})
@@ -92,6 +118,16 @@ module RuboCop
         @mutable_attributes[:parent] = node
       end
 
+      # @return [Boolean]
+      def parent?
+        !!parent
+      end
+
+      # @return [Boolean]
+      def root?
+        !parent
+      end
+
       def complete!
         @mutable_attributes.freeze
         each_child_node(&:complete!)
@@ -201,106 +237,10 @@ module RuboCop
         each_ancestor.to_a
       end
 
-      # Calls the given block for each child node.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # Note that this is different from `node.children.each { |child| ... }`
-      # which yields all children including non-node elements.
-      #
-      # @overload each_child_node
-      #   Yield all nodes.
-      # @overload each_child_node(type)
-      #   Yield only nodes matching the type.
-      #   @param [Symbol] type a node type
-      # @overload each_child_node(type_a, type_b, ...)
-      #   Yield only nodes matching any of the types.
-      #   @param [Symbol] type_a a node type
-      #   @param [Symbol] type_b a node type
-      # @yieldparam [Node] node each child node
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
-      def each_child_node(*types)
-        return to_enum(__method__, *types) unless block_given?
-
-        children.each do |child|
-          next unless child.is_a?(Node)
-
-          yield child if types.empty? || types.include?(child.type)
-        end
-
-        self
-      end
-
-      # Returns an array of child nodes.
-      # This is a shorthand for `node.each_child_node.to_a`.
-      #
-      # @return [Array<Node>] an array of child nodes
-      def child_nodes
-        each_child_node.to_a
-      end
-
-      # Calls the given block for each descendant node with depth first order.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # @overload each_descendant
-      #   Yield all nodes.
-      # @overload each_descendant(type)
-      #   Yield only nodes matching the type.
-      #   @param [Symbol] type a node type
-      # @overload each_descendant(type_a, type_b, ...)
-      #   Yield only nodes matching any of the types.
-      #   @param [Symbol] type_a a node type
-      #   @param [Symbol] type_b a node type
-      # @yieldparam [Node] node each descendant node
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
-      def each_descendant(*types, &block)
-        return to_enum(__method__, *types) unless block_given?
-
-        visit_descendants(types, &block)
-
-        self
-      end
-
-      # Returns an array of descendant nodes.
-      # This is a shorthand for `node.each_descendant.to_a`.
-      #
-      # @return [Array<Node>] an array of descendant nodes
-      def descendants
-        each_descendant.to_a
-      end
-
-      # Calls the given block for the receiver and each descendant node in
-      # depth-first order.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # This method would be useful when you treat the receiver node as the root
-      # of a tree and want to iterate over all nodes in the tree.
-      #
-      # @overload each_node
-      #   Yield all nodes.
-      # @overload each_node(type)
-      #   Yield only nodes matching the type.
-      #   @param [Symbol] type a node type
-      # @overload each_node(type_a, type_b, ...)
-      #   Yield only nodes matching any of the types.
-      #   @param [Symbol] type_a a node type
-      #   @param [Symbol] type_b a node type
-      # @yieldparam [Node] node each node
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
-      def each_node(*types, &block)
-        return to_enum(__method__, *types) unless block_given?
-
-        yield self if types.empty? || types.include?(type)
-
-        visit_descendants(types, &block)
-
-        self
-      end
-
+      # Note: Some rare nodes may have no source, like `s(:args)` in `foo {}`
+      # @return [String, nil]
       def source
-        loc.expression.source
+        loc.expression&.source
       end
 
       def source_range
@@ -427,10 +367,10 @@ module RuboCop
         define_method(recursive_kind) do
           case type
           when :send
-            [*COMPARISON_OPERATORS, :!, :<=>].include?(method_name) &&
+            LITERAL_RECURSIVE_METHODS.include?(method_name) &&
               receiver.send(recursive_kind) &&
               arguments.all?(&recursive_kind)
-          when :begin, :pair, *OPERATOR_KEYWORDS, *COMPOSITE_LITERALS
+          when LITERAL_RECURSIVE_TYPES
             children.compact.all?(&recursive_kind)
           else
             send(kind_filter)
@@ -619,15 +559,6 @@ module RuboCop
         end
       end
 
-      protected
-
-      def visit_descendants(types, &block)
-        each_child_node do |child|
-          yield child if types.empty? || types.include?(child.type)
-          child.visit_descendants(types, &block)
-        end
-      end
-
       private
 
       def visit_ancestors(types)

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

@@ -10,6 +10,7 @@ module RuboCop
         string: /^%[wW]/,
         symbol: /^%[iI]/
       }.freeze
+      private_constant :PERCENT_LITERAL_TYPES
 
       # Returns an array of all value nodes in the `array` literal.
       #

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

@@ -12,6 +12,7 @@ module RuboCop
       include MethodIdentifierPredicates
 
       VOID_CONTEXT_METHODS = %i[each tap].freeze
+      private_constant :VOID_CONTEXT_METHODS
 
       # The `send` node associated with this block.
       #

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

@@ -9,6 +9,7 @@ module RuboCop
       include HashElementNode
 
       DOUBLE_SPLAT = '**'
+      private_constant :DOUBLE_SPLAT
 
       # This is used for duck typing with `pair` nodes which also appear as
       # `hash` elements.

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

@@ -8,6 +8,7 @@ module RuboCop
 
       ARRAY_METHODS =
         (Array.instance_methods - Object.instance_methods - [:to_a]).freeze
+      private_constant :ARRAY_METHODS
 
       def_delegators :to_a, *ARRAY_METHODS
     end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for primitive literal nodes: `sym`, `str`,
+    # `int`, `float`, ...
+    module Descendence
+      # Calls the given block for each child node.
+      # If no block is given, an `Enumerator` is returned.
+      #
+      # Note that this is different from `node.children.each { |child| ... }`
+      # which yields all children including non-node elements.
+      #
+      # @overload each_child_node
+      #   Yield all nodes.
+      # @overload each_child_node(type)
+      #   Yield only nodes matching the type.
+      #   @param [Symbol] type a node type
+      # @overload each_child_node(type_a, type_b, ...)
+      #   Yield only nodes matching any of the types.
+      #   @param [Symbol] type_a a node type
+      #   @param [Symbol] type_b a node type
+      # @yieldparam [Node] node each child node
+      # @return [self] if a block is given
+      # @return [Enumerator] if no block is given
+      def each_child_node(*types)
+        return to_enum(__method__, *types) unless block_given?
+
+        children.each do |child|
+          next unless child.is_a?(::AST::Node)
+
+          yield child if types.empty? || types.include?(child.type)
+        end
+
+        self
+      end
+
+      # Returns an array of child nodes.
+      # This is a shorthand for `node.each_child_node.to_a`.
+      #
+      # @return [Array<Node>] an array of child nodes
+      def child_nodes
+        each_child_node.to_a
+      end
+
+      # Calls the given block for each descendant node with depth first order.
+      # If no block is given, an `Enumerator` is returned.
+      #
+      # @overload each_descendant
+      #   Yield all nodes.
+      # @overload each_descendant(type)
+      #   Yield only nodes matching the type.
+      #   @param [Symbol] type a node type
+      # @overload each_descendant(type_a, type_b, ...)
+      #   Yield only nodes matching any of the types.
+      #   @param [Symbol] type_a a node type
+      #   @param [Symbol] type_b a node type
+      # @yieldparam [Node] node each descendant node
+      # @return [self] if a block is given
+      # @return [Enumerator] if no block is given
+      def each_descendant(*types, &block)
+        return to_enum(__method__, *types) unless block_given?
+
+        visit_descendants(types, &block)
+
+        self
+      end
+
+      # Returns an array of descendant nodes.
+      # This is a shorthand for `node.each_descendant.to_a`.
+      #
+      # @return [Array<Node>] an array of descendant nodes
+      def descendants
+        each_descendant.to_a
+      end
+
+      # Calls the given block for the receiver and each descendant node in
+      # depth-first order.
+      # If no block is given, an `Enumerator` is returned.
+      #
+      # This method would be useful when you treat the receiver node as the root
+      # of a tree and want to iterate over all nodes in the tree.
+      #
+      # @overload each_node
+      #   Yield all nodes.
+      # @overload each_node(type)
+      #   Yield only nodes matching the type.
+      #   @param [Symbol] type a node type
+      # @overload each_node(type_a, type_b, ...)
+      #   Yield only nodes matching any of the types.
+      #   @param [Symbol] type_a a node type
+      #   @param [Symbol] type_b a node type
+      # @yieldparam [Node] node each node
+      # @return [self] if a block is given
+      # @return [Enumerator] if no block is given
+      def each_node(*types, &block)
+        return to_enum(__method__, *types) unless block_given?
+
+        yield self if types.empty? || types.include?(type)
+
+        visit_descendants(types, &block)
+
+        self
+      end
+
+      protected
+
+      def visit_descendants(types, &block)
+        each_child_node do |child|
+          yield child if types.empty? || types.include?(child.type)
+          child.visit_descendants(types, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,9 @@ module RuboCop
       include MethodIdentifierPredicates
 
       ARITHMETIC_OPERATORS = %i[+ - * / % **].freeze
+      private_constant :ARITHMETIC_OPERATORS
       SPECIAL_MODIFIERS = %w[private protected].freeze
+      private_constant :SPECIAL_MODIFIERS
 
       # The receiving node of the method dispatch.
       #
@@ -42,7 +44,7 @@ module RuboCop
       #
       # @return [Boolean] whether the dispatched method is a macro method
       def macro?
-        !receiver && macro_scope?
+        !receiver && in_macro_scope?
       end
 
       # Checks whether the dispatched method is an access modifier.
@@ -222,31 +224,21 @@ module RuboCop
 
       private
 
-      def_node_matcher :macro_scope?, <<~PATTERN
-        {^{({sclass class module block} ...) class_constructor?}
-         ^^{({sclass class module block} ... ({begin if} ...)) class_constructor?}
-         ^#macro_kwbegin_wrapper?
-         #root_node?}
+      def_node_matcher :in_macro_scope?, <<~PATTERN
+        {
+          root?                                    # Either a root node,
+          ^{                                       # or the parent is...
+            sclass class module class_constructor? # a class-like node
+            [ {                                    # or some "wrapper"
+                kwbegin begin block
+                (if _condition <%0 _>)  # note: we're excluding the condition of `if` nodes
+              }
+              #in_macro_scope?                     # that is itself in a macro scope
+            ]
+          }
+        }
       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