rubocop-ast 0.5.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f71ef8c3ea38e4fc2ef139e7ec61bc6811cc4aea1e3cc4031055ca49aa2a20b3
-  data.tar.gz: 3b338905a203f204230099806070e653785e0999d196b09d6a2af3ed69450c10
+  metadata.gz: 47a3f561646e687bc714f3f176e99c5d5eca2ab24559bedf942f792352c4270e
+  data.tar.gz: c063c635a2436be86d39eb50145d5670e1840e94f50ae3631715737ff7dfd9a7
 SHA512:
-  metadata.gz: 61df3d081d020042e922967ed5653781f5c589c9960dc9666d17a339b4c09f57cb948df4be2356bbc175598d4cbbc9f10329e2020f468f1812ce1da383a2768f
-  data.tar.gz: fc5711d88c212f81d4bc0e9aedf461de610d2903a22e217b11ccc95fbabad0170c1a0149b79f49db8475e848cee2b86924f302ea4172e67eee5b7b6e2ab38229
+  metadata.gz: 02f8fcec5a73b6ddf0f1f526681fc625cf866cda61a69f3a11a41e70ab3addafed172b6c25218c1583e7247da66aef458559dc5a182d1cee010cdb603dc31f3d
+  data.tar.gz: af3e1390138540f1f728906efad504d7029deb1261b8607d168383511b210d74d73986e63186339cb916a9dda4ae8f116119257f340c687c88fcac7b8c5d83a1

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'
@@ -67,3 +81,6 @@ 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 = {})
@@ -211,104 +237,6 @@ 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
@@ -439,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)
@@ -631,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/def_node.rb

@@ -58,6 +58,11 @@ module RuboCop
       def receiver
         children[-4]
       end
+
+      # @return [Boolean] if the definition is without an `end` or not.
+      def endless?
+        !loc.end
+      end
     end
   end
 end

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.
       #

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

@@ -11,17 +11,23 @@ module RuboCop
                               find find_all find_index inject loop map!
                               map reduce reject reject! reverse_each select
                               select! times upto].to_set.freeze
+      private_constant :ENUMERATOR_METHODS
 
       ENUMERABLE_METHODS = (Enumerable.instance_methods + [:each]).to_set.freeze
+      private_constant :ENUMERABLE_METHODS
 
       # http://phrogz.net/programmingruby/language.html#table_18.4
       OPERATOR_METHODS = %i[| ^ & <=> == === =~ > >= < <= << >> + - * /
                             % ** ~ +@ -@ !@ ~@ [] []= ! != !~ `].to_set.freeze
+      private_constant :OPERATOR_METHODS
 
       NONMUTATING_BINARY_OPERATOR_METHODS = %i[* / % + - == === != < > <= >= <=>].to_set.freeze
+      private_constant :NONMUTATING_BINARY_OPERATOR_METHODS
       NONMUTATING_UNARY_OPERATOR_METHODS = %i[+@ -@ ~ !].to_set.freeze
+      private_constant :NONMUTATING_UNARY_OPERATOR_METHODS
       NONMUTATING_OPERATOR_METHODS = (NONMUTATING_BINARY_OPERATOR_METHODS +
         NONMUTATING_UNARY_OPERATOR_METHODS).freeze
+      private_constant :NONMUTATING_OPERATOR_METHODS
 
       NONMUTATING_ARRAY_METHODS = %i[
         all? any? assoc at bsearch bsearch_index collect
@@ -37,6 +43,7 @@ module RuboCop
         to_a to_ary to_h to_s transpose union uniq
         values_at zip |
       ].to_set.freeze
+      private_constant :NONMUTATING_ARRAY_METHODS
 
       NONMUTATING_HASH_METHODS = %i[
         any? assoc compact dig each each_key each_pair
@@ -47,6 +54,7 @@ module RuboCop
         to_proc to_s transform_keys transform_values value?
         values values_at
       ].to_set.freeze
+      private_constant :NONMUTATING_HASH_METHODS
 
       NONMUTATING_STRING_METHODS = %i[
         ascii_only? b bytes bytesize byteslice capitalize
@@ -62,6 +70,7 @@ module RuboCop
         to_str to_sym tr tr_s unicode_normalize unicode_normalized?
         unpack unpack1 upcase upto valid_encoding?
       ].to_set.freeze
+      private_constant :NONMUTATING_STRING_METHODS
 
       # Checks whether the method name matches the argument.
       #