Ruby 3.1 syntax

Author: kddnewton

Gemfile.lock

@@ -40,4 +40,4 @@ DEPENDENCIES
   syntax_tree!
 
 BUNDLED WITH
-   2.2.15
+   2.2.31

lib/syntax_tree.rb

@@ -1173,7 +1173,7 @@ def on_args_add(arguments, argument)
   #     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 @@ def child_nodes
 
     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,13 +1223,14 @@ def to_json(*opts)
   #     (false | untyped) block
   #   ) -> Args
   def on_args_add_block(arguments, block)
-    return arguments unless block
+    operator = find_token(Op, "&", consume: false)
+    return arguments unless operator
 
-    arg_block =
-      ArgBlock.new(
-        value: block,
-        location: find_token(Op, "&").location.to(block.location)
-      )
+    tokens.delete(operator)
+    location = operator.location
+    location = operator.location.to(block.location) if block
+
+    arg_block = ArgBlock.new(value: block, location: location)
 
     Args.new(
       parts: arguments.parts << arg_block,
@@ -1896,7 +1899,7 @@ def child_nodes
     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 +1913,10 @@ def pretty_print(q)
         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 +1936,7 @@ def to_json(*opts)
 
     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 +1953,10 @@ def format_contents(q)
   # :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
@@ -2578,7 +2587,7 @@ def on_block_var(params, locals)
   #     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 +2608,17 @@ def child_nodes
 
     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 +2636,10 @@ def to_json(*opts)
   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
@@ -4419,7 +4433,7 @@ class DefEndless
     # [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 +4477,12 @@ def format(q)
         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 +4548,6 @@ def on_def(name, params, bodystmt)
     # 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 +4563,35 @@ def on_def(name, params, bodystmt)
       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 +4799,37 @@ def on_defs(target, operator, name, params, bodystmt)
     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 +8948,7 @@ def format(q)
     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 +9063,7 @@ def format(q)
         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 +9163,8 @@ def to_json(*opts)
   #     (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 +9182,7 @@ def on_params(
       *posts,
       *keywords&.flat_map { |(key, value)| [key, value || nil] },
       (keyword_rest if keyword_rest != :nil),
-      block
+      (block if block != :&)
     ].compact
 
     location =
@@ -9178,7 +9199,7 @@ def on_params(
       posts: posts || [],
       keywords: keywords || [],
       keyword_rest: keyword_rest,
-      block: block,
+      block: (block if block != :&),
       location: location
     )
   end

test/fixtures/arg_block.rb

@@ -14,3 +14,7 @@
 foo(
   &bar.bazzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
 )
+% # >= 3.1.0
+def foo(&)
+  bar(&)
+end

test/fixtures/args_forward.rb

@@ -1,4 +1,8 @@
 %
-def get(...)
-  request(:GET, ...)
+def foo(...)
+  bar(:baz, ...)
+end
+% # >= 3.1.0
+def foo(foo, bar = baz, ...)
+  bar(:baz, ...)
 end

test/fixtures/assoc.rb

@@ -38,3 +38,5 @@
     foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
   ]
 }
+% # >= 3.1.0
+{ foo: }

test/fixtures/def_endless.rb

@@ -6,3 +6,5 @@ def foo(bar) = baz
 def foo() = bar
 -
 def foo = bar
+% # >= 3.1.0
+def foo = bar baz