rubocop-ast 0.6.0 → 0.7.0

data/lib/rubocop/ast/node_pattern/parser.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'parser.racc'
+
+module RuboCop
+  module AST
+    class NodePattern
+      # Parser for NodePattern
+      # Note: class reopened in `parser.racc`
+      #
+      # Doc on how this fits in the compiling process:
+      #   /doc/modules/ROOT/pages/node_pattern.md
+      class Parser < Racc::Parser
+        extend Forwardable
+
+        Builder = NodePattern::Builder
+        Lexer = NodePattern::Lexer
+
+        def initialize(builder = self.class::Builder.new)
+          super()
+          @builder = builder
+        end
+
+        ##
+        # (Similar API to `parser` gem)
+        # Parses a source and returns the AST.
+        #
+        # @param [Parser::Source::Buffer, String] source_buffer The source buffer to parse.
+        # @return [NodePattern::Node]
+        #
+        def parse(source)
+          @lexer = self.class::Lexer.new(source)
+          do_parse
+        rescue Lexer::Error => e
+          raise NodePattern::Invalid, e.message
+        ensure
+          @lexer = nil # Don't keep references
+        end
+
+        def inspect
+          "<##{self.class}>"
+        end
+
+        private
+
+        def_delegators :@builder, :emit_list, :emit_unary_op, :emit_atom, :emit_capture,
+                       :emit_call, :emit_union
+        def_delegators :@lexer, :next_token
+
+        def enforce_unary(node)
+          return node if node.arity == 1
+
+          detail = node.loc&.expression&.source || node.to_s
+          raise NodePattern::Invalid, 'parse error, expected unary node pattern ' \
+            "but got expression matching multiple elements: #{detail}"
+        end
+
+        # Overrides Racc::Parser's method:
+        def on_error(token, val, _vstack)
+          detail = token_to_str(token) || '?'
+          raise NodePattern::Invalid, "parse error on value #{val.inspect} (#{detail})"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node_pattern/parser.y

@@ -0,0 +1,103 @@
+class RuboCop::AST::NodePattern::Parser
+options no_result_var
+token tSYMBOL tNUMBER tSTRING tWILDCARD tPARAM_NAMED tPARAM_CONST tPARAM_NUMBER
+      tFUNCTION_CALL tPREDICATE tNODE_TYPE tARG_LIST tUNIFY tREGEXP
+rule
+  node_pattern                               # @return Node
+    : node_pattern_no_union
+    | union                                  { enforce_unary(val[0]) }
+    ;
+
+  node_pattern_no_union                      # @return Node
+    : '(' variadic_pattern_list ')'          { emit_list :sequence, *val }
+    | '[' node_pattern_list ']'              { emit_list :intersection, *val }
+    | '!' node_pattern                       { emit_unary_op :negation, *val }
+    | '^' node_pattern                       { emit_unary_op :ascend, *val }
+    | '`' node_pattern                       { emit_unary_op :descend, *val }
+    | '$' node_pattern                       { emit_capture(*val) }
+    | tFUNCTION_CALL args                    { emit_call :function_call, *val }
+    | tPREDICATE args                        { emit_call :predicate, *val }
+    | tNODE_TYPE                             { emit_call :node_type, *val }
+    | atom
+    ;
+
+  atom                                       # @return Node
+    : tSYMBOL                                { emit_atom :symbol, *val }
+    | tNUMBER                                { emit_atom :number, *val }
+    | tSTRING                                { emit_atom :string, *val }
+    | tPARAM_CONST                           { emit_atom :const, *val }
+    | tPARAM_NAMED                           { emit_atom :named_parameter, *val }
+    | tPARAM_NUMBER                          { emit_atom :positional_parameter, *val }
+    | tREGEXP                                { emit_atom :regexp, *val }
+    | tWILDCARD                              { emit_atom :wildcard, *val }
+    | tUNIFY                                 { emit_atom :unify, *val }
+    ;
+
+  union                                      # @return Node
+    : '{' separated_variadic_patterns '}'    { emit_union(*val) }
+    ;
+
+  variadic_pattern                           # @return Node
+    : node_pattern_no_union
+    | union
+    | node_pattern repetition
+      {
+        main, repeat_t = val
+        emit_unary_op(:repetition, repeat_t, main, repeat_t)
+      }
+    | opt_capture '<' node_pattern_list opt_rest '>'
+      {
+        opt_capture, bracket, node_pattern_list, opt_rest, close_bracket = val
+        node_pattern_list << opt_rest if opt_rest
+        main = emit_list :any_order, bracket, node_pattern_list, close_bracket
+        emit_capture(opt_capture, main)
+      }
+    | rest
+    ;
+
+  repetition                                 # @return Token
+    : '?'
+    | '*'
+    | '+'
+    ;
+
+  opt_capture                                # @return Token | nil
+    :
+    | '$'
+    ;
+
+  rest                                       # @return Node
+    : opt_capture '...'                      { emit_capture(val[0], emit_atom(:rest, val[1])) }
+    ;
+
+  opt_rest                                   # @return Node | nil
+    :
+    | rest
+    ;
+
+  args                                       # @return [Token, Array<Node>, Token] | nil
+    :
+    | tARG_LIST arg_list ')'                 { val }
+    ;
+
+  arg_list                                   # @return Array<Node>
+    : node_pattern                           { val }
+    | arg_list ',' node_pattern              { val[0] << val[2] }
+    ;
+
+  node_pattern_list                          # @return Array<Node>
+    : node_pattern                           { val }
+    | node_pattern_list node_pattern         { val[0] << val[1] }
+    ;
+
+  variadic_pattern_list                      # @return Array<Node>
+    : variadic_pattern                       { val }
+    | variadic_pattern_list variadic_pattern { val[0] << val[1] }
+    ;
+
+  separated_variadic_patterns                # @return Array<Array<Node>>
+    :                                        { [[]] }
+    | separated_variadic_patterns variadic_pattern { val[0].last << val[1]; val[0] }
+    | separated_variadic_patterns '|'        { val[0] << [] }
+    ;
+end

