From 7c8f4d2a5d9fa2199b0353999dbe46337e023c61 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sun, 30 Aug 2026 12:17:30 +0200 Subject: [PATCH] fix(parser): assignment as a parenthesised call argument stops at the comma MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A parenthesised call/array argument list gathered an assignment's right-hand side across commas into an implicit array, so `f(a = 1, b = 2, 3)` parsed as a single argument `a = [1, b = [2, 3]]` instead of the three arguments `a = 1`, `b = 2`, `3`. The comma inside `(…)` / `[…]` separates arguments (or elements), so multiple-assignment detection must be off there — exactly as the paren-less parseCommandArgs and the def parameter-default / keyword-argument-value paths already do. parseCallArgs now suppresses masgn detection (p.noMasgn) for the span of the argument list, so an assignment argument's value stops at the comma. A parenthesised sub-expression re-enters a statement context and restores masgn, so `f((a, b = 1, 2))` is unaffected, and a top-level `x = 1, 2, 3` still gathers its array RHS. This is the standard mspec idiom for the mutating converter methods, e.g. `ec.primitive_convert(src = +"…", dst = +"", nil, 10)`, which failed with "no implicit conversion of Array into String". go vet, the full suite and the 100% coverage gate stay green. Co-authored-by: Claude Opus 4.8 --- paren_call_arg_assign_test.go | 81 +++++++++++++++++++++++++++++++++++ parser.go | 9 +++- 2 files changed, 89 insertions(+), 1 deletion(-) create mode 100644 paren_call_arg_assign_test.go diff --git a/paren_call_arg_assign_test.go b/paren_call_arg_assign_test.go new file mode 100644 index 0000000..f21ca1a --- /dev/null +++ b/paren_call_arg_assign_test.go @@ -0,0 +1,81 @@ +package parser + +import ( + "testing" + + "github.com/go-ruby-parser/parser/ast" +) + +// TestParenCallArgAssign covers assignment expressions used as parenthesised +// call arguments (and array elements): the comma separates arguments, so an +// assignment's right-hand side stops at it rather than gathering an implicit +// array. `f(a = 1, b = 2, 3)` is three arguments, not `f(a = [1, b = [2, 3]])`. +// This mirrors the paren-less command-argument and def parameter-default rules, +// which already suppress multiple-assignment detection. Regression for the +// mspec idiom `ec.primitive_convert(src = +"...", dst = +"", nil, 10)`. +func TestParenCallArgAssign(t *testing.T) { + cases := []struct { + src string + nargs int + }{ + {`g(s = 1, d = 2, 3)`, 3}, + {`g(a = 1, b = 2)`, 2}, + {`f(x = 1)`, 1}, + {`ec.primitive_convert(src = +"a", dst = +"", nil, 10)`, 4}, + {`f(obj.x = 1, 2)`, 2}, + {`f(a = 1, 2, 3)`, 3}, + } + for _, c := range cases { + prog, err := Parse(c.src) + if err != nil { + t.Fatalf("Parse(%q) error: %v", c.src, err) + } + var call *ast.Call + switch n := prog.Body[0].(type) { + case *ast.Call: + call = n + case *ast.Assign: + // A leading `x = f(...)` wraps the call as the assignment value. + call, _ = n.Value.(*ast.Call) + } + if call == nil { + t.Fatalf("%q: expected a call, got %T", c.src, prog.Body[0]) + } + if len(call.Args) != c.nargs { + t.Errorf("%q: got %d args, want %d", c.src, len(call.Args), c.nargs) + } + // No argument may itself be an implicit-array RHS (the pre-fix defect + // nested the trailing arguments into the first assignment's value). + for i, a := range call.Args { + if asn, ok := a.(*ast.Assign); ok { + if _, isArr := asn.Value.(*ast.ArrayLit); isArr { + t.Errorf("%q: arg %d assignment gathered an array RHS", c.src, i) + } + } + } + } +} + +// TestParenArrayElemAssign covers assignment expressions as array-literal +// elements: `[x = 1, 2]` is a two-element array, not a one-element array holding +// `x = [1, 2]`. +func TestParenArrayElemAssign(t *testing.T) { + prog, err := Parse(`[x = 1, 2, 3]`) + if err != nil { + t.Fatalf("Parse error: %v", err) + } + arr, ok := prog.Body[0].(*ast.ArrayLit) + if !ok { + t.Fatalf("expected *ast.ArrayLit, got %T", prog.Body[0]) + } + if len(arr.Elems) != 3 { + t.Fatalf("got %d elements, want 3", len(arr.Elems)) + } + asn, ok := arr.Elems[0].(*ast.Assign) + if !ok { + t.Fatalf("expected first element *ast.Assign, got %T", arr.Elems[0]) + } + if _, isArr := asn.Value.(*ast.ArrayLit); isArr { + t.Fatalf("first element's assignment gathered an array RHS") + } +} diff --git a/parser.go b/parser.go index 72ac20c..498098f 100644 --- a/parser.go +++ b/parser.go @@ -3198,7 +3198,14 @@ func (p *Parser) parseCallArgs(until token.Type) []ast.Node { // to that argument, not to any enclosing command call, so re-enable it. savedRescue := p.noRescueMod p.noRescueMod = false - defer func() { p.bracketDepth--; p.noRescueMod = savedRescue }() + // The comma separates arguments (or array elements), so multiple-assignment + // detection must be off: `f(a = 1, b = 2, 3)` is three arguments (the first two + // assignments), not `f(a = [1, b = [2, 3]])`, and `[x = 1, 2]` is a two-element + // array. An assignment argument's value stops at the comma. Mirrors the paren- + // less parseCommandArgs and def parameter-default handling. + savedMasgn := p.noMasgn + p.noMasgn = true + defer func() { p.bracketDepth--; p.noRescueMod = savedRescue; p.noMasgn = savedMasgn }() var args []ast.Node var kw *ast.HashLit p.skipNewlines()