ast_transform 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a74867dd7f6d788c78d286901e1e4c6a362e0a341300fb9bb22ccb92503a0223
-  data.tar.gz: c2968b8000a875e169f89d85deaa38868ad49dcc8d193db6a78c88ea4eafb986
+  metadata.gz: 4bd9891c7329570100d1f706978508d03249b188472557bbe2a6ffef3813ccf3
+  data.tar.gz: d2f1620ea7475a63a255c41085db71deb6716e3a28b0dd8a1970a46884a1d742
 SHA512:
-  metadata.gz: 9f4e007503a09479a7df3f595097bf384eb0196fb192cd012855c63417582e34a32cfd318ae765f1a8122de408bbfd337c8e3adfe889d2fd1bc36b3a20c96599
-  data.tar.gz: 900412939feb57ee329d2c3adca9b9712c1da8243038268104db916f9270ea09427d0d96cbf5aded11f86d919d4b45e6629be20372eb4dfc1d0531f05757b1e5
+  metadata.gz: 1212107491dedeffe09b7d1f54303cf784aef2ccc3c9da16b9fe81d1f98c377e32bf14a484d4089b3dc16d9b9087d30a1d6b0a5a5caeb61ca965c88cd2218902
+  data.tar.gz: 0af32ba36db47e621cb661879763b1aa8092b114f0f8fe49ba50bcf49612da879a99ad873523f9f9d75d704a508d9303f73bd8d09f259d78c0aa85497a934097

