syntax_tree 5.1.0 → 5.3.0

data/lib/syntax_tree/node.rb

@@ -775,6 +775,10 @@ module SyntaxTree
       other.is_a?(ArgParen) && arguments === other.arguments
     end
 
+    def arity
+      arguments&.arity || 0
+    end
+
     private
 
     def trailing_comma?
@@ -848,6 +852,21 @@ module SyntaxTree
     def ===(other)
       other.is_a?(Args) && ArrayMatch.call(parts, other.parts)
     end
+
+    def arity
+      parts.sum do |part|
+        case part
+        when ArgStar, ArgsForward
+          Float::INFINITY
+        when BareAssocHash
+          part.assocs.sum do |assoc|
+            assoc.is_a?(AssocSplat) ? Float::INFINITY : 1
+          end
+        else
+          1
+        end
+      end
+    end
   end
 
   # ArgBlock represents using a block operator on an expression.
@@ -1008,6 +1027,10 @@ module SyntaxTree
     def ===(other)
       other.is_a?(ArgsForward)
     end
+
+    def arity
+      Float::INFINITY
+    end
   end
 
   # ArrayLiteral represents an array literal, which can optionally contain
@@ -1080,58 +1103,6 @@ module SyntaxTree
       end
     end
 
-    # Formats an array that contains only a list of variable references. To make
-    # things simpler, if there are a bunch, we format them all using the "fill"
-    # algorithm as opposed to breaking them into a ton of lines. For example,
-    #
-    #     [foo, bar, baz]
-    #
-    # instead of becoming:
-    #
-    #     [
-    #       foo,
-    #       bar,
-    #       baz
-    #     ]
-    #
-    # would instead become:
-    #
-    #     [
-    #       foo, bar,
-    #       baz
-    #     ]
-    #
-    # provided the line length was hit between `bar` and `baz`.
-    class VarRefsFormatter
-      # The separator for the fill algorithm.
-      class Separator
-        def call(q)
-          q.text(",")
-          q.fill_breakable
-        end
-      end
-
-      # [Args] the contents of the array
-      attr_reader :contents
-
-      def initialize(contents)
-        @contents = contents
-      end
-
-      def format(q)
-        q.text("[")
-        q.group do
-          q.indent do
-            q.breakable_empty
-            q.seplist(contents.parts, Separator.new) { |part| q.format(part) }
-            q.if_break { q.text(",") } if q.trailing_comma?
-          end
-          q.breakable_empty
-        end
-        q.text("]")
-      end
-    end
-
     # This is a special formatter used if the array literal contains no values
     # but _does_ contain comments. In this case we do some special formatting to
     # make sure the comments gets indented properly.
@@ -1206,19 +1177,17 @@ module SyntaxTree
     end
 
     def format(q)
-      if qwords?
-        QWordsFormatter.new(contents).format(q)
-        return
-      end
-
-      if qsymbols?
-        QSymbolsFormatter.new(contents).format(q)
-        return
-      end
+      if lbracket.comments.empty? && contents && contents.comments.empty? &&
+           contents.parts.length > 1
+        if qwords?
+          QWordsFormatter.new(contents).format(q)
+          return
+        end
 
-      if var_refs?(q)
-        VarRefsFormatter.new(contents).format(q)
-        return
+        if qsymbols?
+          QSymbolsFormatter.new(contents).format(q)
+          return
+        end
       end
 
       if empty_with_comments?
@@ -1250,39 +1219,24 @@ module SyntaxTree
     private
 
     def qwords?
-      lbracket.comments.empty? && contents && contents.comments.empty? &&
-        contents.parts.length > 1 &&
-        contents.parts.all? do |part|
-          case part
-          when StringLiteral
-            part.comments.empty? && part.parts.length == 1 &&
-              part.parts.first.is_a?(TStringContent) &&
-              !part.parts.first.value.match?(/[\s\[\]\\]/)
-          when CHAR
-            !part.value.match?(/[\[\]\\]/)
-          else
-            false
-          end
+      contents.parts.all? do |part|
+        case part
+        when StringLiteral
+          part.comments.empty? && part.parts.length == 1 &&
+            part.parts.first.is_a?(TStringContent) &&
+            !part.parts.first.value.match?(/[\s\[\]\\]/)
+        when CHAR
+          !part.value.match?(/[\[\]\\]/)
+        else
+          false
         end
+      end
     end
 
     def qsymbols?
