syntax_tree 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 123ef3ac2fa068f2c1f5d653c1eaf0d57c68ab0c17fc632401f0aead46ed8577
-  data.tar.gz: 166fedda529629024fae922db271b4f96294851ea16ea065ffd4f89c2d4671e9
+  metadata.gz: 4797ffd100da9b050f154cd0ac4a235b342c395e49747ee51574eb0e0f9fcf1a
+  data.tar.gz: 52babf707ae1bf42abaeb51b350644fc50f61fa1b74482abb776e863d2ec48dd
 SHA512:
-  metadata.gz: 3b3bf4c737c16159b2bac2329e9999b841c88a43e21a783da7df7e691b27e27f5fb85dbfceb3ec97bcd2309993fec7f5b994abc2e71ec4c3c6f3dfc76a2da05e
-  data.tar.gz: 62d250a1322985c29f53eb6259e084e3ebb2dd54e4e507250ba2338fdf149d15fe6e4683b8026602d0a8e219935fc91c8d2459a15a31f0a43054970886d7b262
+  metadata.gz: 62e28b7e6b25e81bdfb70817c02152bd640395149c1ac75fa553154ebb636c9c913dbf2ebda7a65f9687dd1bb69d51e0e3d8f5ffba172d0b1eadb5849e64369a
+  data.tar.gz: 6233b01960317929ce137305a08f45d3d756d741b5f6b6d037f2499377a53922f222543f433912cc853ee31726e2306527fbe29c75ad757e6125207b7476956c

data/.github/workflows/main.yml

@@ -13,7 +13,7 @@ jobs:
     - uses: ruby/setup-ruby@v1
       with:
         bundler-cache: true
-        ruby-version: 3.0
+        ruby-version: '3.1'
     - name: Test
       run: bundle exec rake test
   automerge:

data/CHANGELOG.md

@@ -6,6 +6,14 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [1.2.0] - 2022-01-09
+
+### Added
+
+- Support for Ruby 3.1 syntax, including: blocks without names, hash keys without values, endless methods without parentheses, and new argument forwarding.
+- Support for pinned expressions and variables within pattern matching.
+- Support endless ranges as the final argument to a `when` clause.
+
 ## [1.1.1] - 2021-12-09
 
 ### Added
@@ -97,7 +105,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 - 🎉 Initial release! 🎉
 
-[unreleased]: https://github.com/kddnewton/syntax_tree/compare/v1.1.1...HEAD
+[unreleased]: https://github.com/kddnewton/syntax_tree/compare/v1.2.0...HEAD
+[1.2.0]: https://github.com/kddnewton/syntax_tree/compare/v1.1.1...v1.2.0
 [1.1.1]: https://github.com/kddnewton/syntax_tree/compare/v1.1.0...v1.1.1
 [1.1.0]: https://github.com/kddnewton/syntax_tree/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/kddnewton/syntax_tree/compare/v0.1.0...v1.0.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    syntax_tree (1.1.1)
