rubocop-ast 0.3.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 918c6017183db74497fc68166973904312bac7583f7752c2e55d1829574cb248
-  data.tar.gz: 1d04eb24fcbaec96b4bf0f17694018c31034fce4b3d81a9446ca98b3085e05a4
+  metadata.gz: d9e5dc8ddfc947af0653c81c0579c18eba59551567d977dc3bf0a4ca4ea92d59
+  data.tar.gz: 4110b86811007a0a28e52c090f45b34449a0e3a6ede4cec97463052c1fb3a8a2
 SHA512:
-  metadata.gz: 54f6882ebf057c76a9c97212a62b295d03baea85ec7c44e606b412e74edce01b6c4bba93dfafa341756009a8bfa2352c4b2b3b22bdbf689dac08ddd9395a9aff
-  data.tar.gz: '08e60b802e83dba688bf1a31be417f9880b640194cf3b966849dd2c211de5a1f3797c8a37be3f2d3aa466d6c994b10c31277b0ed3dc708b12fe1c2f7a0f15552'
+  metadata.gz: 827480d8986177910eee3a5d7bebafd9eb169818d755d79c16f9d4a3f89ebcd486494f35f07fbf3e0f6ffcc2a82da74a86b0475504c79b4fb1de3b3ad732a78f
+  data.tar.gz: 6daa124ee67a95fbc6e91cf5cc0a1179e9aad6718fd8a3f9d54b48c5209b45ede07875e1becbdae84ee2106458bb23538fc144a8aefcc35e922204fcb4c30619

data/lib/rubocop/ast.rb

@@ -5,7 +5,22 @@ require 'forwardable'
 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'
@@ -28,6 +43,7 @@ require_relative 'ast/node/break_node'
 require_relative 'ast/node/case_match_node'
 require_relative 'ast/node/case_node'
 require_relative 'ast/node/class_node'
+require_relative 'ast/node/const_node'
 require_relative 'ast/node/def_node'
 require_relative 'ast/node/defined_node'
 require_relative 'ast/node/ensure_node'
@@ -47,6 +63,7 @@ require_relative 'ast/node/or_node'
 require_relative 'ast/node/pair_node'
 require_relative 'ast/node/range_node'
 require_relative 'ast/node/regexp_node'
+require_relative 'ast/node/rescue_node'
 require_relative 'ast/node/resbody_node'
 require_relative 'ast/node/return_node'
 require_relative 'ast/node/self_class_node'
@@ -60,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,
@@ -27,6 +28,7 @@ module RuboCop
         case_match:   CaseMatchNode,
         case:         CaseNode,
         class:        ClassNode,
+        const:        ConstNode,
         def:          DefNode,
         defined?:     DefinedNode,
         defs:         DefNode,
@@ -48,6 +50,7 @@ module RuboCop
         or:           OrNode,
         pair:         PairNode,
         regexp:       RegexpNode,
+        rescue:       RescueNode,
         resbody:      ResbodyNode,
         return:       ReturnNode,
         csend:        SendNode,

data/lib/rubocop/ast/ext/set.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+test = :foo
+case test
+when Set[:foo]
+  # ok, RUBY_VERSION > 2.4
+else
+  # Harmonize `Set#===`
+  class Set
+    alias === include?
+  end
+end

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].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!)
@@ -116,12 +152,50 @@ module RuboCop
 
       # Returns the index of the receiver node in its siblings. (Sibling index
       # uses zero based numbering.)
+      # Use is discouraged, this is a potentially slow method.
       #
-      # @return [Integer] the index of the receiver node in its siblings
+      # @return [Integer, nil] the index of the receiver node in its siblings
       def sibling_index
         parent&.children&.index { |sibling| sibling.equal?(self) }
       end
 
+      # Use is discouraged, this is a potentially slow method and can lead
+      # to even slower algorithms
+      # @return [Node, nil] the right (aka next) sibling
+      def right_sibling
+        return unless parent
+
+        parent.children[sibling_index + 1].freeze
+      end
+
+      # Use is discouraged, this is a potentially slow method and can lead
+      # to even slower algorithms
+      # @return [Node, nil] the left (aka previous) sibling
+      def left_sibling
+        i = sibling_index
+        return if i.nil? || i.zero?
+
+        parent.children[i - 1].freeze
+      end
+
+      # Use is discouraged, this is a potentially slow method and can lead
+      # to even slower algorithms
+      # @return [Array<Node>] the left (aka previous) siblings
+      def left_siblings
+        return [].freeze unless parent
+
+        parent.children[0...sibling_index].freeze
+      end
+
+      # Use is discouraged, this is a potentially slow method and can lead
+      # to even slower algorithms
+      # @return [Array<Node>] the right (aka next) siblings
+      def right_siblings
+        return [].freeze unless parent
+
+        parent.children[sibling_index + 1..-1].freeze
+      end
+
       # Common destructuring method. This can be used to normalize
       # destructuring for different variations of the node.
       # Some node types override this with their own custom
@@ -163,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
@@ -389,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)
@@ -581,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.
       #
@@ -25,7 +26,7 @@ module RuboCop
       # @return [Array<Node>]
       def arguments
         if numblock_type?
-          [] # Numbered parameters have no block arguments.
+          [].freeze # Numbered parameters have no block arguments.
         else
           node_parts[1]
         end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `const` nodes.
+    class ConstNode < Node
+      # The `send` node associated with this block.
+      #
+      # @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
+
+      # The body of this block.
+      #
+      # @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_given?
+
+        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