-      lbracket.comments.empty? && contents && contents.comments.empty? &&
-        contents.parts.length > 1 &&
-        contents.parts.all? do |part|
-          part.is_a?(SymbolLiteral) && part.comments.empty?
-        end
-    end
-
-    def var_refs?(q)
-      lbracket.comments.empty? && contents && contents.comments.empty? &&
-        contents.parts.all? do |part|
-          part.is_a?(VarRef) && part.comments.empty?
-        end &&
-        (
-          contents.parts.sum { |part| part.value.value.length + 2 } >
-            q.maxwidth * 2
-        )
+      contents.parts.all? do |part|
+        part.is_a?(SymbolLiteral) && part.comments.empty?
+      end
     end
 
     # If we have an empty array that contains only comments, then we're going
@@ -3001,16 +2955,25 @@ module SyntaxTree
       else
         q.format(message)
 
-        if arguments.is_a?(ArgParen) && arguments.arguments.nil? &&
-             !message.is_a?(Const)
-          # If you're using an explicit set of parentheses on something that
-          # looks like a constant, then we need to match that in order to
-          # maintain valid Ruby. For example, you could do something like Foo(),
-          # on which we would need to keep the parentheses to make it look like
-          # a method call.
-        else
-          q.format(arguments)
-        end
+        # Note that this explicitly leaves parentheses in place even if they are
+        # empty. There are two reasons we would need to do this. The first is if
+        # we're calling something that looks like a constant, as in:
+        #
+        #     Foo()
+        #
+        # In this case if we remove the parentheses then this becomes a constant
+        # reference and not a method call. The second is if we're calling a
+        # method that is the same name as a local variable that is in scope, as
+        # in:
+        #
+        #     foo = foo()
+        #
+        # In this case we have to keep the parentheses or else it treats this
+        # like assigning nil to the local variable. Note that we could attempt
+        # to be smarter about this by tracking the local variables that are in
+        # scope, but for now it's simpler and more efficient to just leave the
+        # parentheses in place.
+        q.format(arguments) if arguments
       end
     end
 
@@ -3059,6 +3022,10 @@ module SyntaxTree
         end
       end
     end
+
+    def arity
+      arguments&.arity || 0
+    end
   end
 
   # Case represents the beginning of a case chain.
@@ -3472,6 +3439,10 @@ module SyntaxTree
         arguments === other.arguments && block === other.block
     end
 
+    def arity
+      arguments.arity
+    end
+
     private
 
     def align(q, node, &block)
@@ -3637,6 +3608,10 @@ module SyntaxTree
         arguments === other.arguments && block === other.block
     end
 
+    def arity
+      arguments&.arity || 0
+    end
+
     private
 
     def argument_alignment(q, doc)
@@ -4166,6 +4141,17 @@ module SyntaxTree
     def endless?
       !bodystmt.is_a?(BodyStmt)
     end
+
+    def arity
+      case params
+      when Params
+        params.arity
+      when Paren
+        params.contents.arity
+      else
+        0..0
+      end
+    end
   end
 
   # Defined represents the use of the +defined?+ operator. It can be used with
@@ -4353,6 +4339,15 @@ module SyntaxTree
       opening.is_a?(Kw)
     end
 
+    def arity
+      case block_var
+      when BlockVar
+        block_var.params.arity
+      else
+        0..0
+      end
+    end
+
     private
 
     # If this is nested anywhere inside certain nodes, then we can't change
@@ -6144,7 +6139,7 @@ module SyntaxTree
   module Ternaryable
     class << self
       def call(q, node)
-        return false if ENV["STREE_FAST_FORMAT"]
+        return false if ENV["STREE_FAST_FORMAT"] || q.disable_auto_ternary?
 
         # If this is a conditional inside of a parentheses as the only content,
         # then we don't want to transform it into a ternary. Presumably the user
@@ -6487,9 +6482,26 @@ module SyntaxTree
 
     def format(q)
       force_flat = [
-        AliasNode, Assign, Break, Command, CommandCall, Heredoc, IfNode, IfOp,
-        Lambda, MAssign, Next, OpAssign, RescueMod, ReturnNode, Super, Undef,
-        UnlessNode, VoidStmt, YieldNode, ZSuper
+        AliasNode,
+        Assign,
+        Break,
+        Command,
+        CommandCall,
+        Heredoc,
+        IfNode,
+        IfOp,
+        Lambda,
+        MAssign,
+        Next,
+        OpAssign,
+        RescueMod,
+        ReturnNode,
+        Super,
+        Undef,
+        UnlessNode,
+        VoidStmt,
+        YieldNode,
+        ZSuper
       ]
 
       if q.parent.is_a?(Paren) || force_flat.include?(truthy.class) ||