data/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [3.2.0] - 2026-11-08
+### Fixed
+- One-parameter blocks no longer auto-splat their argument after transformation: `[[1, 2]].each { |a| }` emitted as `{ |a,| }` (the trailing-comma form), so `a` saw `1` instead of `[1, 2]`. The parser builder opted into `emit_kwargs` alone and otherwise produced the parser gem's legacy AST, in which a lone `s(:arg)` under `s(:args)` is what Unparser (written against the modern AST) reads as `|a,|`. Lambdas were affected the same way (`->(a) {}` emitted as `lambda { |a,| }`), and forwarding defs lost their header (`def m(...)` emitted as `def m`). (#21)
+
+### Changed
+- `ASTTransform::KwargsBuilder` is now `ASTTransform::ModernBuilder` and opts into the parser gem's full `modernize` set rather than `emit_kwargs` alone. Transformations and analyses now see the modern node shapes: `s(:args, s(:procarg0, s(:arg, :a)))` for `|a|`, `:index`/`:indexasgn` for `foo[1]`/`foo[1] = 2` (previously `:send` with `:[]`/`:[]=`), `:lambda` for `->() {}` (previously `s(:send, nil, :lambda)`), `s(:args, s(:forward_arg))` for `def m(...)` (previously `:forward_args`), and `s(:__ENCODING__)` for `__ENCODING__` (previously the `Encoding` constant). `:kwargs` and `:match_pattern`/`:match_pattern_p` are unchanged: the former was already on, and Prism's translation emits the latter regardless of the flag. Passes that pattern-match the legacy shapes must update.
+
+## [3.1.1] - 2026-08-03
+### Fixed
+- Line-aligned emission no longer packs displaced statements or container closers onto a heredoc terminator line. Unparser legitimately falls back to `<<-HEREDOC` emission when a dstr fails its quoted-string round-trip; the emitter now treats such a render as line-terminal and opens a fresh line instead, trading one line of alignment for valid Ruby. (#16)
+
 ## [3.1.0] - 2026-07-29
 ### Added
 - Analysis passes: `ASTTransform::AbstractAnalysis`, the read-only counterpart of `AbstractTransformation`. Both leaves share the extracted traversal core `ASTTransform::AbstractProcessor` (sealed `process`, `process_node` hook, thunk descent, `TransformationHelper`) and differ only in what `run` returns — the rebuilt tree for transformations, the analysis instance (result readers) for analyses.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ast_transform (3.1.0)
+    ast_transform (3.2.0)
       parser (>= 3.3)
       prism (>= 1.5)
       unparser (>= 0.8)

data/lib/ast_transform/layout.rb

@@ -9,6 +9,7 @@ module ASTTransform
   class Layout
     def initialize
       @lines = []
+      @sealed = false
     end
 
     # The line number currently being written; the next fresh line would be +cursor + 1+.
@@ -21,7 +22,10 @@ module ASTTransform
     # +column+ — cosmetic only (leading whitespace is never significant in emitted code), but it keeps the artifact
     # visually close to the source. Packed text ignores the column, as do continuation lines (they keep their own
     # relative indentation).
-    def place(target_line, text, column: nil)
+    #
+    # +seal+ declares the text's last line unextendable (the caller's property — e.g. it terminates a heredoc,
+    # whose terminator must stand alone): a subsequent pack opens a fresh line instead of joining it.
+    def place(target_line, text, column: nil, seal: false)
       first, *rest = text.split("\n")
 
       if target_line && target_line > @lines.size
@@ -32,22 +36,27 @@ module ASTTransform
       end
 
       @lines.concat(rest)
+      @sealed = seal
     end
 
     # Appends +text+ on a new line unconditionally — for text that must never be `;`-packed after a statement
     # (e.g. keywords).
     def place_on_fresh_line(text)
       @lines << text
+      @sealed = false
     end
 
-    # Appends +text+ to the current line with a `; ` separator. The last line is never blank here: padding blanks
-    # are only created inside +place+, which immediately overwrites the padded line.
+    # Appends +text+ to the current line with a `; ` separator — unless the current line is sealed, in which case
+    # the text opens a fresh line (alignment degrades by one more line; validity is preserved). The last line is
+    # never blank here: padding blanks are only created inside +place+, which immediately overwrites the padded
+    # line.
     def pack(text)
-      if @lines.empty?
+      if @lines.empty? || @sealed
         @lines << text
       else
         @lines[-1] = "#{@lines.last}; #{text}"
       end
+      @sealed = false
     end
 
     # @return [String] the laid-out text, with a trailing newline.

data/lib/ast_transform/line_aligned_emitter.rb

@@ -71,7 +71,9 @@ module ASTTransform
       if recursive_container?(node)
         emit_container(node, layout, renderer)
       else
-        layout.place(node.loc&.line, renderer.aligned_render(node), column: node.loc&.column)
+        render = renderer.aligned_render(node)
+        # A render in heredoc form seals its line: nothing may pack after the terminator (issue #16).
+        layout.place(node.loc&.line, render, column: node.loc&.column, seal: renderer.line_terminal?(render))
       end
     end
 
@@ -145,7 +147,8 @@ module ASTTransform
     # nested statements align.
     def emit_container(node, layout, renderer)
       opener, closer = container_delimiters(node, renderer)
-      layout.place(node.loc&.line, opener, column: node.loc&.column)
+      # An opener can carry a heredoc too (e.g. a block call with a heredoc argument) — seal it like a statement.
+      layout.place(node.loc&.line, opener, column: node.loc&.column, seal: renderer.line_terminal?(opener))
       emit_body(container_body(node), layout, renderer)
       layout.place(closer_line(node), closer, column: closer_column(node))
     end

data/lib/ast_transform/modern_builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "prism/translation/parser"
+
+module ASTTransform
+  # The framework's parser builder: the stock builder with the parser gem's `modernize` opt-ins, which produce the
+  # modern AST (`:procarg0`, `:index`/`:indexasgn`, `:lambda`, `:forward_args`, `:kwargs`, `:match_pattern`, ...).
+  #
+  # Unparser is written against the modern AST, so parsing in the gem's legacy compatibility shapes changes meaning
+  # at emission. Two examples that matter to any transformed source:
+  #
+  # - Block parameters: in the modern AST `{ |a| }` is `s(:args, s(:procarg0, s(:arg, :a)))`, and a lone bare
+  #   `s(:arg)` means the trailing-comma form `{ |a,| }`. The legacy shape for `{ |a| }` is that lone `s(:arg)`, so
+  #   Unparser emitted `|a,|` and every one-parameter block auto-splatted its argument (#21).
+  # - Keyword arguments: with `emit_kwargs` off, `foo(bar: 1)` and `foo({ bar: 1 })` both parse as :hash; Unparser
+  #   braces :hash and not :kwargs, and Ruby 3+ treats the two as different calls.
+  #
+  # The flags are class-level ivars, so modernizing here opts in this builder only — the global
+  # Parser::Builders::Default stays untouched.
+  #
+  # NOTE: parsed nodes deliberately stay plain Parser::AST::Node. Custom node classes exist only for registered
+  # custom types (see ASTTransform::Node), which are IR and never reach Unparser: AST::Node#eql? compares class, and
+  # Unparser verifies dynamic-string emission by re-parsing and comparing eql? against the freshly parsed
+  # (plain-class) node — custom-class nodes of standard types would fail that verification.
+  class ModernBuilder < Prism::Translation::Parser::Builder
+    modernize
+  end
+end

data/lib/ast_transform/source_parser.rb

@@ -2,7 +2,7 @@
 
 require "prism"
 require "prism/translation/parser"
-require "ast_transform/kwargs_builder"
+require "ast_transform/modern_builder"
 
 module ASTTransform
   # Owns source → AST parsing: Prism's C parser through its whitequark translation layer, so every consumer gets the
@@ -11,10 +11,10 @@ module ASTTransform
   class SourceParser
     # Constructs a new SourceParser instance.
     #
-    # KwargsBuilder is a required implementation detail, not an injection seam: the framework's emission depends
-    # on the kwargs/hash distinction it preserves, so every parse goes through it.
+    # ModernBuilder is a required implementation detail, not an injection seam: the framework's emission depends
+    # on the modern AST shapes it produces, so every parse goes through it.
     def initialize
-      @builder = KwargsBuilder.new
+      @builder = ModernBuilder.new
     end
 
     # Parses the given +source+.

data/lib/ast_transform/statement_renderer.rb

@@ -62,8 +62,30 @@ module ASTTransform
       compress_to_single_line(render) || render
     end
 
+    # Whether +render+ must be the last text on its final line: a render ending on a heredoc terminator (Unparser
+    # falls back to `<<-HEREDOC` form when its quoted-string round-trip fails) cannot have anything `;`-packed
+    # after it — the terminator must stand alone, so a join unterminates the heredoc. Probed by re-parse, the same
+    # verification style as +compress_to_single_line+, behind a cheap textual gate: only a heredoc makes a last
+    # line unextendable, and every heredoc opener contains +<<+. A false positive (the probe failing for another
+    # reason, e.g. an isolated container opener carrying a heredoc argument) costs one line of alignment, never
+    # correctness.
+    def line_terminal?(render)
+      return false unless render.include?('<<')
+
+      # chomp: heredoc renders end with a trailing newline; the probe must extend the last *line* (where the
+      # layout would pack), not append below it.
+      !parses?("#{render.chomp}; nil")
+    end
+
     private
 
+    def parses?(source)
+      Unparser.parse(source)
+      true
+    rescue Parser::SyntaxError
+      false
+    end
+
     def compress_to_single_line(render)
       candidate = render.split("\n").map(&:strip).join('; ')
       # Both sides parsed without scope context, so lvar/send ambiguity cancels out; equality means the newline

data/lib/ast_transform/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ASTTransform
-  VERSION = "3.1.0"
+  VERSION = "3.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ast_transform
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Jean-Philippe Duchesne
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-29 00:00:00.000000000 Z
+date: 2026-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -87,9 +87,9 @@ files:
 - lib/ast_transform/instruction_sequence/bootsnap_mixin.rb
 - lib/ast_transform/instruction_sequence/mixin.rb
 - lib/ast_transform/instruction_sequence/mixin_utils.rb
-- lib/ast_transform/kwargs_builder.rb
 - lib/ast_transform/layout.rb
 - lib/ast_transform/line_aligned_emitter.rb
+- lib/ast_transform/modern_builder.rb
 - lib/ast_transform/node.rb
 - lib/ast_transform/source_parser.rb
 - lib/ast_transform/statement_renderer.rb

data/lib/ast_transform/kwargs_builder.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "prism/translation/parser"
-
-module ASTTransform
-  # The framework's parser builder: the stock builder with the parser gem's `emit_kwargs` opt-in, which
-  # distinguishes keyword arguments from hash literals in the AST.
-  #
-  # With the flag off (the gem's compatibility default) both `foo(bar: 1)` and `foo({ bar: 1 })` emit :hash nodes.
-  # Unparser uses the node type to decide whether to emit braces: :hash gets `{}`, :kwargs does not. Since Ruby 3.0+
-  # treats these as semantically different (strict keyword/positional separation), the AST must preserve the
-  # distinction. `emit_kwargs` rewrites at the call sites where kwargs semantics live (method calls, index,
-  # super/yield); the flag is a class-level ivar, so setting it here opts in this builder only — the global
-  # Parser::Builders::Default stays untouched.
-  #
-  # NOTE: parsed nodes deliberately stay plain Parser::AST::Node. Custom node classes exist only for registered
-  # custom types (see ASTTransform::Node), which are IR and never reach Unparser: AST::Node#eql? compares class, and
-  # Unparser verifies dynamic-string emission by re-parsing and comparing eql? against the freshly parsed
-  # (plain-class) node — custom-class nodes of standard types would fail that verification.
-  class KwargsBuilder < Prism::Translation::Parser::Builder
-    self.emit_kwargs = true
-  end
-end