syntax_tree 6.0.1 → 6.1.0

data/lib/syntax_tree/node.rb

@@ -792,9 +792,10 @@ module SyntaxTree
     private
 
     def trailing_comma?
+      arguments = self.arguments
       return false unless arguments.is_a?(Args)
-      parts = arguments.parts
 
+      parts = arguments.parts
       if parts.last.is_a?(ArgBlock)
         # If the last argument is a block, then we can't put a trailing comma
         # after it without resulting in a syntax error.
@@ -1188,8 +1189,11 @@ module SyntaxTree
     end
 
     def format(q)
-      if lbracket.comments.empty? && contents && contents.comments.empty? &&
-           contents.parts.length > 1
+      lbracket = self.lbracket
+      contents = self.contents
+
+      if lbracket.is_a?(LBracket) && lbracket.comments.empty? && contents &&
+           contents.comments.empty? && contents.parts.length > 1
         if qwords?
           QWordsFormatter.new(contents).format(q)
           return
@@ -2091,6 +2095,7 @@ module SyntaxTree
     end
 
     def format(q)
+      left = self.left
       power = operator == :**
 
       q.group do
@@ -2307,6 +2312,8 @@ module SyntaxTree
     end
 
     def bind(parser, start_char, start_column, end_char, end_column)
+      rescue_clause = self.rescue_clause
+
       @location =
         Location.new(
           start_line: location.start_line,
@@ -2330,6 +2337,7 @@ module SyntaxTree
       # Next we're going to determine the rescue clause if there is one
       if rescue_clause
         consequent = else_clause || ensure_clause
+
         rescue_clause.bind_end(
           consequent ? consequent.location.start_char : end_char,
           consequent ? consequent.location.start_column : end_column
@@ -2735,7 +2743,7 @@ module SyntaxTree
               children << receiver
             end
           when MethodAddBlock
-            if receiver.call.is_a?(CallNode) && !receiver.call.receiver.nil?
+            if (call = receiver.call).is_a?(CallNode) && !call.receiver.nil?
               children << receiver
             else
               break
@@ -2744,8 +2752,8 @@ module SyntaxTree
             break
           end
         when MethodAddBlock
-          if child.call.is_a?(CallNode) && !child.call.receiver.nil?
-            children << child.call
+          if (call = child.call).is_a?(CallNode) && !call.receiver.nil?
+            children << call
           else
             break
           end
@@ -2767,8 +2775,8 @@ module SyntaxTree
         # of just Statements nodes.
         parent = parents[3] if parent.is_a?(BlockNode) && parent.keywords?
 
-        if parent.is_a?(MethodAddBlock) && parent.call.is_a?(CallNode) &&
-             parent.call.message.value == "sig"
+        if parent.is_a?(MethodAddBlock) &&
+             (call = parent.call).is_a?(CallNode) && call.message.value == "sig"
           threshold = 2
         end
       end
@@ -2813,10 +2821,10 @@ module SyntaxTree
 
           while (child = children.pop)
             if child.is_a?(CallNode)
-              if child.receiver.is_a?(CallNode) &&
-                   (child.receiver.message != :call) &&
-                   (child.receiver.message.value == "where") &&
-                   (child.message.value == "not")
+              if (receiver = child.receiver).is_a?(CallNode) &&
+                   (receiver.message != :call) &&
+                   (receiver.message.value == "where") &&
+                   (message.value == "not")
                 # This is very specialized behavior wherein we group
                 # .where.not calls together because it looks better. For more
                 # information, see
@@ -2872,7 +2880,8 @@ module SyntaxTree
       when CallNode
         !node.receiver.nil?
       when MethodAddBlock
-        node.call.is_a?(CallNode) && !node.call.receiver.nil?
+        call = node.call
+        call.is_a?(CallNode) && !call.receiver.nil?
       else
         false
       end
@@ -3629,6 +3638,10 @@ module SyntaxTree
     end
 
     def format(q)
+      message = self.message
+      arguments = self.arguments
+      block = self.block
+
       q.group do
         doc =
           q.nest(0) do
@@ -3637,7 +3650,7 @@ module SyntaxTree
             # If there are leading comments on the message then we know we have
             # a newline in the source that is forcing these things apart. In
             # this case we will have to use a trailing operator.
-            if message.comments.any?(&:leading?)
+            if message != :call && message.comments.any?(&:leading?)
               q.format(CallOperatorFormatter.new(operator), stackable: false)
               q.indent do
                 q.breakable_empty
@@ -4153,6 +4166,9 @@ module SyntaxTree
     end
 
     def format(q)
+      params = self.params
+      bodystmt = self.bodystmt
+
       q.group do
         q.group do
           q.text("def")
@@ -4209,6 +4225,8 @@ module SyntaxTree
     end
 
     def arity
+      params = self.params
+
       case params
       when Params
         params.arity
@@ -5293,6 +5311,7 @@ module SyntaxTree
     end
 
     def child_nodes
+      operator = self.operator
       [parent, (operator if operator != :"::"), name]
     end
 
@@ -5674,7 +5693,7 @@ module SyntaxTree
     end
 
     def child_nodes
-      [lbrace] + assocs
+      [lbrace].concat(assocs)
     end
 
     def copy(lbrace: nil, assocs: nil, location: nil)
@@ -5766,7 +5785,7 @@ module SyntaxTree
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
-    def initialize(beginning:, ending: nil, dedent: 0, parts: [], location:)
+    def initialize(beginning:, location:, ending: nil, dedent: 0, parts: [])
       @beginning = beginning
       @ending = ending
       @dedent = dedent
@@ -6134,6 +6153,8 @@ module SyntaxTree
     private
 
     def format_contents(q, parts, nested)
+      keyword_rest = self.keyword_rest
+
       q.group { q.seplist(parts) { |part| q.format(part, stackable: false) } }
 
       # If there isn't a constant, and there's a blank keyword_rest, then we
@@ -6763,10 +6784,13 @@ module SyntaxTree
 
     def format(q)
       keyword = "in "
+      pattern = self.pattern
+      consequent = self.consequent
 
       q.group do
         q.text(keyword)
         q.nest(keyword.length) { q.format(pattern) }
+        q.text(" then") if pattern.is_a?(RangeNode) && pattern.right.nil?
 
         unless statements.empty?
           q.indent do
@@ -7164,6 +7188,8 @@ module SyntaxTree
     end
 
     def format(q)
+      params = self.params
+
       q.text("->")
       q.group do
         if params.is_a?(Paren)
@@ -7642,7 +7668,7 @@ module SyntaxTree
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
-    def initialize(parts:, comma: false, location:)
+    def initialize(parts:, location:, comma: false)
       @parts = parts
       @comma = comma
       @location = location
@@ -7703,7 +7729,7 @@ module SyntaxTree
     # [Array[ Comment | EmbDoc ]] the comments attached to this node
     attr_reader :comments
 
-    def initialize(contents:, comma: false, location:)
+    def initialize(contents:, location:, comma: false)
       @contents = contents
       @comma = comma
       @location = location
@@ -8286,14 +8312,14 @@ module SyntaxTree
     attr_reader :comments
 
     def initialize(
+      location:,
       requireds: [],
       optionals: [],
       rest: nil,
       posts: [],
       keywords: [],
       keyword_rest: nil,
-      block: nil,
-      location:
+      block: nil
     )
       @requireds = requireds
       @optionals = optionals
@@ -8320,6 +8346,8 @@ module SyntaxTree
     end
 
     def child_nodes
+      keyword_rest = self.keyword_rest
+
       [
         *requireds,
         *optionals.flatten(1),
@@ -8374,16 +8402,19 @@ module SyntaxTree
     end
 
     def format(q)
+      rest = self.rest
+      keyword_rest = self.keyword_rest
+
       parts = [
         *requireds,
         *optionals.map { |(name, value)| OptionalFormatter.new(name, value) }
       ]
 
       parts << rest if rest && !rest.is_a?(ExcessedComma)
-      parts += [
-        *posts,
-        *keywords.map { |(name, value)| KeywordFormatter.new(name, value) }
-      ]
+      parts.concat(posts)
+      parts.concat(
+        keywords.map { |(name, value)| KeywordFormatter.new(name, value) }
+      )
 
       parts << KeywordRestFormatter.new(keyword_rest) if keyword_rest
       parts << block if block
@@ -8510,6 +8541,8 @@ module SyntaxTree
     end
 
     def format(q)
+      contents = self.contents
+
       q.group do
         q.format(lparen)
 
@@ -9424,11 +9457,11 @@ module SyntaxTree
           end_column: end_column
         )
 
-      if consequent
-        consequent.bind_end(end_char, end_column)
+      if (next_node = consequent)
+        next_node.bind_end(end_char, end_column)
         statements.bind_end(
-          consequent.location.start_char,
-          consequent.location.start_column
+          next_node.location.start_char,
+          next_node.location.start_column
         )
       else
         statements.bind_end(end_char, end_column)
@@ -9871,8 +9904,8 @@ module SyntaxTree
           end_column: end_column
         )
 
-      if body[0].is_a?(VoidStmt)
-        location = body[0].location
+      if (void_stmt = body[0]).is_a?(VoidStmt)
+        location = void_stmt.location
         location =
           Location.new(
             start_line: location.start_line,
@@ -10351,7 +10384,7 @@ module SyntaxTree
       opening_quote, closing_quote =
         if !Quotes.locked?(self, q.quote)
           [q.quote, q.quote]
-        elsif quote.start_with?("%")
+        elsif quote&.start_with?("%")
           [quote, Quotes.matching(quote[/%[qQ]?(.)/, 1])]
         else
           [quote, quote]
@@ -11520,7 +11553,7 @@ module SyntaxTree
     end
 
     def child_nodes
-      [value]
+      value == :nil ? [] : [value]
     end
 
     def copy(value: nil, location: nil)

data/lib/syntax_tree/parser.rb

@@ -2132,13 +2132,20 @@ module SyntaxTree
       ending = consequent || consume_keyword(:end)
 
       statements_start = pattern
-      if (token = find_keyword(:then))
+      if (token = find_keyword_between(:then, pattern, statements))
         tokens.delete(token)
         statements_start = token
       end
 
       start_char =
         find_next_statement_start((token || statements_start).location.end_char)
+
+      # Ripper ignores parentheses on patterns, so we need to do the same in
+      # order to attach comments correctly to the pattern.
+      if source[start_char] == ")"
+        start_char = find_next_statement_start(start_char + 1)
+      end
+
       statements.bind(
         self,
         start_char,
@@ -2391,8 +2398,14 @@ module SyntaxTree
         }
       }
 
+      parent_line = lineno - 1
+      parent_column =
+        consume_token(Semicolon).location.start_column - tokens[index][0][1]
+
       tokens[(index + 1)..].each_with_object([]) do |token, locals|
         (lineno, column), type, value, = token
+        column += parent_column if lineno == 1
+        lineno += parent_line
 
         # Make the state transition for the parser. If there isn't a transition
         # from the current state to a new state for this type, then we're in a

data/lib/syntax_tree/reflection.rb

@@ -138,12 +138,13 @@ module SyntaxTree
     # as a placeholder for collecting all of the various places that nodes are
     # used.
     class Node
-      attr_reader :name, :comment, :attributes
+      attr_reader :name, :comment, :attributes, :visitor_method
 
-      def initialize(name, comment, attributes)
+      def initialize(name, comment, attributes, visitor_method)
         @name = name
         @comment = comment
         @attributes = attributes
+        @visitor_method = visitor_method
       end
     end
 
@@ -176,16 +177,18 @@ module SyntaxTree
     program =
       SyntaxTree.parse(SyntaxTree.read(File.expand_path("node.rb", __dir__)))
 
-    main_statements = program.statements.body.last.bodystmt.statements.body
+    program_statements = program.statements
+    main_statements = program_statements.body.last.bodystmt.statements.body
     main_statements.each_with_index do |main_statement, main_statement_index|
       # Ensure we are only looking at class declarations.
       next unless main_statement.is_a?(SyntaxTree::ClassDeclaration)
 
       # Ensure we're looking at class declarations with superclasses.
-      next unless main_statement.superclass.is_a?(SyntaxTree::VarRef)
+      superclass = main_statement.superclass
+      next unless superclass.is_a?(SyntaxTree::VarRef)
 
       # Ensure we're looking at class declarations that inherit from Node.
-      next unless main_statement.superclass.value.value == "Node"
+      next unless superclass.value.value == "Node"
 
       # All child nodes inherit the location attr_reader from Node, so we'll add
       # that to the list of attributes first.
@@ -194,6 +197,10 @@ module SyntaxTree
           Attribute.new(:location, "[Location] the location of this node")
       }
 