@@ -8316,6 +8328,29 @@ module SyntaxTree
         keyword_rest === other.keyword_rest && block === other.block
     end
 
+    # Returns a range representing the possible number of arguments accepted
+    # by this params node not including the block. For example:
+    #
+    #     def foo(a, b = 1, c:, d: 2, &block)
+    #       ...
+    #     end
+    #
+    # has arity 2..4.
+    #
+    def arity
+      optional_keywords = keywords.count { |_label, value| value }
+
+      lower_bound =
+        requireds.length + posts.length + keywords.length - optional_keywords
+
+      upper_bound =
+        if keyword_rest.nil? && rest.nil?
+          lower_bound + optionals.length + optional_keywords
+        end
+
+      lower_bound..upper_bound
+    end
+
     private
 
     def format_contents(q, parts)
@@ -11585,6 +11620,10 @@ module SyntaxTree
     def access_control?
       @access_control ||= %w[private protected public].include?(value.value)
     end
+
+    def arity
+      0
+    end
   end
 
   # VoidStmt represents an empty lexical block of code.

data/lib/syntax_tree/parser.rb

@@ -53,7 +53,7 @@ module SyntaxTree
       # there's a BOM at the beginning of the file, which is the reason we need
       # to compare it to 0 here.
       def [](byteindex)
-        indices[byteindex < 0 ? 0 : byteindex]
+        indices[[byteindex, 0].max]
       end
     end
 
@@ -1103,6 +1103,7 @@ module SyntaxTree
     # :call-seq:
     #   on_comment: (String value) -> Comment
     def on_comment(value)
+      # char is the index of the # character in the source.
       char = char_pos
       location =
         Location.token(
@@ -1112,8 +1113,24 @@ module SyntaxTree
           size: value.size - 1
         )
 
-      index = source.rindex(/[^\t ]/, char - 1) if char != 0
-      inline = index && (source[index] != "\n")
+      # Loop backward in the source string, starting from the beginning of the
+      # comment, and find the first character that is not a space or a tab. If
+      # index is -1, this indicates that we've checked all of the characters
+      # back to the start of the source, so this comment must be at the
+      # beginning of the file.
+      #
+      # We are purposefully not using rindex or regular expressions here because
+      # they check if there are invalid characters, which is actually possible
+      # with the use of __END__ syntax.
+      index = char - 1
+      while index > -1 && (source[index] == "\t" || source[index] == " ")
+        index -= 1
+      end
+
+      # If we found a character that was not a space or a tab before the comment
+      # and it's a newline, then this comment is inline. Otherwise, it stands on
+      # its own and can be attached as its own node in the tree.
+      inline = index != -1 && source[index] != "\n"
       comment =
         Comment.new(value: value.chomp, inline: inline, location: location)
 

data/lib/syntax_tree/plugin/disable_ternary.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  class Formatter
+    DISABLE_TERNARY = true
+  end
+end

data/lib/syntax_tree/version.rb

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

data/lib/syntax_tree/yarv/assembler.rb

@@ -62,22 +62,26 @@ module SyntaxTree
         "constant-from"
       ].freeze
 
-      attr_reader :filepath
+      attr_reader :lines
 
-      def initialize(filepath)
-        @filepath = filepath
+      def initialize(lines)
+        @lines = lines
       end
 
       def assemble
-        iseq = InstructionSequence.new(:top, "<main>", nil, Location.default)
-        assemble_iseq(iseq, File.readlines(filepath, chomp: true))
+        iseq = InstructionSequence.new("<main>", "<compiled>", 1, :top)
+        assemble_iseq(iseq, lines)
 
         iseq.compile!
         iseq
       end
 
-      def self.assemble(filepath)
-        new(filepath).assemble
+      def self.assemble(source)
+        new(source.lines(chomp: true)).assemble
+      end
+
+      def self.assemble_file(filepath)
+        new(File.readlines(filepath, chomp: true)).assemble
       end
 
       private
@@ -138,7 +142,7 @@ module SyntaxTree
             name = parse_symbol(name_value)
             flags = parse_number(flags_value)
 