+    syntax_tree (1.2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -9,8 +9,8 @@ GEM
     ast (2.4.2)
     benchmark-ips (2.9.2)
     docile (1.4.0)
-    minitest (5.14.4)
-    parser (3.0.3.2)
+    minitest (5.15.0)
+    parser (3.1.0.0)
       ast (~> 2.4.1)
     rake (13.0.6)
     ruby_parser (3.18.1)
@@ -26,6 +26,7 @@ GEM
 
 PLATFORMS
   x86_64-darwin-19
+  x86_64-darwin-21
   x86_64-linux
 
 DEPENDENCIES
@@ -40,4 +41,4 @@ DEPENDENCIES
   syntax_tree!
 
 BUNDLED WITH
-   2.2.15
+   2.2.31

data/lib/syntax_tree/version.rb

@@ -3,5 +3,5 @@
 require "ripper"
 
 class SyntaxTree < Ripper
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/lib/syntax_tree.rb

@@ -1173,7 +1173,7 @@ class SyntaxTree < Ripper
   #     method(&expression)
   #
   class ArgBlock
-    # [untyped] the expression being turned into a block
+    # [nil | untyped] the expression being turned into a block
     attr_reader :value
 
     # [Location] the location of this node
@@ -1194,15 +1194,17 @@ class SyntaxTree < Ripper
 
     def format(q)
       q.text("&")
-      q.format(value)
+      q.format(value) if value
     end
 
     def pretty_print(q)
       q.group(2, "(", ")") do
         q.text("arg_block")
 
-        q.breakable
-        q.pp(value)
+        if value
+          q.breakable
+          q.pp(value)
+        end
 
         q.pp(Comment::List.new(comments))
       end
@@ -1221,17 +1223,34 @@ class SyntaxTree < Ripper
   #     (false | untyped) block
   #   ) -> Args
   def on_args_add_block(arguments, block)
-    return arguments unless block
+    operator = find_token(Op, "&", consume: false)
 
-    arg_block =
-      ArgBlock.new(
-        value: block,
-        location: find_token(Op, "&").location.to(block.location)
-      )
+    # If we can't find the & operator, then there's no block to add to the list,
+    # so we're just going to return the arguments as-is.
+    return arguments unless operator
+
+    # Now we know we have an & operator, so we're going to delete it from the
+    # list of tokens to make sure it doesn't get confused with anything else.
+    tokens.delete(operator)
+
+    # Construct the location that represents the block argument.
+    location = operator.location
+    location = operator.location.to(block.location) if block
+
+    # If there are any arguments and the operator we found from the list is not
+    # after them, then we're going to return the arguments as-is because we're
+    # looking at an & that occurs before the arguments are done.
+    if arguments.parts.any? && location.start_char < arguments.location.end_char
+      return arguments
+    end
+
+    # Otherwise, we're looking at an actual block argument (with or without a
+    # block, which could be missing because it could be a bare & since 3.1.0).
+    arg_block = ArgBlock.new(value: block, location: location)
 
     Args.new(
       parts: arguments.parts << arg_block,
-      location: arguments.location.to(arg_block.location)
+      location: arguments.location.to(location)
     )
   end
 
@@ -1676,10 +1695,13 @@ class SyntaxTree < Ripper
       parts += posts
 
       if constant
-        q.format(constant)
-        q.text("[")
-        q.seplist(parts) { |part| q.format(part) }
-        q.text("]")
+        q.group do
+          q.format(constant)
+          q.text("[")
+          q.seplist(parts) { |part| q.format(part) }
+          q.text("]")
+        end
+
         return
       end
 
@@ -1689,7 +1711,7 @@ class SyntaxTree < Ripper
         q.seplist(parts) { |part| q.format(part) }
         q.text("]")
       else
-        q.seplist(parts) { |part| q.format(part) }
+        q.group { q.seplist(parts) { |part| q.format(part) } }
       end
     end
 
@@ -1896,7 +1918,7 @@ class SyntaxTree < Ripper
     end
 
     def format(q)
-      if value.is_a?(HashLiteral)
+      if value&.is_a?(HashLiteral)
         format_contents(q)
       else
         q.group { format_contents(q) }
@@ -1910,8 +1932,10 @@ class SyntaxTree < Ripper
         q.breakable
         q.pp(key)
 
-        q.breakable
-        q.pp(value)
+        if value
+          q.breakable
+          q.pp(value)
+        end
 
         q.pp(Comment::List.new(comments))
       end
@@ -1931,6 +1955,7 @@ class SyntaxTree < Ripper
 
     def format_contents(q)
       q.parent.format_key(q, key)
+      return unless value
 
       if key.comments.empty? && AssignFormatting.skip_indent?(value)
         q.text(" ")
@@ -1947,7 +1972,10 @@ class SyntaxTree < Ripper
   # :call-seq:
   #   on_assoc_new: (untyped key, untyped value) -> Assoc
   def on_assoc_new(key, value)
-    Assoc.new(key: key, value: value, location: key.location.to(value.location))
+    location = key.location
+    location = location.to(value.location) if value
+
+    Assoc.new(key: key, value: value, location: location)
   end
 
   # AssocSplat represents double-splatting a value into a hash (either a hash
@@ -2315,24 +2343,95 @@ class SyntaxTree < Ripper
     end
   end
 
+  # PinnedBegin represents a pinning a nested statement within pattern matching.
+  #
+  #     case value
+  #     in ^(statement)
+  #     end
+  #
+  class PinnedBegin
+    # [untyped] the expression being pinned
+    attr_reader :statement
+
+    # [Location] the location of this node
+    attr_reader :location
+
+    # [Array[ Comment | EmbDoc ]] the comments attached to this node
+    attr_reader :comments
+
+    def initialize(statement:, location:, comments: [])
+      @statement = statement
+      @location = location
+      @comments = comments
+    end
+
+    def child_nodes
+      [statement]
+    end
+
+    def format(q)
+      q.group do
+        q.text("^(")
+        q.nest(1) do
+          q.indent do
+            q.breakable("")
+            q.format(statement)
+          end
+          q.breakable("")
+          q.text(")")
+        end
+      end
+    end
+
+    def pretty_print(q)
+      q.group(2, "(", ")") do
+        q.text("pinned_begin")
+
+        q.breakable
+        q.pp(statement)
+
+        q.pp(Comment::List.new(comments))
+      end
+    end
+
+    def to_json(*opts)
+      {
+        type: :pinned_begin,
+        stmt: statement,
+        loc: location,
+        cmts: comments
+      }.to_json(*opts)
+    end
+  end
+
   # :call-seq:
-  #   on_begin: (BodyStmt bodystmt) -> Begin
+  #   on_begin: (untyped bodystmt) -> Begin | PinnedBegin
   def on_begin(bodystmt)
-    keyword = find_token(Kw, "begin")
-    end_char =
-      if bodystmt.rescue_clause || bodystmt.ensure_clause ||
-           bodystmt.else_clause
-        bodystmt.location.end_char
-      else
-        find_token(Kw, "end").location.end_char
-      end
+    pin = find_token(Op, "^", consume: false)
 
-    bodystmt.bind(keyword.location.end_char, end_char)
+    if pin && pin.location.start_char < bodystmt.location.start_char
+      tokens.delete(pin)
+      find_token(LParen)
 
-    Begin.new(
-      bodystmt: bodystmt,
-      location: keyword.location.to(bodystmt.location)
-    )
+      rparen = find_token(RParen)
+      location = pin.location.to(rparen.location)
+
+      PinnedBegin.new(statement: bodystmt, location: location)
+    else
+      keyword = find_token(Kw, "begin")
+      end_char =
+        if bodystmt.rescue_clause || bodystmt.ensure_clause ||
+            bodystmt.else_clause
+          bodystmt.location.end_char
+        else
+          find_token(Kw, "end").location.end_char
+        end
+
+      bodystmt.bind(keyword.location.end_char, end_char)
+      location = keyword.location.to(bodystmt.location)
+
+      Begin.new(bodystmt: bodystmt, location: location)
+    end
   end
 
   # Binary represents any expression that involves two sub-expressions with an
@@ -2423,12 +2522,29 @@ class SyntaxTree < Ripper
   # :call-seq:
   #   on_binary: (untyped left, (Op | Symbol) operator, untyped right) -> Binary
   def on_binary(left, operator, right)
-    # On most Ruby implementations, operator is a Symbol that represents that
-    # operation being performed. For instance in the example `1 < 2`, the
-    # `operator` object would be `:<`. However, on JRuby, it's an `@op` node,
-    # so here we're going to explicitly convert it into the same normalized
-    # form.
-    operator = tokens.delete(operator).value unless operator.is_a?(Symbol)
+    if operator.is_a?(Symbol)
+      # Here, we're going to search backward for the token that's between the
+      # two operands that matches the operator so we can delete it from the
+      # list.
+      index =
+        tokens.rindex do |token|
+          location = token.location
+
+          token.is_a?(Op) &&
+            token.value == operator.to_s &&
+            location.start_char > left.location.end_char &&
+            location.end_char < right.location.start_char
+        end
+
+      tokens.delete_at(index) if index
+    else
+      # On most Ruby implementations, operator is a Symbol that represents that
+      # operation being performed. For instance in the example `1 < 2`, the
+      # `operator` object would be `:<`. However, on JRuby, it's an `@op` node,
+      # so here we're going to explicitly convert it into the same normalized
+      # form.
+      operator = tokens.delete(operator).value
+    end
 
     Binary.new(
       left: left,
@@ -2578,7 +2694,7 @@ class SyntaxTree < Ripper
   #     def method(&block); end
   #
   class BlockArg
-    # [Ident] the name of the block argument
+    # [nil | Ident] the name of the block argument
     attr_reader :name
 
     # [Location] the location of this node
@@ -2599,15 +2715,17 @@ class SyntaxTree < Ripper
 
     def format(q)
       q.text("&")
-      q.format(name)
+      q.format(name) if name
     end
 
     def pretty_print(q)
       q.group(2, "(", ")") do
         q.text("blockarg")
 
-        q.breakable
-        q.pp(name)
+        if name
+          q.breakable
+          q.pp(name)
+        end
 
         q.pp(Comment::List.new(comments))
       end
@@ -2625,7 +2743,10 @@ class SyntaxTree < Ripper
   def on_blockarg(name)
     operator = find_token(Op, "&")
 
-    BlockArg.new(name: name, location: operator.location.to(name.location))
+    location = operator.location
+    location = location.to(name.location) if name
+
+    BlockArg.new(name: name, location: location)
   end
 
   # bodystmt can't actually determine its bounds appropriately because it
@@ -3968,6 +4089,10 @@ class SyntaxTree < Ripper
       []
     end
 
+    def child_nodes
+      []
+    end
+
     def format(q)
       q.text(value)
     end
@@ -4419,7 +4544,7 @@ class SyntaxTree < Ripper
     # [Backtick | Const | Ident | Kw | Op] the name of the method
     attr_reader :name
 
-    # [nil | Paren] the parameter declaration for the method
+    # [nil | Params | Paren] the parameter declaration for the method
     attr_reader :paren
 
     # [untyped] the expression to be executed by the method
@@ -4463,7 +4588,12 @@ class SyntaxTree < Ripper
         end
 
         q.format(name)
-        q.format(paren) if paren && !paren.contents.empty?
+
+        if paren
+          params = paren
+          params = params.contents if params.is_a?(Paren)
+          q.format(paren) unless params.empty?
+        end
 
         q.text(" =")
         q.group do
@@ -4529,21 +4659,6 @@ class SyntaxTree < Ripper
     # and normal method definitions.
     beginning = find_token(Kw, "def")
 
-    # If we don't have a bodystmt node, then we have a single-line method
-    unless bodystmt.is_a?(BodyStmt)
-      node =
-        DefEndless.new(
-          target: nil,
-          operator: nil,
-          name: name,
-          paren: params,
-          statement: bodystmt,
-          location: beginning.location.to(bodystmt.location)
-        )
-
-      return node
-    end
-
     # If there aren't any params then we need to correct the params node
     # location information
     if params.is_a?(Params) && params.empty?
@@ -4559,18 +4674,35 @@ class SyntaxTree < Ripper
       params = Params.new(location: location)
     end
 
-    ending = find_token(Kw, "end")
-    bodystmt.bind(
-      find_next_statement_start(params.location.end_char),
-      ending.location.start_char
-    )
+    ending = find_token(Kw, "end", consume: false)
 
-    Def.new(
-      name: name,
-      params: params,
-      bodystmt: bodystmt,
-      location: beginning.location.to(ending.location)
-    )
+    if ending
+      tokens.delete(ending)
+      bodystmt.bind(
+        find_next_statement_start(params.location.end_char),
+        ending.location.start_char
+      )
+
+      Def.new(
+        name: name,
+        params: params,
+        bodystmt: bodystmt,
+        location: beginning.location.to(ending.location)
+      )
+    else
+      # In Ruby >= 3.1.0, this is a BodyStmt that wraps a single statement in
+      # the statements list. Before, it was just the individual statement.
+      statement = bodystmt.is_a?(BodyStmt) ? bodystmt.statements : bodystmt
+
+      DefEndless.new(
+        target: nil,
+        operator: nil,
+        name: name,
+        paren: params,
+        statement: statement,
+        location: beginning.location.to(bodystmt.location)
+      )
+    end
   end
 
   # Defined represents the use of the +defined?+ operator. It can be used with
@@ -4778,37 +4910,37 @@ class SyntaxTree < Ripper
     end
 
     beginning = find_token(Kw, "def")
+    ending = find_token(Kw, "end", consume: false)
 
-    # If we don't have a bodystmt node, then we have a single-line method
-    unless bodystmt.is_a?(BodyStmt)
-      node =
-        DefEndless.new(
-          target: target,
-          operator: operator,
-          name: name,
-          paren: params,
-          statement: bodystmt,
-          location: beginning.location.to(bodystmt.location)
-        )
-
-      return node
-    end
-
-    ending = find_token(Kw, "end")
+    if ending
+      tokens.delete(ending)
+      bodystmt.bind(
+        find_next_statement_start(params.location.end_char),
+        ending.location.start_char
+      )
 
-    bodystmt.bind(
-      find_next_statement_start(params.location.end_char),
-      ending.location.start_char
-    )
+      Defs.new(
+        target: target,
+        operator: operator,
+        name: name,
+        params: params,
+        bodystmt: bodystmt,
+        location: beginning.location.to(ending.location)
+      )
+    else
+      # In Ruby >= 3.1.0, this is a BodyStmt that wraps a single statement in
+      # the statements list. Before, it was just the individual statement.
+      statement = bodystmt.is_a?(BodyStmt) ? bodystmt.statements : bodystmt
 
-    Defs.new(
-      target: target,
-      operator: operator,
-      name: name,
-      params: params,
-      bodystmt: bodystmt,
-      location: beginning.location.to(ending.location)
-    )
+      DefEndless.new(
+        target: target,
+        operator: operator,
+        name: name,
+        paren: params,
+        statement: statement,
+        location: beginning.location.to(bodystmt.location)
+      )
+    end
   end
 
   # DoBlock represents passing a block to a method call using the +do+ and +end+
@@ -8927,7 +9059,7 @@ class SyntaxTree < Ripper
     end
 
     class KeywordRestFormatter
-      # [:nil | KwRestParam] the value of the parameter
+      # [:nil | ArgsForward | KwRestParam] the value of the parameter
       attr_reader :value
 
       def initialize(value)
@@ -9042,7 +9174,7 @@ class SyntaxTree < Ripper
         q.format(rest) if rest && rest.is_a?(ExcessedComma)
       end
 
-      if [Def, Defs].include?(q.parent.class)
+      if [Def, Defs, DefEndless].include?(q.parent.class)
         q.group(0, "(", ")") do
           q.indent do
             q.breakable("")
@@ -9142,8 +9274,8 @@ class SyntaxTree < Ripper
   #     (nil | ArgsForward | ExcessedComma | RestParam) rest,
   #     (nil | Array[Ident]) posts,
   #     (nil | Array[[Ident, nil | untyped]]) keywords,
-  #     (nil | :nil | KwRestParam) keyword_rest,
-  #     (nil | BlockArg) block
+  #     (nil | :nil | ArgsForward | KwRestParam) keyword_rest,
+  #     (nil | :& | BlockArg) block
   #   ) -> Params
   def on_params(
     requireds,
@@ -9161,7 +9293,7 @@ class SyntaxTree < Ripper
       *posts,
       *keywords&.flat_map { |(key, value)| [key, value || nil] },
       (keyword_rest if keyword_rest != :nil),
-      block
+      (block if block != :&)
     ].compact
 
     location =
@@ -9178,7 +9310,7 @@ class SyntaxTree < Ripper
       posts: posts || [],
       keywords: keywords || [],
       keyword_rest: keyword_rest,
-      block: block,
+      block: (block if block != :&),
       location: location
     )
   end
@@ -12901,10 +13033,70 @@ class SyntaxTree < Ripper
     end
   end
 
+  # PinnedVarRef represents a pinned variable reference within a pattern
+  # matching pattern.
+  #
+  #     case value
+  #     in ^variable
+  #     end
+  #
+  # This can be a plain local variable like the example above. It can also be a
+  # a class variable, a global variable, or an instance variable.
+  class PinnedVarRef
+    # [VarRef] the value of this node
+    attr_reader :value
+
+    # [Location] the location of this node
+    attr_reader :location
+
+    # [Array[ Comment | EmbDoc ]] the comments attached to this node
+    attr_reader :comments
+
+    def initialize(value:, location:, comments: [])
+      @value = value
+      @location = location
+      @comments = comments
+    end
+
+    def child_nodes
+      [value]
+    end
+
+    def format(q)
+      q.group do
+        q.text("^")
+        q.format(value)
+      end
+    end
+
+    def pretty_print(q)
+      q.group(2, "(", ")") do
+        q.text("pinned_var_ref")
+
+        q.breakable
+        q.pp(value)
+
+        q.pp(Comment::List.new(comments))
+      end
+    end
+
+    def to_json(*opts)
+      { type: :pinned_var_ref, value: value, loc: location, cmts: comments }
+        .to_json(*opts)
+    end
+  end
+
   # :call-seq:
   #   on_var_ref: ((Const | CVar | GVar | Ident | IVar | Kw) value) -> VarRef
   def on_var_ref(value)
-    VarRef.new(value: value, location: value.location)
+    pin = find_token(Op, "^", consume: false)
+
+    if pin && pin.location.start_char == value.location.start_char - 1
+      tokens.delete(pin)
+      PinnedVarRef.new(value: value, location: pin.location.to(value.location))
+    else
+      VarRef.new(value: value, location: value.location)
+    end
   end
 
   # VCall represent any plain named object with Ruby that could be either a
@@ -12976,6 +13168,10 @@ class SyntaxTree < Ripper
       @comments = comments
     end
 
+    def child_nodes
+      []
+    end
+
     def format(q)
     end
 
@@ -13050,6 +13246,14 @@ class SyntaxTree < Ripper
               separator = -> { q.group { q.comma_breakable } }
               q.seplist(arguments.parts, separator) { |part| q.format(part) }
             end
+
+            # Very special case here. If you're inside of a when clause and the
+            # last argument to the predicate is and endless range, then you are
+            # forced to use the "then" keyword to make it parse properly.
+            last = arguments.parts.last
+            if (last.is_a?(Dot2) || last.is_a?(Dot3)) && !last.right
+              q.text(" then")
+            end
           end
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-09 00:00:00.000000000 Z
+date: 2022-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.0.dev
 signing_key:
 specification_version: 4
 summary: A parser based on ripper