data/lib/rubocop/ast/node_pattern/sets.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    class NodePattern
+      # Utility to assign a set of values to a constant
+      module Sets
+        REGISTRY = Hash.new do |h, set|
+          name = Sets.name(set).freeze
+          Sets.const_set(name, set)
+          h[set] = "::RuboCop::AST::NodePattern::Sets::#{name}"
+        end
+
+        MAX = 4
+        def self.name(set)
+          elements = set
+          elements = set.first(MAX - 1) << :etc if set.size > MAX
+          name = elements.to_a.join('_').upcase.gsub(/[^A-Z0-9_]/, '')
+          uniq("SET_#{name}")
+        end
+
+        def self.uniq(name)
+          return name unless Sets.const_defined?(name)
+
+          (2..Float::INFINITY).each do |i|
+            uniq = "#{name}_#{i}"
+            return uniq unless Sets.const_defined?(uniq)
+          end
+        end
+
+        def self.[](set)
+          REGISTRY[set]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node_pattern/with_meta.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    class NodePattern
+      class Parser
+        # Overrides Parser to use `WithMeta` variants and provide additional methods
+        class WithMeta < Parser
+          # Overrides Lexer to token locations and comments
+          class Lexer < NodePattern::Lexer
+            attr_reader :source_buffer
+
+            def initialize(str_or_buffer)
+              @source_buffer = if str_or_buffer.respond_to?(:source)
+                                 str_or_buffer
+                               else
+                                 ::Parser::Source::Buffer.new('(string)', source: str_or_buffer)
+                               end
+              @comments = []
+              super(@source_buffer.source)
+            end
+
+            def token(type, value)
+              super(type, [value, pos])
+            end
+
+            def emit_comment
+              @comments << Comment.new(pos)
+              super
+            end
+
+            # @return [::Parser::Source::Range] last match's position
+            def pos
+              ::Parser::Source::Range.new(source_buffer, ss.pos - ss.matched_size, ss.pos)
+            end
+          end
+
+          # Overrides Builder to emit nodes with locations
+          class Builder < NodePattern::Builder
+            def emit_atom(type, token)
+              value, loc = token
+              begin_l = loc.resize(1)
+              end_l = loc.end.adjust(begin_pos: -1)
+              begin_l = nil if begin_l.source.match?(/\w/)
+              end_l = nil if end_l.source.match?(/\w/)
+              n(type, [value], source_map(token, begin_t: begin_l, end_t: end_l))
+            end
+
+            def emit_unary_op(type, operator_t = nil, *children)
+              children[-1] = children[-1].first if children[-1].is_a?(Array) # token?
+              map = source_map(children.first.loc.expression, operator_t: operator_t)
+              n(type, children, map)
+            end
+
+            def emit_list(type, begin_t, children, end_t)
+              expr = children.first.loc.expression.join(children.last.loc.expression)
+              map = source_map(expr, begin_t: begin_t, end_t: end_t)
+              n(type, children, map)
+            end
+
+            def emit_call(type, selector_t, args = nil)
+              selector, = selector_t
+              begin_t, arg_nodes, end_t = args
+
+              map = source_map(selector_t, begin_t: begin_t, end_t: end_t, selector_t: selector_t)
+              n(type, [selector, *arg_nodes], map)
+            end
+
+            private
+
+            def n(type, children, source_map)
+              super(type, children, { location: source_map })
+            end
+
+            def loc(token_or_range)
+              return token_or_range[1] if token_or_range.is_a?(Array)
+
+              token_or_range
+            end
+
+            def join_exprs(left_expr, right_expr)
+              left_expr.loc.expression
+                       .join(right_expr.loc.expression)
+            end
+
+            def source_map(token_or_range, begin_t: nil, end_t: nil, operator_t: nil, selector_t: nil)
+              expression_l = loc(token_or_range)
+              expression_l = expression_l.expression if expression_l.respond_to?(:expression)
+              locs = [begin_t, end_t, operator_t, selector_t].map { |token| loc(token) }
+              begin_l, end_l, operator_l, selector_l = locs
+
+              expression_l = locs.compact.inject(expression_l, :join)
+
+              ::Parser::Source::Map::Send.new(_dot_l = nil, selector_l, begin_l, end_l, expression_l)
+                                         .with_operator(operator_l)
+            end
+          end
+
+          attr_reader :comments, :tokens
+
+          def do_parse
+            r = super
+            @comments = @lexer.comments
+            @tokens = @lexer.tokens
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/ast/processed_source.rb

