diff --git a/blink/internal/fixer/rules/braces_position.go b/blink/internal/fixer/rules/braces_position.go
index 66d0cbbc56..3da1e6ac1c 100644
--- a/blink/internal/fixer/rules/braces_position.go
+++ b/blink/internal/fixer/rules/braces_position.go
@@ -1,7 +1,8 @@
 package rules
 
 import (
-	"strings"
+	"regexp"
+	"slices"
 
 	"github.com/ecsphp/ecs-src/blink/internal/fixer"
 	"github.com/ecsphp/ecs-src/blink/internal/token"
@@ -84,14 +85,8 @@ func (f BracesPosition) Fix(s *tokens.Stream) bool {
 		switch kind {
 		case braceClassLike:
 			category = "classes"
-			// an anonymous class ("new class ... {", also "new #[Attr] class ... {")
-			// is configured separately; step back over any leading attribute
-			if kw >= 0 {
-				if p := prevMeaningfulSkippingAttributes(s, kw); p >= 0 {
-					if prev := s.At(p); prev.Kind == token.Keyword && strings.EqualFold(prev.Value, "new") {
-						category = "anon_classes"
-					}
-				}
+			if taIsAnonymousClass(s, kw) {
+				category = "anon_classes"
 			}
 		case braceFunctionDecl:
 			category = "functions"
@@ -117,17 +112,23 @@ func (f BracesPosition) Fix(s *tokens.Stream) bool {
 		}
 
 		if nextLine, handle := f.wantNextLine(category, s, i); handle {
+			if target := bpBraceTarget(s, i, nextLine); target >= 0 {
+				i = bpMoveBrace(s, i, target)
+				changed = true
+			}
 			want := " "
 			if nextLine {
 				// php-cs-fixer aligns the brace with the line holding the keyword
 				want = "\n" + lineIndent(s, kw)
 			}
-			if i > 0 && s.At(i-1).Kind == token.Whitespace {
+			switch {
+			case !nextLine && bpFollowsLineComment(s, i):
+			case i > 0 && s.At(i-1).Kind == token.Whitespace:
 				if s.At(i-1).Value != want {
 					s.SetValue(i-1, want)
 					changed = true
 				}
-			} else {
+			default:
 				s.InsertAt(i, token.Token{Kind: token.Whitespace, Value: want})
 				i++
 				changed = true
@@ -141,6 +142,117 @@ func (f BracesPosition) Fix(s *tokens.Stream) bool {
 	return changed
 }
 
+// bpBraceTarget is PHP-CS-Fixer's $moveBraceToIndex: where the brace goes so that a
+// comment next to it stays out of the way, or -1. On the same line the brace goes
+// before the comments, as written after "// c" it would be part of the comment. On the
+// next line it goes after a "//" or "#" comment that follows it.
+func bpBraceTarget(s *tokens.Stream, open int, nextLine bool) int {
+	if nextLine {
+		return bpTargetAfterComment(s, open)
+	}
+	target := -1
+	previous := prevMeaningfulIndex(s, open)
+	for i := open - 1; i > previous; i-- {
+		if !isComment(s.At(i)) {
+			continue
+		}
+		i--
+		if s.At(i).Kind == token.Whitespace {
+			target = i
+		} else if i == previous {
+			target = previous + 1
+		}
+	}
+	// PHP-CS-Fixer moves it here too and writes a parse error
+	if target < 0 || isLineComment(s.At(target-1)) || s.MatchForward(open) < 0 {
+		return -1
+	}
+	return target
+}
+
+func bpTargetAfterComment(s *tokens.Stream, open int) int {
+	if before := s.At(open - 1); before.Kind == token.Whitespace && hasNewline(before.Value) {
+		return -1
+	}
+	closing := s.MatchForward(open)
+	if closing < 0 {
+		return -1
+	}
+	target := -1
+	for i := open + 1; i < closing; i++ {
+		t := s.At(i)
+		// PHP-CS-Fixer has already put a one-line body on its own line at this point;
+		// blink has not, so stop at code or the brace would jump over it
+		if t.Kind == token.Whitespace && hasNewline(t.Value) || t.Kind != token.Whitespace && !isComment(t) {
+			break
+		}
+		// blink's "// c ?>" comment keeps the space, so the close tag can follow directly
+		if isLineComment(t) && s.At(i+1).Kind == token.Whitespace {
+			target = i + 1
+		}
+	}
+	return target
+}
+
+// bpFollowsLineComment reports a brace whose line starts after a "//" or "#" comment:
+// on the same line as that comment it would be part of it.
+func bpFollowsLineComment(s *tokens.Stream, open int) bool {
+	before := open - 1
+	if s.At(before).Kind == token.Whitespace {
+		before--
+	}
+	return isLineComment(s.At(before))
+}
+
+var bpLeadingBreakRe = regexp.MustCompile(`^(?:[ \t]*?(?:\r\n|\n|\r))?[ \t]*`)
+
+// bpMoveBrace moves the brace at open to target like PHP-CS-Fixer: the tokens between
+// shift by one, and the whitespace left on either side is cleared or merged. It returns
+// the new index of the brace.
+func bpMoveBrace(s *tokens.Stream, open, target int) int {
+	first, last := min(open-1, target), max(open+1, target)
+	work := slices.Clone(s.Tokens()[first : last+1])
+	at := func(i int) *token.Token { return &work[i-first] }
+	clearAt := func(i int) { *at(i) = token.Token{Kind: token.Whitespace} }
+	isSpace := func(i int) bool { return at(i).Kind == token.Whitespace }
+
+	brace := *at(open)
+	delta := 1
+	if open > target {
+		delta = -1
+	}
+	if isSpace(open + delta) {
+		if delta == -1 && hasNewline(at(open-1).Value) {
+			if isSpace(open + 1) {
+				at(open + 1).Value = bpLeadingBreakRe.ReplaceAllString(at(open+1).Value, "")
+			}
+		} else if isSpace(open - 1) {
+			clearAt(open - 1)
+		}
+	}
+	for i := open; i != target; i += delta {
+		*at(i) = *at(i + delta)
+	}
+	*at(target) = brace
+	if isSpace(open) && isSpace(open+1) {
+		at(open).Value += at(open + 1).Value
+		clearAt(open + 1)
+	}
+
+	moved := make([]token.Token, 0, len(work))
+	index := -1
+	for i, t := range work {
+		if i+first == target {
+			index = first + len(moved)
+		}
+		if t.Value != "" {
+			moved = append(moved, t)
+		}
+	}
+	s.ReplaceRange(first, last, moved)
+	return index
+}
+
 // closureBodyNeedsNewlines reports whether the body of the anonymous function
 // whose "{" is at open goes on lines of its own: always when
 // allow_single_line_anonymous_functions is false, and otherwise only when
diff --git a/blink/internal/fixer/rules/braces_position_comment_guard_test.go b/blink/internal/fixer/rules/braces_position_comment_guard_test.go
new file mode 100644
index 0000000000..55455c6e2f
--- /dev/null
+++ b/blink/internal/fixer/rules/braces_position_comment_guard_test.go
@@ -0,0 +1,63 @@
+package rules
+
+import (
+	"strings"
+	"testing"
+)
+
+// PHP-CS-Fixer first puts the body on its own line, which blink does not do, so its output
+// is no reference. The brace must not jump over the code to reach the comment.
+func TestBracesPositionBraceStaysBeforeCode(t *testing.T) {
+	t.Parallel()
+	got, _ := apply(t, BracesPosition{}, "<?php\nclass A { public function f() { // c\n        echo 1;\n    }\n}\n")
+	if !strings.HasPrefix(got, "<?php\nclass A\n{ public function f()") {
+		t.Fatalf("got=%q", got)
+	}
+}
+
+// The PHP engine throws on an unclosed brace, so there is no output to match. The brace
+// must stay where it is, and it must not stop the run.
+func TestBracesPositionUnclosedBraceAtEndOfFile(t *testing.T) {
+	t.Parallel()
+	cases := []struct{ src, want string }{
+		{"<?php\nif ($b) /* c */{", "<?php\nif ($b) /* c */ {"},
+		{"<?php\nif ($b) // c\n{", "<?php\nif ($b) // c\n{"},
+		{"<?php\nif ($b) /* c */ {", "<?php\nif ($b) /* c */ {"},
+	}
+	for _, c := range cases {
+		if got, _ := apply(t, BracesPosition{}, c.src); got != c.want {
+			t.Errorf("%s\n got=%q\nwant=%q", c.src, got, c.want)
+		}
+	}
+}
+
+// PHP-CS-Fixer writes the brace inside the comment on these, so its output is no reference.
+func TestBracesPositionBraceStaysOutOfLineComment(t *testing.T) {
+	t.Parallel()
+	for _, src := range []string{
+		"<?php\nif ($b) /*a*/// c\n{\n    echo 1;\n}\n",
+		"<?php\nif ($b)/*a*/// c\n{\n    echo 1;\n}\n",
+		"<?php\nif ($b) /*a*/# c\n{\n    echo 1;\n}\n",
+		"<?php\nif ($b) /*a*/// c\n/*d*/{\n    echo 1;\n}\n",
+	} {
+		got, _ := apply(t, BracesPosition{}, src)
+		for line := range strings.Lines(got) {
+			if comment := strings.Index(line, "//"); comment >= 0 && strings.Contains(line[comment:], "{") {
+				t.Errorf("%s got=%q", src, got)
+			}
+			if comment := strings.Index(line, "#"); comment >= 0 && strings.Contains(line[comment:], "{") {
+				t.Errorf("%s got=%q", src, got)
+			}
+		}
+	}
+}
+
+// PHP-CS-Fixer ends the comment before the space, so its output is no reference: the brace
+// must not go past the close tag, where it would be inline HTML.
+func TestBracesPositionBraceStaysBeforeCloseTag(t *testing.T) {
+	t.Parallel()
+	got, _ := apply(t, BracesPosition{}, "<?php\nfunction f() { // e ?>\n<b>x</b>\n<?php\n}\n")
+	if want := "<?php\nfunction f()\n{ // e ?>\n<b>x</b>\n<?php\n}\n"; got != want {
+		t.Fatalf("\n got=%q\nwant=%q", got, want)
+	}
+}
diff --git a/blink/internal/fixer/rules/braces_position_comment_next_line_test.go b/blink/internal/fixer/rules/braces_position_comment_next_line_test.go
new file mode 100644
index 0000000000..cb3ee82dee
--- /dev/null
+++ b/blink/internal/fixer/rules/braces_position_comment_next_line_test.go
@@ -0,0 +1,29 @@
+package rules
+
+import "testing"
+
+// The expected output of every case comes from the PHP engine.
+func TestBracesPositionCommentNextLine(t *testing.T) {
+	t.Parallel()
+	cases := []struct{ src, want string }{
+		{"if ($b) { // c\n    echo 1;\n}", "if ($b) // c\n{echo 1;\n}"},
+		{"if ($b) { # c\n    echo 1;\n}", "if ($b) # c\n{echo 1;\n}"},
+		{"if ($b) { /* c */\n    echo 1;\n}", "if ($b)\n{ /* c */\n    echo 1;\n}"},
+		{"if ($b)\n{ // c\n    echo 1;\n}", "if ($b)\n{ // c\n    echo 1;\n}"},
+		{"foreach ($a as $b) { // c\n    echo 1;\n}", "foreach ($a as $b) // c\n{echo 1;\n}"},
+		{"try { // c\n    echo 1;\n} catch (E $e) { // e\n    echo 2;\n}", "try // c\n{echo 1;\n} catch (E $e) // e\n{echo 2;\n}"},
+		{"$a = new class { // c\n    public $x;\n};", "$a = new class // c\n{public $x;\n};"},
+		{"$a = new class($b) implements C { // c\n    public $x;\n};", "$a = new class($b) implements C // c\n{public $x;\n};"},
+		{"$a = new class /* c */ {\n    public $x;\n};", "$a = new class /* c */\n{\n    public $x;\n};"},
+		{"$f = function () { // c\n    echo 1;\n};", "$f = function () // c\n{echo 1;\n};"},
+		{"$f = function () use ($a) { // c\n    echo 1;\n};", "$f = function () use ($a) // c\n{echo 1;\n};"},
+		{"$f = function () /* c */ {\n    echo 1;\n};", "$f = function () /* c */\n{\n    echo 1;\n};"},
+		{"if ($b) // c\n{\n    echo 1;\n}", "if ($b) // c\n{\n    echo 1;\n}"},
+	}
+	for _, c := range cases {
+		got, changed := apply(t, BracesPosition{}.WithConfig(map[string]any{"control_structures_opening_brace": bracesNextLine, "anonymous_classes_opening_brace": bracesNextLine, "anonymous_functions_opening_brace": bracesNextLine}).(fixerRule), "<?php\n"+c.src+"\n")
+		if want := "<?php\n" + c.want + "\n"; got != want || changed != (c.src != c.want) {
+			t.Errorf("%s\n got=%q changed=%v\nwant=%q", c.src, got, changed, want)
+		}
+	}
+}
diff --git a/blink/internal/fixer/rules/braces_position_comment_test.go b/blink/internal/fixer/rules/braces_position_comment_test.go
new file mode 100644
index 0000000000..18c8a4cdd6
--- /dev/null
+++ b/blink/internal/fixer/rules/braces_position_comment_test.go
@@ -0,0 +1,57 @@
+package rules
+
+import "testing"
+
+// The expected output of every case comes from the PHP engine.
+func TestBracesPositionComment(t *testing.T) {
+	t.Parallel()
+	cases := []struct{ src, want string }{
+		{"if ($b) // c\n{\n    echo 1;\n}", "if ($b) { // c\necho 1;\n}"},
+		{"if ($b) # c\n{\n    echo 1;\n}", "if ($b) { # c\necho 1;\n}"},
+		{"if ($b) /* c */\n{\n    echo 1;\n}", "if ($b) { /* c */\necho 1;\n}"},
+		{"if ($b) /* c */ {\n    echo 1;\n}", "if ($b) { /* c */\n    echo 1;\n}"},
+		{"if ($b)/* c */{\n    echo 1;\n}", "if ($b) {/* c */\n    echo 1;\n}"},
+		{"if ($b) /** d */\n{\n    echo 1;\n}", "if ($b) { /** d */\necho 1;\n}"},
+		{"if ($b)\n// c\n{\n    echo 1;\n}", "if ($b) {\n// c\necho 1;\n}"},
+		{"if ($b) // c\n// e\n{\n    echo 1;\n}", "if ($b) { // c\n// e\necho 1;\n}"},
+		{"if ($b) // c\n/* e */\n{\n    echo 1;\n}", "if ($b) { // c\n/* e */\necho 1;\n}"},
+		{"if ($b) // c\n\n{\n    echo 1;\n}", "if ($b) { // c\n\necho 1;\n}"},
+		{"if ($b)// c\n{\n    echo 1;\n}", "if ($b) {// c\necho 1;\n}"},
+		{"if ($b) { // c\n    echo 1;\n}", "if ($b) { // c\n    echo 1;\n}"},
+		{"if ($b) // c\n{ // e\n    echo 1;\n}", "if ($b) { // c\n// e\n    echo 1;\n}"},
+		{"foreach ($a as $b) // c\n{\n    echo 1;\n}", "foreach ($a as $b) { // c\necho 1;\n}"},
+		{"while ($b) // c\n{\n    echo 1;\n}", "while ($b) { // c\necho 1;\n}"},
+		{"for (;;) // c\n{\n    echo 1;\n}", "for (;;) { // c\necho 1;\n}"},
+		{"do // c\n{\n    echo 1;\n} while ($b);", "do { // c\necho 1;\n} while ($b);"},
+		{"try // c\n{\n    echo 1;\n} catch (E $e) // e\n{\n} finally // f\n{\n}", "try { // c\necho 1;\n} catch (E $e) { // e\n} finally { // f\n}"},
+		{"switch ($b) // c\n{\n    case 1:\n}", "switch ($b) { // c\ncase 1:\n}"},
+		{"if ($b) {\n} else // c\n{\n    echo 1;\n}", "if ($b) {\n} else { // c\necho 1;\n}"},
+		{"if ($b) {\n} elseif ($c) // c\n{\n    echo 1;\n}", "if ($b) {\n} elseif ($c) { // c\necho 1;\n}"},
+		{"$a = new class // c\n{\n    public $x;\n};", "$a = new class { // c\npublic $x;\n};"},
+		{"$a = new class # c\n{\n    public $x;\n};", "$a = new class { # c\npublic $x;\n};"},
+		{"$a = new class /* c */\n{\n    public $x;\n};", "$a = new class { /* c */\npublic $x;\n};"},
+		{"$a = new class /* c */ {\n    public $x;\n};", "$a = new class { /* c */\n    public $x;\n};"},
+		{"$a = new class($b) // c\n{\n    public $x;\n};", "$a = new class($b) { // c\npublic $x;\n};"},
+		{"$a = new class($b) implements C // c\n{\n    public $x;\n};", "$a = new class($b) implements C { // c\npublic $x;\n};"},
+		{"$a = new class\n// c\n{\n    public $x;\n};", "$a = new class {\n// c\npublic $x;\n};"},
+		{"class A // c\n{\n}", "class A // c\n{\n}"},
+		{"class A /* c */ {\n}", "class A /* c */\n{\n}"},
+		{"class A // c\n{\n    public $x;\n}", "class A // c\n{\n    public $x;\n}"},
+		{"class A { // c\n    public $x;\n}", "class A // c\n{public $x;\n}"},
+		{"class A { /* c */\n    public $x;\n}", "class A\n{ /* c */\n    public $x;\n}"},
+		{"class A { # c\n    public $x;\n}", "class A # c\n{public $x;\n}"},
+		{"class A { /** d */\n    public $x;\n}", "class A\n{ /** d */\n    public $x;\n}"},
+		{"class A\n{ // c\n    public $x;\n}", "class A\n{ // c\n    public $x;\n}"},
+		{"class A {// c\n    public $x;\n}", "class A // c\n{public $x;\n}"},
+		{"function f() // c\n{\n}", "function f() // c\n{\n}"},
+		{"function f() { // c\n    echo 1;\n}", "function f() // c\n{echo 1;\n}"},
+		{"function f(): void // c\n{\n    echo 1;\n}", "function f(): void // c\n{\n    echo 1;\n}"},
+		{"function f() /* c */ {\n    echo 1;\n}", "function f() /* c */\n{\n    echo 1;\n}"},
+	}
+	for _, c := range cases {
+		got, changed := apply(t, BracesPosition{}, "<?php\n"+c.src+"\n")
+		if want := "<?php\n" + c.want + "\n"; got != want || changed != (c.src != c.want) {
+			t.Errorf("%s\n got=%q changed=%v\nwant=%q", c.src, got, changed, want)
+		}
+	}
+}
diff --git a/blink/internal/fixer/rules/braces_position_readonly_anonymous_test.go b/blink/internal/fixer/rules/braces_position_readonly_anonymous_test.go
new file mode 100644
index 0000000000..77f23c0f08
--- /dev/null
+++ b/blink/internal/fixer/rules/braces_position_readonly_anonymous_test.go
@@ -0,0 +1,49 @@
+package rules
+
+import "testing"
+
+// The expected output of every case comes from the PHP engine.
+func TestBracesPositionReadonlyAnonymousClass(t *testing.T) {
+	t.Parallel()
+	cases := []struct{ src, want string }{
+		{"$a = new class {};", "$a = new class {};"},
+		{"$a = new class {\n};", "$a = new class {\n};"},
+		{"$a = new class\n{\n};", "$a = new class {\n};"},
+		{"$a = new readonly class {\n};", "$a = new readonly class {\n};"},
+		{"$a = new readonly class\n{\n};", "$a = new readonly class {\n};"},
+		{"$a = new readonly class() {\n};", "$a = new readonly class() {\n};"},
+		{"$a = new readonly class()\n{\n};", "$a = new readonly class() {\n};"},
+		{"$a = new readonly class($b) {\n};", "$a = new readonly class($b) {\n};"},
+		{"$a = new readonly class($b) implements C {\n};", "$a = new readonly class($b) implements C {\n};"},
+		{"$a = new readonly class($b) implements C\n{\n};", "$a = new readonly class($b) implements C {\n};"},
+		{"$a = new readonly class($b) extends D implements C {\n};", "$a = new readonly class($b) extends D implements C {\n};"},
+		{"$a = new READONLY class {\n};", "$a = new READONLY class {\n};"},
+		{"$a = new #[Foo] class {\n};", "$a = new #[Foo] class {\n};"},
+		{"$a = new #[Foo] readonly class {\n};", "$a = new #[Foo] readonly class {\n};"},
+		{"$a = new #[Foo] readonly class\n{\n};", "$a = new #[Foo] readonly class {\n};"},
+		{"$a = new /* c */ readonly class {\n};", "$a = new /* c */ readonly class {\n};"},
+		{"$a = new readonly /* c */ class {\n};", "$a = new readonly /* c */ class {\n};"},
+		{"$a = new\n    readonly class {\n};", "$a = new\n    readonly class {\n};"},
+		{"$a = new readonly\n    class {\n};", "$a = new readonly\n    class {\n};"},
+		{"foo(new readonly class {\n});", "foo(new readonly class {\n});"},
+		{"foo(new readonly class($b) implements C {\n}, 1);", "foo(new readonly class($b) implements C {\n}, 1);"},
+		{"return new readonly class {\n};", "return new readonly class {\n};"},
+		{"readonly class A {\n}", "readonly class A\n{\n}"},
+		{"readonly class A\n{\n}", "readonly class A\n{\n}"},
+		{"final readonly class A {\n}", "final readonly class A\n{\n}"},
+		{"readonly final class A {\n}", "readonly final class A\n{\n}"},
+		{"abstract readonly class A {\n}", "abstract readonly class A\n{\n}"},
+		{"#[Foo] readonly class A {\n}", "#[Foo] readonly class A\n{\n}"},
+		{"$a = new readonly class // c\n{\n    public $x;\n};", "$a = new readonly class { // c\npublic $x;\n};"},
+		{"$a = new readonly class # c\n{\n    public $x;\n};", "$a = new readonly class { # c\npublic $x;\n};"},
+		{"$a = new readonly class($b) implements C // c\n{\n    public $x;\n};", "$a = new readonly class($b) implements C { // c\npublic $x;\n};"},
+		{"$a = new readonly class\n// c\n{\n    public $x;\n};", "$a = new readonly class {\n// c\npublic $x;\n};"},
+		{"$a = new readonly class /* c */ {\n    public $x;\n};", "$a = new readonly class { /* c */\n    public $x;\n};"},
+	}
+	for _, c := range cases {
+		got, changed := apply(t, BracesPosition{}, "<?php\n"+c.src+"\n")
+		if want := "<?php\n" + c.want + "\n"; got != want || changed != (c.src != c.want) {
+			t.Errorf("%s\n got=%q changed=%v\nwant=%q", c.src, got, changed, want)
+		}
+	}
+}
diff --git a/blink/internal/fixer/rules/method_argument_space.go b/blink/internal/fixer/rules/method_argument_space.go
index 8e5447e7fe..75d2486f69 100644
--- a/blink/internal/fixer/rules/method_argument_space.go
+++ b/blink/internal/fixer/rules/method_argument_space.go
@@ -665,7 +665,7 @@ func reflowAfterComma(s *tokens.Stream, comma int, base string, collapseBlanks b
 		// only method_argument_space normalizes the comma-to-comment gap to one
 		// space; the Symplify array/standalone-line reflows (collapseBlanks=false)
 		// keep the author's alignment, matching their PHP fixers
-		if collapseBlanks {
+		if collapseBlanks && !masCommentLastLine(s, n) {
 			if ws >= 0 {
 				if s.At(ws).Value != " " {
 					s.SetValue(ws, " ")
diff --git a/blink/internal/fixer/rules/method_argument_space_comment_gap_test.go b/blink/internal/fixer/rules/method_argument_space_comment_gap_test.go
new file mode 100644
index 0000000000..799a4873a8
--- /dev/null
+++ b/blink/internal/fixer/rules/method_argument_space_comment_gap_test.go
@@ -0,0 +1,25 @@
+package rules
+
+import "testing"
+
+// The expected output of every case comes from the PHP engine.
+func TestMethodArgumentSpaceCommentGap(t *testing.T) {
+	t.Parallel()
+	cases := []struct{ src, want string }{
+		{"function f(\n    string $a,      // first\n    ?int $b = null,   // second\n    bool $c = true,\n): void {\n}", "function f(\n    string $a,      // first\n    ?int $b = null,   // second\n    bool $c = true,\n): void {\n}"},
+		{"function f(\n    ?int $a = null,       /* third */\n    bool $b = true,\n): void {\n}", "function f(\n    ?int $a = null,       /* third */\n    bool $b = true,\n): void {\n}"},
+		{"foo(\n    $a,     // aligned\n    $bb,    // aligned\n    $ccc\n);", "foo(\n    $a,     // aligned\n    $bb,    // aligned\n    $ccc\n);"},
+		{"foo(\n    $a, // one space\n    $b\n);", "foo(\n    $a, // one space\n    $b\n);"},
+		{"foo(\n    $a,// no space\n    $b\n);", "foo(\n    $a,// no space\n    $b\n);"},
+		{"foo(\n    $a,   /* block */ $b\n);", "foo(\n    $a, /* block */\n    $b\n);"},
+		{"foo($a,   $b);", "foo($a, $b);"},
+		{"foo(\n    $a,   \n    $b\n);", "foo(\n    $a,\n    $b\n);"},
+		{"foo($a,   // c\n    $b);", "foo($a,   // c\n    $b);"},
+	}
+	for _, c := range cases {
+		got, changed := apply(t, MethodArgumentSpace{}, "<?php\n"+c.src+"\n")
+		if want := "<?php\n" + c.want + "\n"; got != want || changed != (c.src != c.want) {
+			t.Errorf("%s\n got=%q changed=%v\nwant=%q", c.src, got, changed, want)
+		}
+	}
+}
diff --git a/blink/internal/fixer/rules/priorities.go b/blink/internal/fixer/rules/priorities.go
index 298350119b..b68fe2f750 100644
--- a/blink/internal/fixer/rules/priorities.go
+++ b/blink/internal/fixer/rules/priorities.go
@@ -279,4 +279,5 @@ var fixerPriority = map[string]int{
 	"PhpdocSummaryFixer":                              0,
 	"PhpdocTagTypeFixer":                              0,
 	"PhpdocOrderFixer":                                -2,
+	"StandaloneLineRequiredParamFixer":                40,
 }
diff --git a/blink/internal/fixer/rules/standalone_line_required_param.go b/blink/internal/fixer/rules/standalone_line_required_param.go
index a6a47c276b..8f1b162fdb 100644
--- a/blink/internal/fixer/rules/standalone_line_required_param.go
+++ b/blink/internal/fixer/rules/standalone_line_required_param.go
@@ -15,10 +15,7 @@ import (
 // dependency is added or removed from an autowired setter.
 type StandaloneLineRequiredParam struct{}
 
-var (
-	requiredAnnotationRe = regexp.MustCompile(`(?i)@required\b`)
-	requiredAttributeRe  = regexp.MustCompile(`(?i)^#\[.*\bRequired\b`)
-)
+var requiredAnnotationRe = regexp.MustCompile(`(?i)@required\b`)
 
 func (StandaloneLineRequiredParam) Name() string {
 	return `Symplify\CodingStandard\Fixer\Spacing\StandaloneLineRequiredParamFixer`
@@ -66,7 +63,7 @@ func isPublicRequiredMethod(s *tokens.Stream, fnPos int) bool {
 		t := s.At(j)
 		if attributeEndsAt(s, j) {
 			start := s.AttributeStartOf(j)
-			if requiredAttributeRe.MatchString(attributeText(s, start, j)) {
+			if attributeMarksRequired(s, start, j) {
 				isRequired = true
 			}
 			j = start
@@ -95,3 +92,18 @@ func isPublicRequiredMethod(s *tokens.Stream, fnPos int) bool {
 	}
 	return isPublic && isRequired
 }
+
+// attributeMarksRequired looks for the exact name, in any position. "required: true"
+// and 'Required' do not count, or every attribute with such an option would match.
+func attributeMarksRequired(s *tokens.Stream, start, end int) bool {
+	for i := start; i <= end; i++ {
+		t := s.At(i)
+		if t.Kind == token.DocComment && requiredAnnotationRe.MatchString(t.Value) {
+			return true
+		}
+		if t.Kind == token.Ident && t.Value == "Required" && !taIsNamedArgument(s, i) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/blink/internal/fixer/rules/standalone_line_required_param_attribute_test.go b/blink/internal/fixer/rules/standalone_line_required_param_attribute_test.go
new file mode 100644
index 0000000000..f429544902
--- /dev/null
+++ b/blink/internal/fixer/rules/standalone_line_required_param_attribute_test.go
@@ -0,0 +1,72 @@
+package rules
+
+import "testing"
+
+// The expected output of every case comes from the PHP engine.
+func TestStandaloneLineRequiredParamAttribute(t *testing.T) {
+	t.Parallel()
+	cases := []struct{ src, want string }{
+		{"class A { #[Required] public function f(int $a) {} }", "class A { #[Required] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Required] public function f(int $a, int $b): void {} }", "class A { #[Required] public function f(\n    int $a,\n    int $b\n): void {} }"},
+		{"class A { #[\\Required] public function f(int $a) {} }", "class A { #[\\Required] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo\\Required] public function f(int $a) {} }", "class A { #[Foo\\Required] public function f(\n    int $a\n) {} }"},
+		{"class A { #[\\Foo\\Required] public function f(int $a) {} }", "class A { #[\\Foo\\Required] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Required\\Foo] public function f(int $a) {} }", "class A { #[Required\\Foo] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo\\Required\\Bar] public function f(int $a) {} }", "class A { #[Foo\\Required\\Bar] public function f(\n    int $a\n) {} }"},
+		{"class A { #[namespace\\Required] public function f(int $a) {} }", "class A { #[namespace\\Required] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Required()] public function f(int $a) {} }", "class A { #[Required()] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo, Required] public function f(int $a) {} }", "class A { #[Foo, Required] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo] #[Required] public function f(int $a) {} }", "class A { #[Foo] #[Required] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Required] #[Foo] public function f(int $a) {} }", "class A { #[Required] #[Foo] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo(Required: true)] public function f(int $a) {} }", "class A { #[Foo(Required: true)] public function f(int $a) {} }"},
+		{"class A { #[Foo(Required::X)] public function f(int $a) {} }", "class A { #[Foo(Required::X)] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo(x: Required::X)] public function f(int $a) {} }", "class A { #[Foo(x: Required::X)] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo(Required)] public function f(int $a) {} }", "class A { #[Foo(Required)] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo(new Required())] public function f(int $a) {} }", "class A { #[Foo(new Required())] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo(Bar::Required)] public function f(int $a) {} }", "class A { #[Foo(Bar::Required)] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo(required: true)] public function f(int $a) {} }", "class A { #[Foo(required: true)] public function f(int $a) {} }"},
+		{"class A { #[Foo(x: 1, required: true)] public function f(int $a) {} }", "class A { #[Foo(x: 1, required: true)] public function f(int $a) {} }"},
+		{"class A { #[required] public function f(int $a) {} }", "class A { #[required] public function f(int $a) {} }"},
+		{"class A { #[REQUIRED] public function f(int $a) {} }", "class A { #[REQUIRED] public function f(int $a) {} }"},
+		{"class A { #[Foo\\required] public function f(int $a) {} }", "class A { #[Foo\\required] public function f(int $a) {} }"},
+		{"class A { #[Foo('Required')] public function f(int $a) {} }", "class A { #[Foo('Required')] public function f(int $a) {} }"},
+		{"class A { #[Foo(\"Required\")] public function f(int $a) {} }", "class A { #[Foo(\"Required\")] public function f(int $a) {} }"},
+		{"class A { #[Foo('is Required here')] public function f(int $a) {} }", "class A { #[Foo('is Required here')] public function f(int $a) {} }"},
+		{"class A { #[Foo(description: 'Required value')] public function f(int $a) {} }", "class A { #[Foo(description: 'Required value')] public function f(int $a) {} }"},
+		{"class A { #[Foo /* Required */] public function f(int $a) {} }", "class A { #[Foo /* Required */] public function f(int $a) {} }"},
+		{"class A { #[NotRequired] public function f(int $a) {} }", "class A { #[NotRequired] public function f(int $a) {} }"},
+		{"class A { #[RequiredFoo] public function f(int $a) {} }", "class A { #[RequiredFoo] public function f(int $a) {} }"},
+		{"class A { #[Foo_Required] public function f(int $a) {} }", "class A { #[Foo_Required] public function f(int $a) {} }"},
+		{"class A { #[Required] protected function f(int $a) {} }", "class A { #[Required] protected function f(int $a) {} }"},
+		{"class A { #[Required] private function f(int $a) {} }", "class A { #[Required] private function f(int $a) {} }"},
+		{"class A { #[Required] function f(int $a) {} }", "class A { #[Required] function f(int $a) {} }"},
+		{"class A { #[Required] public function f() {} }", "class A { #[Required] public function f() {} }"},
+		{"class A { #[Required] public static function f(int $a) {} }", "class A { #[Required] public static function f(\n    int $a\n) {} }"},
+		{"class A { #[Required] final public function f(int $a) {} }", "class A { #[Required] final public function f(\n    int $a\n) {} }"},
+		{"abstract class A { #[Required] abstract public function f(int $a); }", "abstract class A { #[Required] abstract public function f(\n    int $a\n); }"},
+		{"class A { /** @required */ public function f(int $a) {} }", "class A { /** @required */ public function f(\n    int $a\n) {} }"},
+		{"class A { /** @Required */ public function f(int $a) {} }", "class A { /** @Required */ public function f(\n    int $a\n) {} }"},
+		{"class A { /** @required-foo */ public function f(int $a) {} }", "class A { /** @required-foo */ public function f(\n    int $a\n) {} }"},
+		{"class A { /** @requiredfoo */ public function f(int $a) {} }", "class A { /** @requiredfoo */ public function f(int $a) {} }"},
+		{"class A { /** Required */ public function f(int $a) {} }", "class A { /** Required */ public function f(int $a) {} }"},
+		{"class A { /* @required */ public function f(int $a) {} }", "class A { /* @required */ public function f(int $a) {} }"},
+		{"class A { /** @required */ protected function f(int $a) {} }", "class A { /** @required */ protected function f(int $a) {} }"},
+		{"class A { #[Foo(required: true)] /** @required */ public function f(int $a) {} }", "class A { #[Foo(required: true)] /** @required */ public function f(\n    int $a\n) {} }"},
+		{"class A { /** @required */ #[Foo(required: true)] public function f(int $a) {} }", "class A { /** @required */ #[Foo(required: true)] public function f(\n    int $a\n) {} }"},
+		{"#[Required] function f(int $a) {}", "#[Required] function f(int $a) {}"},
+		{"class A { public function g() {} #[Required] public function f(int $a) {} }", "class A { public function g() {} #[Required] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Required] public function g() {} public function f(int $a) {} }", "class A { #[Required] public function g() {} public function f(int $a) {} }"},
+		{"class A { #[Foo(/** @required */ x: 1)] public function f(int $a) {} }", "class A { #[Foo(/** @required */ x: 1)] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo(x: 1 /** @required */)] public function f(int $a) {} }", "class A { #[Foo(x: 1 /** @required */)] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo(/** Required */ x: 1)] public function f(int $a) {} }", "class A { #[Foo(/** Required */ x: 1)] public function f(int $a) {} }"},
+		{"class A {\n    #[\n        Foo,\n        Required,\n    ]\n    public function f(int $a) {}\n}", "class A {\n    #[\n        Foo,\n        Required,\n    ]\n    public function f(\n        int $a\n    ) {}\n}"},
+		{"class A { #[Foo(true ? Required : false)] public function f(int $a) {} }", "class A { #[Foo(true ? Required : false)] public function f(\n    int $a\n) {} }"},
+		{"class A { #[Foo(x: true ? Required : false)] public function f(int $a) {} }", "class A { #[Foo(x: true ? Required : false)] public function f(\n    int $a\n) {} }"},
+	}
+	for _, c := range cases {
+		got, changed := apply(t, StandaloneLineRequiredParam{}, "<?php\n"+c.src+"\n")
+		if want := "<?php\n" + c.want + "\n"; got != want || changed != (c.src != c.want) {
+			t.Errorf("%s\n got=%q changed=%v\nwant=%q", c.src, got, changed, want)
+		}
+	}
+}
diff --git a/blink/internal/fixer/rules/standalone_line_required_param_test.go b/blink/internal/fixer/rules/standalone_line_required_param_test.go
index 43ff205609..4a831a54e0 100644
--- a/blink/internal/fixer/rules/standalone_line_required_param_test.go
+++ b/blink/internal/fixer/rules/standalone_line_required_param_test.go
@@ -1,6 +1,10 @@
 package rules
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/ecsphp/ecs-src/blink/internal/fixer"
+)
 
 func TestStandaloneLineRequiredParam(t *testing.T) {
 	t.Parallel()
@@ -34,3 +38,18 @@ func TestStandaloneLineRequiredParam(t *testing.T) {
 		t.Fatal("method needs #[Required] or @required")
 	}
 }
+
+// The expected output comes from the PHP engine: LineLength joins what this rule broke.
+func TestStandaloneLineRequiredParamRunsBeforeLineLength(t *testing.T) {
+	t.Parallel()
+	src := "<?php\nclass A\n{\n    #[Required]\n    public function autowire(FormModel $a, SubModel $b): void\n    {\n    }\n}\n"
+	fixers := []fixer.Fixer{LineLength{}, StandaloneLineRequiredParam{}}
+	CanonicalOrder(fixers)
+	got := src
+	for _, f := range fixers {
+		got, _ = apply(t, f.(fixerRule), got)
+	}
+	if got != src {
+		t.Fatalf("got=%q", got)
+	}
+}
diff --git a/blink/internal/fixer/rules/statement_indentation.go b/blink/internal/fixer/rules/statement_indentation.go
index c57f99adcd..fe334202df 100644
--- a/blink/internal/fixer/rules/statement_indentation.go
+++ b/blink/internal/fixer/rules/statement_indentation.go
@@ -116,6 +116,8 @@ func (f StatementIndentation) Fix(s *tokens.Stream) bool {
 			switch {
 			case t.Kind == token.Keyword && stmtKwIn(t.Value, "extends", "implements"):
 				ei = stmtNextValue(s, index, "{")
+			case t.Kind == token.AttributeStart:
+				ei = s.AttributeEnd(index)
 			case t.Kind == token.Punct && t.Value == ":":
 				if _, ok := caseBlockStarts[index]; ok {
 					ei, eiInclusive = f.findCaseBlockEnd(s, index)
@@ -342,7 +344,7 @@ func (f StatementIndentation) Fix(s *tokens.Stream) bool {
 
 		if stmtIsComment(s, index) ||
 			(t.Kind == token.Punct && (t.Value == ";" || t.Value == "," || t.Value == "}")) ||
-			t.Kind == token.OpenTag || t.Kind == token.CloseTag {
+			t.Kind == token.OpenTag || t.Kind == token.CloseTag || t.Kind == token.AttributeEnd {
 			continue
 		}
 
@@ -427,6 +429,9 @@ func stmtIsDynamicMemberBrace(s *tokens.Stream, index int) bool {
 // stepped every token before index.
 func stmtIsBlockFirst(s *tokens.Stream, tr *arrayNotationTracker, index int) bool {
 	t := s.At(index)
+	if t.Kind == token.AttributeStart {
+		return true
+	}
 	if t.Kind != token.Punct {
 		return false
 	}
diff --git a/blink/internal/fixer/rules/statement_indentation_attribute_list_test.go b/blink/internal/fixer/rules/statement_indentation_attribute_list_test.go
new file mode 100644
index 0000000000..515a9a7f96
--- /dev/null
+++ b/blink/internal/fixer/rules/statement_indentation_attribute_list_test.go
@@ -0,0 +1,29 @@
+package rules
+
+import "testing"
+
+// The expected output of every case comes from the PHP engine.
+func TestStatementIndentationAttributeList(t *testing.T) {
+	t.Parallel()
+	cases := []struct{ src, want string }{
+		{"class A {\n    #[\n        Foo,\n        Bar(max: 3)\n    ]\n    public string $a;\n}", "class A {\n    #[\n        Foo,\n        Bar(max: 3)\n    ]\n    public string $a;\n}"},
+		{"class A {\n    #[\n        Foo,\n        Bar(max: 3),\n    ]\n    public string $a;\n}", "class A {\n    #[\n        Foo,\n        Bar(max: 3),\n    ]\n    public string $a;\n}"},
+		{"class A {\n    #[\n    Foo,\n    Bar\n    ]\n    public string $a;\n}", "class A {\n    #[\n        Foo,\n        Bar\n    ]\n    public string $a;\n}"},
+		{"class A {\n    #[\n            Foo,\n            Bar\n    ]\n    public function f() {}\n}", "class A {\n    #[\n        Foo,\n        Bar\n    ]\n    public function f() {}\n}"},
+		{"class A {\n    public function __construct(\n        #[Baz]\n        #[\n            Foo,\n            Bar(mode: Bar::MODE),\n        ]\n        public string $a\n    ) {\n    }\n}", "class A {\n    public function __construct(\n        #[Baz]\n        #[\n            Foo,\n            Bar(mode: Bar::MODE),\n        ]\n        public string $a\n    ) {\n    }\n}"},
+		{"class A {\n    #[\n        Foo(\n            x: 1,\n        ),\n        Bar\n    ]\n    public string $a;\n}", "class A {\n    #[\n        Foo(\n            x: 1,\n        ),\n        Bar\n    ]\n    public string $a;\n}"},
+		{"#[\n    Foo,\n    Bar\n]\nfinal class A {\n}", "#[\n    Foo,\n    Bar\n]\nfinal class A {\n}"},
+		{"#[\n    Foo,\n    Bar\n]\nfunction f() {\n}", "#[\n    Foo,\n    Bar\n]\nfunction f() {\n}"},
+		{"class A {\n    #[Foo, Bar]\n    public string $a;\n}", "class A {\n    #[Foo, Bar]\n    public string $a;\n}"},
+		{"class A {\n    #[Foo(\n        x: 1\n    )]\n    public string $a;\n}", "class A {\n    #[Foo(\n        x: 1\n    )]\n    public string $a;\n}"},
+		{"class A {\n    #[\n        Foo\n]\n    public function f() {\n        return 1;\n    }\n}", "class A {\n    #[\n        Foo\n    ]\n    public function f() {\n        return 1;\n    }\n}"},
+		{"function f(#[\n    Foo\n] $a) {\n}", "function f(#[\n    Foo\n] $a) {\n}"},
+		{"class A {\n    public function __construct(\n        #[\n            Bar\n        ] private int $b\n    ) {\n    }\n}", "class A {\n    public function __construct(\n        #[\n            Bar\n        ] private int $b\n    ) {\n    }\n}"},
+	}
+	for _, c := range cases {
+		got, changed := apply(t, StatementIndentation{}, "<?php\n"+c.src+"\n")
+		if want := "<?php\n" + c.want + "\n"; got != want || changed != (c.src != c.want) {
+			t.Errorf("%s\n got=%q changed=%v\nwant=%q", c.src, got, changed, want)
+		}
+	}
+}
diff --git a/blink/internal/fixer/rules/trailing_comma.go b/blink/internal/fixer/rules/trailing_comma.go
index 9eb0d3c5f6..6b7634e5cb 100644
--- a/blink/internal/fixer/rules/trailing_comma.go
+++ b/blink/internal/fixer/rules/trailing_comma.go
@@ -100,10 +100,29 @@ func (f TrailingCommaInMultiline) WithConfig(config map[string]any) fixer.Fixer
 	return f
 }
 
+// trailingCommaIsPlainDestructuring reports "[...] =", "as [...]" and "as $k => [...]".
+// A nested target is not checked, so it gets a comma: only these forms are certain.
+func trailingCommaIsPlainDestructuring(s *tokens.Stream, open, closeIdx int) bool {
+	prev := sigPrev(s, open)
+	if prev >= 0 && arrayNotationIsAs(s.At(prev)) {
+		return true
+	}
+	if prev >= 0 && isPunctVal(s, prev, "=>") {
+		key := sigPrev(s, prev)
+		if key < 0 || s.At(key).Kind != token.Variable {
+			return false
+		}
+		before := sigPrev(s, key)
+		return before >= 0 && arrayNotationIsAs(s.At(before))
+	}
+	next := sigNext(s, closeIdx)
+	return next >= 0 && isPunctVal(s, next, "=")
+}
+
 func (f TrailingCommaInMultiline) included(s *tokens.Stream, sc *arrayNotationScan, open, closeIdx int) bool {
 	closer := s.At(closeIdx).Value
 	if f.Elements == nil {
-		return closer == "]" && !isOffsetOpen(s, open)
+		return closer == "]" && !isOffsetOpen(s, open) && !trailingCommaIsPlainDestructuring(s, open, closeIdx)
 	}
 	switch trailingCommaCategory(s, sc, open) {
 	case "arrays":
diff --git a/blink/internal/fixer/rules/trailing_comma_destructuring_test.go b/blink/internal/fixer/rules/trailing_comma_destructuring_test.go
new file mode 100644
index 0000000000..74fc74287d
--- /dev/null
+++ b/blink/internal/fixer/rules/trailing_comma_destructuring_test.go
@@ -0,0 +1,38 @@
+package rules
+
+import "testing"
+
+// The expected output of every case comes from the PHP engine.
+func TestTrailingCommaDestructuring(t *testing.T) {
+	t.Parallel()
+	cases := []struct{ src, want string }{
+		{"[\n    $a,\n    $b\n] = foo();", "[\n    $a,\n    $b\n] = foo();"},
+		{"[\n    $a,\n    $b,\n] = foo();", "[\n    $a,\n    $b,\n] = foo();"},
+		{"['x' => $a, 'y' => $b] = foo();", "['x' => $a, 'y' => $b] = foo();"},
+		{"[\n    'x' => $a,\n    'y' => $b\n] = foo();", "[\n    'x' => $a,\n    'y' => $b\n] = foo();"},
+		{"list(\n    $a,\n    $b\n) = foo();", "list(\n    $a,\n    $b\n) = foo();"},
+		{"foreach ($g as [\n    $a,\n    $b\n]) {\n}", "foreach ($g as [\n    $a,\n    $b\n]) {\n}"},
+		{"[\n    [$a, $b],\n    $c\n] = foo();", "[\n    [$a, $b],\n    $c\n] = foo();"},
+		{"$x = [\n    1,\n    2\n];", "$x = [\n    1,\n    2,\n];"},
+		{"foo([\n    1,\n    2\n]);", "foo([\n    1,\n    2,\n]);"},
+		{"$a[\n    0\n] = 1;", "$a[\n    0\n] = 1;"},
+		{"foo(\n    1,\n    2\n);", "foo(\n    1,\n    2\n);"},
+		{"[\n    'k' => [\n        $a,\n        $b\n    ],\n    'l' => $c\n] = foo();", "[\n    'k' => [\n        $a,\n        $b,\n    ],\n    'l' => $c\n] = foo();"},
+		{"foreach ($g as ['a' => [\n    $b,\n    $c\n]]) {\n}", "foreach ($g as ['a' => [\n    $b,\n    $c,\n]]) {\n}"},
+		{"$f = fn ($x) => [\n    $a,\n    $b\n] = $x;", "$f = fn ($x) => [\n    $a,\n    $b,\n] = $x;"},
+		{"foreach ($g as $k => [\n    $a,\n    $b\n]) {\n}", "foreach ($g as $k => [\n    $a,\n    $b\n]) {\n}"},
+		{"$x = ['k' => [\n    1,\n    2\n]];", "$x = ['k' => [\n    1,\n    2,\n]];"},
+		{"['k' => [[\n    $a\n]]] = foo();", "['k' => [[\n    $a,\n]]] = foo();"},
+		{"$f = fn ($x) => [\n    $a,\n    [\n        $b\n    ],\n] = $x;", "$f = fn ($x) => [\n    $a,\n    [\n        $b,\n    ],\n] = $x;"},
+		{"foreach ($g as $this->k => [\n    $a\n]) {\n}", "foreach ($g as $this->k => [\n    $a,\n]) {\n}"},
+		{"foreach ($g as $m['x'] => [\n    $a\n]) {\n}", "foreach ($g as $m['x'] => [\n    $a,\n]) {\n}"},
+		{"[$x . [\n    1\n][0] => $a] = foo();", "[$x . [\n    1,\n][0] => $a] = foo();"},
+		{"$x = ['k' => [[\n    $a\n]] = foo()];", "$x = ['k' => [[\n    $a,\n]] = foo()];"},
+	}
+	for _, c := range cases {
+		got, changed := apply(t, TrailingCommaInMultiline{}, "<?php\n"+c.src+"\n")
+		if want := "<?php\n" + c.want + "\n"; got != want || changed != (c.src != c.want) {
+			t.Errorf("%s\n got=%q changed=%v\nwant=%q", c.src, got, changed, want)
+		}
+	}
+}
diff --git a/blink/internal/lexer/lexer.go b/blink/internal/lexer/lexer.go
index aee0a9ae69..7ba4bbbb52 100644
--- a/blink/internal/lexer/lexer.go
+++ b/blink/internal/lexer/lexer.go
@@ -429,7 +429,7 @@ func (l *lexer) skipTrivia(p int) int {
 			}
 			p += 2 + end + 2
 		case strings.HasPrefix(src[p:], "//") || (src[p] == '#' && !strings.HasPrefix(src[p:], "#[")):
-			for p < len(src) && src[p] != '\n' && !strings.HasPrefix(src[p:], "?>") {
+			for p < len(src) && src[p] != '\n' && src[p] != '\r' && !strings.HasPrefix(src[p:], "?>") {
 				p++
 			}
 		default:
@@ -486,7 +486,7 @@ func (l *lexer) matchOperator() int {
 }
 
 func (l *lexer) lexLineComment(start int) {
-	for l.pos < len(l.src) && l.src[l.pos] != '\n' {
+	for l.pos < len(l.src) && l.src[l.pos] != '\n' && l.src[l.pos] != '\r' {
 		// a ?> ends a line comment in PHP; stop before it
 		if l.hasPrefix("?>") {
 			break
diff --git a/blink/internal/lexer/line_comment_test.go b/blink/internal/lexer/line_comment_test.go
new file mode 100644
index 0000000000..ca070c086a
--- /dev/null
+++ b/blink/internal/lexer/line_comment_test.go
@@ -0,0 +1,43 @@
+package lexer
+
+import (
+	"testing"
+
+	"github.com/ecsphp/ecs-src/blink/internal/token"
+)
+
+// The expected comments come from PHP's token_get_all.
+func TestLineCommentEnds(t *testing.T) {
+	cases := []struct{ src, comment string }{
+		{"<?php // c\n$a;", "// c"},
+		{"<?php // c\r\n$a;", "// c"},
+		{"<?php // c\r$a;", "// c"},
+		{"<?php # c  \r\n", "# c  "},
+		{"<?php // c ?>", "// c "},
+	}
+	for _, c := range cases {
+		found := false
+		for _, tk := range Lex(c.src) {
+			if tk.Kind == token.Comment {
+				found = true
+				if tk.Value != c.comment {
+					t.Errorf("%q comment=%q want %q", c.src, tk.Value, c.comment)
+				}
+			}
+		}
+		if !found {
+			t.Errorf("%q has no comment", c.src)
+		}
+	}
+}
+
+// PHP's token_get_all gives one T_YIELD_FROM here, comment included.
+func TestYieldFromAcrossCommentEndingAtCarriageReturn(t *testing.T) {
+	src := "<?php yield // c\r    from [];"
+	for _, tk := range Lex(src) {
+		if tk.Value == "yield // c\r    from" {
+			return
+		}
+	}
+	t.Errorf("no single yield from token in %q", src)
+}