-            class_iseq = iseq.class_child_iseq(name.to_s, Location.default)
+            class_iseq = iseq.class_child_iseq(name.to_s, 1)
             assemble_iseq(class_iseq, body)
             iseq.defineclass(name, class_iseq, flags)
           when "defined"
@@ -153,7 +157,7 @@ module SyntaxTree
             line_index += body.length
 
             name = parse_symbol(operands)
-            method_iseq = iseq.method_child_iseq(name.to_s, Location.default)
+            method_iseq = iseq.method_child_iseq(name.to_s, 1)
             assemble_iseq(method_iseq, body)
 
             iseq.definemethod(name, method_iseq)
@@ -162,7 +166,7 @@ module SyntaxTree
             line_index += body.length
 
             name = parse_symbol(operands)
-            method_iseq = iseq.method_child_iseq(name.to_s, Location.default)
+            method_iseq = iseq.method_child_iseq(name.to_s, 1)
 
             assemble_iseq(method_iseq, body)
             iseq.definesmethod(name, method_iseq)
@@ -221,7 +225,7 @@ module SyntaxTree
                 body = parse_nested(lines[line_index..])
                 line_index += body.length
 
-                block_iseq = iseq.block_child_iseq(Location.default)
+                block_iseq = iseq.block_child_iseq(1)
                 assemble_iseq(block_iseq, body)
                 block_iseq
               end
@@ -249,7 +253,7 @@ module SyntaxTree
                 body = parse_nested(lines[line_index..])
                 line_index += body.length
 
-                block_iseq = iseq.block_child_iseq(Location.default)
+                block_iseq = iseq.block_child_iseq(1)
                 assemble_iseq(block_iseq, body)
                 block_iseq
               end
@@ -354,7 +358,7 @@ module SyntaxTree
                 body = parse_nested(lines[line_index..])
                 line_index += body.length
 
-                block_iseq = iseq.block_child_iseq(Location.default)
+                block_iseq = iseq.block_child_iseq(1)
                 assemble_iseq(block_iseq, body)
                 block_iseq
               end

data/lib/syntax_tree/yarv/bf.rb

@@ -13,7 +13,7 @@ module SyntaxTree
 
       def compile
         # Set up the top-level instruction sequence that will be returned.
-        iseq = InstructionSequence.new(:top, "<compiled>", nil, location)
+        iseq = InstructionSequence.new("<compiled>", "<compiled>", 1, :top)
 
         # Set up the $tape global variable that will hold our state.
         iseq.duphash({ 0 => 0 })
@@ -80,19 +80,6 @@ module SyntaxTree
 
       private
 
-      # This is the location of the top instruction sequence, derived from the
-      # source string.
-      def location
-        Location.new(
-          start_line: 1,
-          start_char: 0,
-          start_column: 0,
-          end_line: source.count("\n") + 1,
-          end_char: source.size,
-          end_column: source.size - (source.rindex("\n") || 0) - 1
-        )
-      end
-
       # $tape[$cursor] += value
       def change_by(iseq, value)
         iseq.getglobal(:$tape)
@@ -111,6 +98,7 @@ module SyntaxTree
         end
 
         iseq.send(YARV.calldata(:[]=, 2))
+        iseq.pop
       end
 
       # $cursor += value
@@ -138,6 +126,7 @@ module SyntaxTree
         iseq.send(YARV.calldata(:chr))
 
         iseq.send(YARV.calldata(:putc, 1))
+        iseq.pop
       end
 
       # $tape[$cursor] = $stdin.getc.ord
@@ -150,6 +139,7 @@ module SyntaxTree
         iseq.send(YARV.calldata(:ord))
 
         iseq.send(YARV.calldata(:[]=, 2))
+        iseq.pop
       end
 
       # unless $tape[$cursor] == 0
@@ -164,14 +154,21 @@ module SyntaxTree
 
         iseq.putobject(0)
         iseq.send(YARV.calldata(:==, 1))
-        iseq.branchunless(end_label)
+        iseq.branchif(end_label)
 
         [start_label, end_label]
       end
 
       # Jump back to the start of the loop.
       def loop_end(iseq, start_label, end_label)
-        iseq.jump(start_label)
+        iseq.getglobal(:$tape)
+        iseq.getglobal(:$cursor)
+        iseq.send(YARV.calldata(:[], 1))
+
+        iseq.putobject(0)
+        iseq.send(YARV.calldata(:==, 1))
+        iseq.branchunless(start_label)
+
         iseq.push(end_label)
       end
     end