+      # This is the name of the method tha gets called on the given visitor when
+      # the accept method is called on this node.
+      visitor_method = nil
+
       statements = main_statement.bodystmt.statements.body
       statements.each_with_index do |statement, statement_index|
         case statement
@@ -223,16 +230,25 @@ module SyntaxTree
           end
 
           attributes[attribute.name] = attribute
+        when SyntaxTree::DefNode
+          if statement.name.value == "accept"
+            call_node = statement.bodystmt.statements.body.first
+            visitor_method = call_node.message.value.to_sym
+          end
         end
       end
 
+      # If we never found a visitor method, then we have an error.
+      raise if visitor_method.nil?
+
       # Finally, set it up in the hash of nodes so that we can use it later.
       comments = parse_comments(main_statements, main_statement_index)
       node =
         Node.new(
           main_statement.constant.constant.value.to_sym,
           "#{comments.join("\n")}\n",
-          attributes
+          attributes,
+          visitor_method
         )
 
       @nodes[node.name] = node

data/lib/syntax_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SyntaxTree
-  VERSION = "6.0.1"
+  VERSION = "6.1.0"
 end

data/lib/syntax_tree/with_scope.rb

@@ -189,6 +189,15 @@ module SyntaxTree
       super
     end
 
+    def visit_block_var(node)
+      node.locals.each do |local|
+        current_scope.add_local_definition(local, :variable)
+      end
+
+      super
+    end
+    alias visit_lambda_var visit_block_var
+
     # Visit for keeping track of local variable definitions
     def visit_var_field(node)
       value = node.value