@@ -9,6 +9,7 @@ module RuboCop
     # and other information such as disabled lines for cops.
     # It also provides a convenient way to access source lines.
     class ProcessedSource
+      # @api private
       STRING_SOURCE_NAME = '(string)'
 
       attr_reader :path, :buffer, :ast, :comments, :tokens, :diagnostics,

data/lib/rubocop/ast/traversal.rb

@@ -38,6 +38,7 @@ module RuboCop
                              index indexasgn].freeze
       SECOND_CHILD_ONLY = %i[lvasgn ivasgn cvasgn gvasgn optarg kwarg
                              kwoptarg].freeze
+      private_constant :NO_CHILD_NODES, :ONE_CHILD_NODE, :MANY_CHILD_NODES, :SECOND_CHILD_ONLY
 
       NO_CHILD_NODES.each do |type|
         module_eval("def on_#{type}(node); end", __FILE__, __LINE__)

data/lib/rubocop/ast/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module AST
     module Version
-      STRING = '0.6.0'
+      STRING = '0.7.0'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-ast
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-26 00:00:00.000000000 Z
+date: 2020-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -26,6 +26,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.7.1.5
+- !ruby/object:Gem::Dependency
+  name: strscan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +103,7 @@ files:
 - lib/rubocop/ast/node/mixin/binary_operator_node.rb
 - lib/rubocop/ast/node/mixin/collection_node.rb
 - lib/rubocop/ast/node/mixin/conditional_node.rb
+- lib/rubocop/ast/node/mixin/descendence.rb
 - lib/rubocop/ast/node/mixin/hash_element_node.rb
 - lib/rubocop/ast/node/mixin/method_dispatch_node.rb
 - lib/rubocop/ast/node/mixin/method_identifier_predicates.rb
@@ -115,6 +130,25 @@ files:
 - lib/rubocop/ast/node/while_node.rb
 - lib/rubocop/ast/node/yield_node.rb
 - lib/rubocop/ast/node_pattern.rb
+- lib/rubocop/ast/node_pattern/builder.rb
+- lib/rubocop/ast/node_pattern/comment.rb
+- lib/rubocop/ast/node_pattern/compiler.rb
+- lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb
+- lib/rubocop/ast/node_pattern/compiler/binding.rb
+- lib/rubocop/ast/node_pattern/compiler/debug.rb
+- lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb
+- lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb
+- lib/rubocop/ast/node_pattern/compiler/subcompiler.rb
+- lib/rubocop/ast/node_pattern/lexer.rb
+- lib/rubocop/ast/node_pattern/lexer.rex
+- lib/rubocop/ast/node_pattern/lexer.rex.rb
+- lib/rubocop/ast/node_pattern/method_definer.rb
+- lib/rubocop/ast/node_pattern/node.rb
+- lib/rubocop/ast/node_pattern/parser.racc.rb
+- lib/rubocop/ast/node_pattern/parser.rb
+- lib/rubocop/ast/node_pattern/parser.y
+- lib/rubocop/ast/node_pattern/sets.rb
+- lib/rubocop/ast/node_pattern/with_meta.rb
 - lib/rubocop/ast/processed_source.rb
 - lib/rubocop/ast/rubocop_compatibility.rb
 - lib/rubocop/ast/sexp.rb