@@ -217,11 +226,72 @@ module SyntaxTree
       super
     end
 
+    # When using regex named capture groups, vcalls might actually be a variable
+    def visit_vcall(node)
+      value = node.value
+      definition = current_scope.find_local(value.value)
+      current_scope.add_local_usage(value, definition.type) if definition
+
+      super
+    end
+
+    # Visit for capturing local variables defined in regex named capture groups
+    def visit_binary(node)
+      if node.operator == :=~
+        left = node.left
+
+        if left.is_a?(RegexpLiteral) && left.parts.length == 1 &&
+             left.parts.first.is_a?(TStringContent)
+          content = left.parts.first
+
+          value = content.value
+          location = content.location
+          start_line = location.start_line
+
+          Regexp
+            .new(value, Regexp::FIXEDENCODING)
+            .names
+            .each do |name|
+              offset = value.index(/\(\?<#{Regexp.escape(name)}>/)
+              line = start_line + value[0...offset].count("\n")
+
+              # We need to add 3 to account for these three characters
+              # prefixing a named capture (?<
+              column = location.start_column + offset + 3
+              if value[0...offset].include?("\n")
+                column =
+                  value[0...offset].length - value[0...offset].rindex("\n") +
+                    3 - 1
+              end
+
+              ident_location =
+                Location.new(
+                  start_line: line,
+                  start_char: location.start_char + offset,
+                  start_column: column,
+                  end_line: line,
+                  end_char: location.start_char + offset + name.length,
+                  end_column: column + name.length
+                )
+
+              identifier = Ident.new(value: name, location: ident_location)
+              current_scope.add_local_definition(identifier, :variable)
+            end
+        end
+      end
+
+      super
+    end
+
     private
 
     def add_argument_definitions(list)
       list.each do |param|
-        if param.is_a?(SyntaxTree::MLHSParen)
+        case param
+        when ArgStar
+          value = param.value
+          current_scope.add_local_definition(value, :argument) if value
+        when MLHSParen
           add_argument_definitions(param.contents.parts)
         else
           current_scope.add_local_definition(param, :argument)

data/lib/syntax_tree/yarv/compiler.rb

@@ -875,8 +875,7 @@ module SyntaxTree
           when Ident
             iseq.putobject("local-variable")
           when IVar
-            iseq.putnil
-            iseq.defined(Defined::TYPE_IVAR, name, "instance-variable")
+            iseq.definedivar(name, iseq.inline_storage, "instance-variable")
           when Kw
             case name
             when :false

data/lib/syntax_tree/yarv/instruction_sequence.rb

@@ -50,7 +50,7 @@ module SyntaxTree
           @tail_node = nil
         end
 
-        def each
+        def each(&_blk)
           return to_enum(__method__) unless block_given?
           each_node { |node| yield node.value }
         end
@@ -673,12 +673,21 @@ module SyntaxTree
         push(ConcatStrings.new(number))
       end
 
+      def defineclass(name, class_iseq, flags)
+        push(DefineClass.new(name, class_iseq, flags))
+      end
+
       def defined(type, name, message)
         push(Defined.new(type, name, message))
       end
 
-      def defineclass(name, class_iseq, flags)
-        push(DefineClass.new(name, class_iseq, flags))
+      def definedivar(name, cache, message)
+        if RUBY_VERSION < "3.3"
+          push(PutNil.new)
+          push(Defined.new(Defined::TYPE_IVAR, name, message))
+        else
+          push(DefinedIVar.new(name, cache, message))
+        end
       end
 
       def definemethod(name, method_iseq)
@@ -1058,6 +1067,8 @@ module SyntaxTree
             iseq.defineclass(opnds[0], from(opnds[1], options, iseq), opnds[2])
           when :defined
             iseq.defined(opnds[0], opnds[1], opnds[2])
+          when :definedivar
+            iseq.definedivar(opnds[0], opnds[1], opnds[2])
           when :definemethod
             iseq.definemethod(opnds[0], from(opnds[1], options, iseq))
           when :definesmethod

data/lib/syntax_tree/yarv/instructions.rb

@@ -994,6 +994,64 @@ module SyntaxTree
       end
     end
 
+    # ### Summary
+    #
+    # `definedivar` checks if an instance variable is defined. It is a
+    # specialization of the `defined` instruction. It accepts three arguments:
+    # the name of the instance variable, an inline cache, and the string that
+    # should be pushed onto the stack in the event that the instance variable
+    # is defined.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # defined?(@value)
+    # ~~~
+    #
+    class DefinedIVar < Instruction
+      attr_reader :name, :cache, :message
+
+      def initialize(name, cache, message)
+        @name = name
+        @cache = cache
+        @message = message
+      end
+
+      def disasm(fmt)
+        fmt.instruction(
+          "definedivar",
+          [fmt.object(name), fmt.inline_storage(cache), fmt.object(message)]
+        )
+      end
+
+      def to_a(_iseq)
+        [:definedivar, name, cache, message]
+      end
+
+      def deconstruct_keys(_keys)
+        { name: name, cache: cache, message: message }
+      end
+
+      def ==(other)
+        other.is_a?(DefinedIVar) && other.name == name &&
+          other.cache == cache && other.message == message
+      end
+
+      def length
+        4
+      end
+
+      def pushes
+        1
+      end
+
+      def call(vm)
+        result = (message if vm.frame._self.instance_variable_defined?(name))
+
+        vm.push(result)
+      end
+    end
+
     # ### Summary
     #
     # `definemethod` defines a method on the class of the current value of

data/lib/syntax_tree.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prettier_print"
+require "pp"
 require "ripper"
 
 require_relative "syntax_tree/node"