diff --git a/.github/workflows/blink_parity.yaml b/.github/workflows/blink_parity.yaml
new file mode 100644
index 0000000000..4d6e10a3bd
--- /dev/null
+++ b/.github/workflows/blink_parity.yaml
@@ -0,0 +1,162 @@
+name: Blink Parity
+
+# Runs blink and the ECS in this repository on the same real codebase (full
+# rector-src) and fails if blink's output differs from ECS (psr12 + common) on
+# any file. This is the 1:1 parity gate - it stays red until blink reproduces
+# ECS exactly.
+
+on:
+ pull_request:
+ paths:
+ - 'blink/**'
+ - 'src/**'
+ - 'packages/**'
+ - 'config/**'
+ - '.github/workflows/blink_parity.yaml'
+ workflow_dispatch: null
+
+jobs:
+ blink-parity:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+
+ - uses: actions/setup-go@v5
+ with:
+ go-version: "1.26.6"
+
+ - name: Build blink
+ working-directory: blink
+ run: go build -o /tmp/blink .
+
+ - uses: shivammathur/setup-php@v2
+ with:
+ php-version: "8.4"
+ coverage: none
+
+ # installs this repository's ECS so parity runs against the code being shipped
+ - uses: "ramsey/composer-install@v4"
+
+ - name: Fetch a real codebase sample
+ run: |
+ git clone --depth 1 https://github.com/rectorphp/rector-src.git /tmp/rector
+ # full rector-src tree; .php.inc fixtures are skipped by the *.php find below
+ mkdir -p /tmp/sample
+ cp -r /tmp/rector/src /tmp/rector/rules /tmp/rector/tests /tmp/sample/
+ cp -r /tmp/sample /tmp/ours
+ cp -r /tmp/sample /tmp/ecs
+
+ - name: Run blink
+ run: /tmp/blink --fix /tmp/ours || true
+
+ - name: Build the local ECS config
+ run: |
+ cat > /tmp/ecs.php <<'PHP'
+ withPreparedSets(psr12: true, common: true);
+ PHP
+
+ - name: Run the local ECS
+ run: bin/ecs check /tmp/ecs --fix --no-progress-bar --config /tmp/ecs.php || true
+
+ - name: Rank missing fixers (data-driven backlog)
+ run: |
+ # what ECS would apply on the pristine sample, as JSON
+ bin/ecs check /tmp/sample --output-format=json --config /tmp/ecs.php > /tmp/ecs.json 2>/dev/null || true
+ # fixers we already implement
+ /tmp/blink list-checkers | sed 's/^[[:space:]]*-[[:space:]]*//; /Registered/d' | sort -u > /tmp/impl.txt
+ # count applied checkers across files, most frequent first
+ jq -r '[.files[]?.diffs[]?.applied_checkers[]?] | group_by(.) | map("\(length) \(.[0])") | .[]' /tmp/ecs.json 2>/dev/null | sort -rn > /tmp/counts.txt || true
+ {
+ echo "## Backlog: ECS fixers not yet in blink, ranked by frequency on the sample"
+ echo ""
+ echo "| fixer | files |"
+ echo "|---|---|"
+ } >> "$GITHUB_STEP_SUMMARY"
+ n=0
+ while read -r count chk; do
+ [ "$n" -ge 25 ] && break
+ if ! grep -qxF "$chk" /tmp/impl.txt; then
+ echo "| \`$chk\` | $count |" >> "$GITHUB_STEP_SUMMARY"
+ n=$((n + 1))
+ fi
+ done < /tmp/counts.txt
+ if [ "$n" -eq 0 ]; then
+ echo "| (no data - check the ECS JSON shape) | |" >> "$GITHUB_STEP_SUMMARY"
+ fi
+ # stdout diagnostics (the summary table is not fetchable via CLI)
+ echo "=== implemented: $(wc -l < /tmp/impl.txt) | ecs.json bytes: $(wc -c < /tmp/ecs.json) ==="
+ echo "=== top applied checkers, raw (before excluding implemented) ==="
+ head -20 /tmp/counts.txt || true
+
+ - name: Compare outputs
+ run: |
+ total=0
+ differ=0
+ for f in $(cd /tmp/ours && find . -name '*.php'); do
+ total=$((total + 1))
+ if ! diff -q "/tmp/ours/$f" "/tmp/ecs/$f" >/dev/null 2>&1; then
+ differ=$((differ + 1))
+ fi
+ done
+ same=$((total - differ))
+ {
+ echo "## blink vs ECS (psr12 + common) on full rector-src"
+ echo ""
+ echo "| metric | value |"
+ echo "|---|---|"
+ echo "| files | $total |"
+ echo "| identical output | $same |"
+ echo "| differing output | $differ |"
+ echo ""
+ echo "This is the 1:1 parity gate: it fails while any file differs from ECS."
+ } >> "$GITHUB_STEP_SUMMARY"
+ echo "identical=$same differing=$differ of $total"
+
+ # Per differing file: which rules ECS applied vs blink, and the
+ # snippet they differ on. ECS applied checkers come from the JSON
+ # captured on the pristine sample; blink's from a dry-run check.
+ echo "### Divergences ($differ files): applied rules + diff" >> "$GITHUB_STEP_SUMMARY"
+ echo ""
+ echo "=== Divergences ($differ files) ==="
+ export LC_ALL=C
+ for f in $(cd /tmp/ours && find . -name '*.php' | sort); do
+ diff -q "/tmp/ours/$f" "/tmp/ecs/$f" >/dev/null 2>&1 && continue
+ rel=${f#./}
+ abs="/tmp/sample/$rel"
+ ecs_rules=$(jq -r --arg k "$abs" '.files[$k].diffs[]?.applied_checkers[]?' /tmp/ecs.json 2>/dev/null | sed -E 's#.*\\##' | sort -u)
+ go_rules=$(/tmp/blink "$abs" 2>/dev/null | sed -n 's/^[[:space:]]*\*[[:space:]]//p' | sed -E 's#.*\\##' | sort -u)
+ ecs_only=$(comm -23 <(printf '%s\n' "$ecs_rules") <(printf '%s\n' "$go_rules") | grep -v '^$' | paste -sd, - || true)
+ go_only=$(comm -13 <(printf '%s\n' "$ecs_rules") <(printf '%s\n' "$go_rules") | grep -v '^$' | paste -sd, - || true)
+ # stdout (CI log): file + which rules differ + the diff
+ echo ""
+ echo "--- $rel"
+ echo " ECS applied, blink did not: ${ecs_only:-(none)}"
+ echo " blink applied, ECS did not: ${go_only:-(none)}"
+ diff "/tmp/ours/$f" "/tmp/ecs/$f" | sed 's/^/ /' | head -40 || true
+ # job summary (rich, collapsible)
+ {
+ echo ""
+ echo "$rel
"
+ echo ""
+ echo "- **ECS applied, blink did not:** ${ecs_only:-(none)}"
+ echo "- **blink applied, ECS did not:** ${go_only:-(none)}"
+ echo ""
+ echo '```diff'
+ diff "/tmp/ours/$f" "/tmp/ecs/$f" | head -40 || true
+ echo '```'
+ echo "after
",
+ " more",
+ }
+ for _, src := range cases {
+ var got strings.Builder
+ for _, tk := range Lex(src) {
+ got.WriteString(tk.Value)
+ }
+ if got.String() != src {
+ t.Errorf("not lossless\n src: %q\n got: %q", src, got.String())
+ }
+ }
+}
+
+func TestLexClassifies(t *testing.T) {
+ toks := Lex(" 3 && tk.Value[:3] == "<<<" {
+ heredoc = tk.Value
+ }
+ }
+ if heredoc == "" {
+ t.Errorf("heredoc not captured as a single String token in %q", src)
+ }
+ // lossless
+ var got strings.Builder
+ for _, tk := range Lex(src) {
+ got.WriteString(tk.Value)
+ }
+ if got.String() != src {
+ t.Errorf("not lossless\n src: %q\n got: %q", src, got.String())
+ }
+ }
+}
+
+func TestLexMultilineAttributeWithNowdoc(t *testing.T) {
+ src := " 2 && tk.Value[:2] == "#[" {
+ attr = tk.Value
+ }
+ }
+ if attr == "" {
+ t.Fatal("multiline attribute not captured as one token")
+ }
+ if !strings.Contains(attr, "prose e.g. with. dots") {
+ t.Errorf("nowdoc body not inside the attribute token: %q", attr)
+ }
+ // lossless
+ var got strings.Builder
+ for _, tk := range Lex(src) {
+ got.WriteString(tk.Value)
+ }
+ if got.String() != src {
+ t.Errorf("not lossless:\n src: %q\n got: %q", src, got.String())
+ }
+}
+
+func TestLexKeywordsVsIdent(t *testing.T) {
+ toks := Lex("list;")
+ for _, tk := range toks {
+ if tk.Value == "list" && tk.Kind != token.Ident {
+ t.Errorf("property `list` after -> should be Ident, got %s", tk.Kind)
+ }
+ }
+}
+
+func TestLexMultiCharOperators(t *testing.T) {
+ cases := map[string]string{
+ "$b;": "=>",
+ "b;": "->",
+ " $b;": "<=>",
+ "= p.width:
+ bar = strings.Repeat("=", p.width)
+ case filled == 0:
+ bar = ">" + strings.Repeat(" ", p.width-1)
+ default:
+ bar = strings.Repeat("=", filled-1) + ">" + strings.Repeat(" ", p.width-filled)
+ }
+ _, _ = fmt.Fprintf(p.w, "\r %d/%d [%s] %3d%%", p.cur, p.total, bar, pct)
+}
diff --git a/blink/internal/reporter/reporter.go b/blink/internal/reporter/reporter.go
new file mode 100644
index 0000000000..35d7753625
--- /dev/null
+++ b/blink/internal/reporter/reporter.go
@@ -0,0 +1,196 @@
+// Package reporter reproduces ECS's console output: numbered file-diff blocks
+// with "Applied checkers" listings, wrapped diffs, and Symfony-style
+// success/warning status blocks.
+package reporter
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+
+ "blink/internal/runner"
+)
+
+type formatter struct {
+ w io.Writer
+ width int
+ color bool
+}
+
+// Report writes results to w and returns the process exit code (0 when clean or
+// after a successful fix, 1 when a check finds fixable issues).
+func Report(w io.Writer, results []runner.FileResult, isFixer bool) int {
+ f := newFormatter(w)
+
+ // --fix applies changes and prints a summary; the per-file diff listing is a
+ // check (dry-run) concern, matching ECS.
+ if !isFixer {
+ f.reportFileDiffs(results)
+ }
+ f.newLine(1)
+
+ if len(results) == 0 {
+ f.success("No errors found. Great job - your code is shiny in style!")
+ return 0
+ }
+
+ f.newLine(1)
+
+ n := len(results)
+ if isFixer {
+ f.success(fmt.Sprintf(
+ "%d error%s successfully fixed and no other errors found!",
+ n, plural(n),
+ ))
+ return 0
+ }
+
+ verb := "errors are"
+ if n == 1 {
+ verb = "error is"
+ }
+ f.warning(fmt.Sprintf(
+ "%d %s fixable! Just add \"--fix\" to console command and rerun to apply.",
+ n, verb,
+ ))
+ return 1
+}
+
+// Footer prints an ECS-style run summary: files scanned, time and memory.
+func Footer(w io.Writer, files int, d time.Duration, memBytes uint64) {
+ _, _ = fmt.Fprintf(w, "\n // %d files · %s · %d MB\n", files, d.Truncate(time.Millisecond), memBytes/(1024*1024))
+}
+
+func newFormatter(w io.Writer) formatter {
+ width := 80
+ color := false
+ if file, ok := w.(*os.File); ok {
+ if ws, ok2 := winsize(file); ok2 {
+ color = true
+ if ws > 0 {
+ width = ws
+ }
+ }
+ }
+ if c := os.Getenv("COLUMNS"); c != "" {
+ if n, err := strconv.Atoi(c); err == nil && n > 0 {
+ width = n
+ }
+ }
+ return formatter{w: w, width: width, color: color}
+}
+
+func (f formatter) reportFileDiffs(results []runner.FileResult) {
+ if len(results) == 0 {
+ return
+ }
+ f.newLine(1)
+
+ for i, r := range results {
+ f.newLine(2)
+ f.writeln(f.bold(fmt.Sprintf("%d) %s", i+1, r.Path)))
+ f.newLine(1)
+ f.writeln(f.formatDiff(r.Diff))
+ f.newLine(1)
+ f.writeln(f.underscore("Applied checkers:"))
+ f.newLine(1)
+ f.listing(r.AppliedRules)
+ }
+}
+
+// formatDiff wraps a unified diff in the begin/end frame and colors +, - and @
+// lines, matching ECS's ColorConsoleDiffFormatter.
+func (f formatter) formatDiff(diff string) string {
+ var colored []string
+ for line := range strings.SplitSeq(strings.TrimRight(diff, "\n"), "\n") {
+ switch {
+ case line == "--- Original", line == "+++ New":
+ continue
+ case strings.HasPrefix(line, "+"):
+ line = f.fg(line, 32) // green
+ case strings.HasPrefix(line, "-"):
+ line = f.fg(line, 31) // red
+ case strings.HasPrefix(line, "@"):
+ line = f.fg(line, 36) // cyan
+ case line == " ":
+ line = ""
+ }
+ colored = append(colored, line)
+ }
+
+ begin := f.comment(" ---------- begin diff ----------")
+ end := f.comment(" ----------- end diff -----------")
+ return begin + "\n" + strings.Join(colored, "\n") + "\n" + end + "\n"
+}
+
+func (f formatter) listing(items []string) {
+ for _, it := range items {
+ f.writeln(" * " + it)
+ }
+ f.newLine(1)
+}
+
+// success / warning render Symfony-style padded, colored blocks.
+func (f formatter) success(msg string) { f.block("[OK]", msg, 30, 42) }
+func (f formatter) warning(msg string) { f.block("[WARNING]", msg, 30, 43) }
+
+func (f formatter) block(tag, msg string, fg, bg int) {
+ f.newLine(1)
+ pad := func(s string) string {
+ if len([]rune(s)) < f.width {
+ s += strings.Repeat(" ", f.width-len([]rune(s)))
+ }
+ return f.bg(s, fg, bg)
+ }
+ f.writeln(pad(""))
+ f.writeln(pad(" " + tag + " " + msg))
+ f.writeln(pad(""))
+ f.newLine(1)
+}
+
+func (f formatter) newLine(n int) {
+ for range n {
+ _, _ = io.WriteString(f.w, "\n")
+ }
+}
+
+func (f formatter) writeln(s string) { _, _ = fmt.Fprintln(f.w, s) }
+
+// ANSI helpers, no-ops when color is disabled.
+func (f formatter) fg(s string, code int) string {
+ if !f.color {
+ return s
+ }
+ return fmt.Sprintf("\x1b[%dm%s\x1b[39m", code, s)
+}
+
+func (f formatter) bg(s string, fg, bg int) string {
+ if !f.color {
+ return s
+ }
+ return fmt.Sprintf("\x1b[%d;%dm%s\x1b[39;49m", fg, bg, s)
+}
+
+func (f formatter) comment(s string) string { return f.fg(s, 33) } // yellow
+func (f formatter) bold(s string) string {
+ if !f.color {
+ return s
+ }
+ return "\x1b[1m" + s + "\x1b[22m"
+}
+func (f formatter) underscore(s string) string {
+ if !f.color {
+ return s
+ }
+ return "\x1b[4m" + s + "\x1b[24m"
+}
+
+func plural(n int) string {
+ if n == 1 {
+ return ""
+ }
+ return "s"
+}
diff --git a/blink/internal/reporter/reporter_test.go b/blink/internal/reporter/reporter_test.go
new file mode 100644
index 0000000000..085370469c
--- /dev/null
+++ b/blink/internal/reporter/reporter_test.go
@@ -0,0 +1,57 @@
+package reporter
+
+import (
+ "bytes"
+ "strings"
+ "testing"
+
+ "blink/internal/runner"
+)
+
+func TestReportClean(t *testing.T) {
+ var buf bytes.Buffer
+ code := Report(&buf, nil, false)
+ if code != 0 {
+ t.Fatalf("clean exit code = %d, want 0", code)
+ }
+ if !strings.Contains(buf.String(), "No errors found. Great job - your code is shiny in style!") {
+ t.Fatalf("missing success message:\n%s", buf.String())
+ }
+}
+
+func TestReportCheckFixable(t *testing.T) {
+ var buf bytes.Buffer
+ results := []runner.FileResult{{
+ Path: "src/Foo.php",
+ AppliedRules: []string{`PhpCsFixer\Fixer\Semicolon\SpaceAfterSemicolonFixer`},
+ Diff: "--- Original\n+++ New\n@@ @@\n-$a=1;$b=2;\n+$a=1; $b=2;\n",
+ }}
+ code := Report(&buf, results, false)
+ out := buf.String()
+ if code != 1 {
+ t.Fatalf("check exit code = %d, want 1", code)
+ }
+ for _, want := range []string{
+ "1) src/Foo.php",
+ "begin diff",
+ "Applied checkers:",
+ `PhpCsFixer\Fixer\Semicolon\SpaceAfterSemicolonFixer`,
+ "1 error is fixable!",
+ } {
+ if !strings.Contains(out, want) {
+ t.Fatalf("output missing %q:\n%s", want, out)
+ }
+ }
+}
+
+func TestReportFixed(t *testing.T) {
+ var buf bytes.Buffer
+ results := []runner.FileResult{{Path: "a.php", AppliedRules: []string{"X"}}, {Path: "b.php", AppliedRules: []string{"Y"}}}
+ code := Report(&buf, results, true)
+ if code != 0 {
+ t.Fatalf("fix exit code = %d, want 0", code)
+ }
+ if !strings.Contains(buf.String(), "2 errors successfully fixed and no other errors found!") {
+ t.Fatalf("missing fixed message:\n%s", buf.String())
+ }
+}
diff --git a/blink/internal/reporter/winsize_unix.go b/blink/internal/reporter/winsize_unix.go
new file mode 100644
index 0000000000..22b83e3549
--- /dev/null
+++ b/blink/internal/reporter/winsize_unix.go
@@ -0,0 +1,25 @@
+//go:build !windows
+
+package reporter
+
+import (
+ "os"
+ "syscall"
+ "unsafe"
+)
+
+const tiocgwinsz = 0x5413 // linux TIOCGWINSZ
+
+func winsize(file *os.File) (int, bool) {
+ ws := struct{ Row, Col, X, Y uint16 }{}
+ _, _, errno := syscall.Syscall(
+ syscall.SYS_IOCTL,
+ file.Fd(),
+ uintptr(tiocgwinsz),
+ uintptr(unsafe.Pointer(&ws)),
+ )
+ if errno != 0 {
+ return 0, false
+ }
+ return int(ws.Col), true
+}
diff --git a/blink/internal/reporter/winsize_windows.go b/blink/internal/reporter/winsize_windows.go
new file mode 100644
index 0000000000..7f42f5eac7
--- /dev/null
+++ b/blink/internal/reporter/winsize_windows.go
@@ -0,0 +1,29 @@
+//go:build windows
+
+package reporter
+
+import (
+ "os"
+ "syscall"
+ "unsafe"
+)
+
+var procGetConsoleScreenBufferInfo = syscall.NewLazyDLL("kernel32.dll").NewProc("GetConsoleScreenBufferInfo")
+
+// consoleScreenBufferInfo mirrors the Win32 CONSOLE_SCREEN_BUFFER_INFO struct.
+type consoleScreenBufferInfo struct {
+ SizeX, SizeY int16
+ CursorX, CursorY int16
+ Attributes uint16
+ WindowLeft, WindowTop, WindowRight, WindowBottom int16
+ MaxWindowSizeX, MaxWindowSizeY int16
+}
+
+func winsize(file *os.File) (int, bool) {
+ var info consoleScreenBufferInfo
+ ok, _, _ := procGetConsoleScreenBufferInfo.Call(file.Fd(), uintptr(unsafe.Pointer(&info)))
+ if ok == 0 {
+ return 0, false
+ }
+ return int(info.WindowRight-info.WindowLeft) + 1, true
+}
diff --git a/blink/internal/runner/runner.go b/blink/internal/runner/runner.go
new file mode 100644
index 0000000000..939a68e16b
--- /dev/null
+++ b/blink/internal/runner/runner.go
@@ -0,0 +1,129 @@
+// Package runner ties finder, lexer, token stream and fixers together, echoing
+// ECS's application layer. Files are processed by a pool of parallel workers.
+package runner
+
+import (
+ "os"
+ "sort"
+ "sync"
+
+ "blink/internal/config"
+ "blink/internal/diff"
+ "blink/internal/finder"
+ "blink/internal/lexer"
+ "blink/internal/tokens"
+)
+
+// FileResult records the change made to one file.
+type FileResult struct {
+ Path string
+ AppliedRules []string // rules that changed this file, in application order
+ Diff string // unified diff (Original vs fixed)
+ After string // fixed content
+}
+
+func (r FileResult) Changed() bool { return len(r.AppliedRules) > 0 }
+
+// Run scans the config's paths and applies rules across Jobs workers. When
+// write is true, changed files are written back to disk. Results are returned
+// sorted by path so output is deterministic regardless of worker scheduling.
+// Progress receives per-file progress updates during a run.
+type Progress interface {
+ Start(total int)
+ Advance()
+}
+
+func Run(cfg *config.Config, write bool, prog Progress) ([]FileResult, error) {
+ files, err := finder.Find(cfg.Paths, cfg.Skip)
+ if err != nil {
+ return nil, err
+ }
+ if prog != nil {
+ prog.Start(len(files))
+ }
+
+ jobs := max(cfg.Jobs, 1)
+
+ paths := make(chan string)
+ results := make(chan FileResult)
+ var firstErr error
+ var errOnce sync.Once
+
+ var wg sync.WaitGroup
+ for range jobs {
+ wg.Go(func() {
+ for path := range paths {
+ res, err := fixFile(cfg, path, write)
+ if prog != nil {
+ prog.Advance()
+ }
+ if err != nil {
+ errOnce.Do(func() { firstErr = err })
+ continue
+ }
+ if res.Changed() {
+ results <- res
+ }
+ }
+ })
+ }
+
+ go func() {
+ for _, p := range files {
+ paths <- p
+ }
+ close(paths)
+ wg.Wait()
+ close(results)
+ }()
+
+ var collected []FileResult
+ for r := range results {
+ collected = append(collected, r)
+ }
+ if firstErr != nil {
+ return nil, firstErr
+ }
+
+ sort.Slice(collected, func(i, j int) bool { return collected[i].Path < collected[j].Path })
+ return collected, nil
+}
+
+func fixFile(cfg *config.Config, path string, write bool) (FileResult, error) {
+ src, err := os.ReadFile(path)
+ if err != nil {
+ return FileResult{}, err
+ }
+ original := string(src)
+
+ stream := tokens.New(lexer.Lex(original))
+ res := FileResult{Path: path}
+
+ for _, rule := range cfg.Rules {
+ if rule.Fix(stream) {
+ res.AppliedRules = append(res.AppliedRules, rule.Name())
+ }
+ }
+
+ res.After = stream.Render()
+ if !res.Changed() {
+ return res, nil
+ }
+ // The unified diff is only rendered in check (dry-run) mode; --fix reports a
+ // count and rewrites the file, so computing the diff there is wasted work.
+ if !write {
+ res.Diff = diff.Unified(original, res.After)
+ }
+
+ if write {
+ info, statErr := os.Stat(path)
+ mode := os.FileMode(0o644)
+ if statErr == nil {
+ mode = info.Mode()
+ }
+ if err := os.WriteFile(path, []byte(res.After), mode); err != nil {
+ return FileResult{}, err
+ }
+ }
+ return res, nil
+}
diff --git a/blink/internal/runner/runner_test.go b/blink/internal/runner/runner_test.go
new file mode 100644
index 0000000000..81bef6b679
--- /dev/null
+++ b/blink/internal/runner/runner_test.go
@@ -0,0 +1,51 @@
+package runner
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+
+ "blink/internal/config"
+)
+
+func TestRunFixesFile(t *testing.T) {
+ dir := t.TempDir()
+ path := filepath.Join(dir, "sample.php")
+ dirty := " "FooFixer").
+func shortName(name string) string {
+ if i := strings.LastIndexByte(name, '\\'); i >= 0 {
+ return name[i+1:]
+ }
+ return name
+}
+
+// Get returns the fixers of a named set.
+func Get(name string) ([]fixer.Fixer, bool) {
+ build, ok := byName[name]
+ if !ok {
+ return nil, false
+ }
+ return build(), true
+}
+
+// SpacesLevel returns the first n rules of the spaces set, for gradual adoption
+// (withSpacesLevel in ECS). n is clamped to the set size.
+func SpacesLevel(n int) []fixer.Fixer {
+ all := Spaces()
+ if n < 0 {
+ n = 0
+ }
+ if n > len(all) {
+ n = len(all)
+ }
+ return all[:n]
+}
+
+// Names lists the available set names, sorted.
+func Names() []string {
+ names := make([]string, 0, len(byName))
+ for name := range byName {
+ names = append(names, name)
+ }
+ sort.Strings(names)
+ return names
+}
+
+// defaultMembers is psr12Members ∪ commonMembers.
+var defaultMembers = func() map[string]bool {
+ m := map[string]bool{}
+ for k := range psr12Members {
+ m[k] = true
+ }
+ for k := range commonMembers {
+ m[k] = true
+ }
+ return m
+}()
+
+// psr12Members is the @PSR-12 set (from ECS config/set/psr12.php), by short name.
+var psr12Members = map[string]bool{
+ "BinaryOperatorSpacesFixer": true,
+ "BlankLineAfterNamespaceFixer": true,
+ "BlankLineAfterOpeningTagFixer": true,
+ "BracesPositionFixer": true,
+ "ClassDefinitionFixer": true,
+ "ConcatSpaceFixer": true,
+ "ConstantCaseFixer": true,
+ "ControlStructureBracesFixer": true,
+ "ControlStructureContinuationPositionFixer": true,
+ "DeclareEqualNormalizeFixer": true,
+ "DeclareParenthesesFixer": true,
+ "ElseifFixer": true,
+ "EncodingFixer": true,
+ "FullOpeningTagFixer": true,
+ "FunctionDeclarationFixer": true,
+ "IndentationTypeFixer": true,
+ "LineEndingFixer": true,
+ "LowercaseCastFixer": true,
+ "LowercaseKeywordsFixer": true,
+ "MethodArgumentSpaceFixer": true,
+ "NewWithParenthesesFixer": true,
+ "NoBlankLinesAfterClassOpeningFixer": true,
+ "NoBreakCommentFixer": true,
+ "NoClosingTagFixer": true,
+ "NoExtraBlankLinesFixer": true,
+ "NoLeadingImportSlashFixer": true,
+ "NoMultipleStatementsPerLineFixer": true,
+ "NoSinglelineWhitespaceBeforeSemicolonsFixer": true,
+ "NoSpacesAfterFunctionNameFixer": true,
+ "NoTrailingWhitespaceFixer": true,
+ "NoTrailingWhitespaceInCommentFixer": true,
+ "NoWhitespaceBeforeCommaInArrayFixer": true,
+ "OrderedImportsFixer": true,
+ "ReturnTypeDeclarationFixer": true,
+ "ShortScalarCastFixer": true,
+ "SingleBlankLineAtEofFixer": true,
+ "SingleClassElementPerStatementFixer": true,
+ "SingleImportPerStatementFixer": true,
+ "SingleLineAfterImportsFixer": true,
+ "SingleSpaceAroundConstructFixer": true,
+ "SpacesInsideParenthesesFixer": true,
+ "StatementIndentationFixer": true,
+ "SwitchCaseSemicolonToColonFixer": true,
+ "SwitchCaseSpaceFixer": true,
+ "TernaryOperatorSpacesFixer": true,
+ "UnaryOperatorSpacesFixer": true,
+ "VisibilityRequiredFixer": true,
+ "WhitespaceAfterCommaInArrayFixer": true,
+}
+
+// commonMembers is ECS's common set (array, casing, cleanup, comments,
+// control-structures, docblock, namespaces, spaces, clean-code), by short name.
+var commonMembers = map[string]bool{
+ "AddMissingParamNameFixer": true,
+ "AddMissingVarNameFixer": true,
+ "AlignMultilineCommentFixer": true,
+ "ArrayIndentationFixer": true,
+ "ArrayListItemNewlineFixer": true,
+ "ArrayOpenerAndCloserNewlineFixer": true,
+ "ArraySyntaxFixer": true,
+ "AssignNullCoalescingToCoalesceEqualFixer": true,
+ "BinaryOperatorSpacesFixer": true,
+ "BlankLineAfterOpeningTagFixer": true,
+ "BlankLineAfterStrictTypesFixer": true,
+ "CastSpacesFixer": true,
+ "ClassAttributesSeparationFixer": true,
+ "ClassDefinitionFixer": true,
+ "ClassReferenceNameCasingFixer": true,
+ "ConcatSpaceFixer": true,
+ "DoubleAsteriskInlineVarFixer": true,
+ "ExplicitIndirectVariableFixer": true,
+ "ExplicitStringVariableFixer": true,
+ "FixParamNameTypoFixer": true,
+ "FixTagTypoFixer": true,
+ "FunctionToConstantFixer": true,
+ "GeneralPhpdocAnnotationRemoveFixer": true,
+ "IncludeFixer": true,
+ "IntegerLiteralCaseFixer": true,
+ "IsNullFixer": true,
+ "LambdaNotUsedImportFixer": true,
+ "ListSyntaxFixer": true,
+ "LongToShorthandOperatorFixer": true,
+ "MagicConstantCasingFixer": true,
+ "MagicMethodCasingFixer": true,
+ "MergeDocBlockStartFixer": true,
+ "MethodArgumentSpaceFixer": true,
+ "MethodChainingIndentationFixer": true,
+ "MethodChainingNewlineFixer": true,
+ "MultilineCommentOpeningClosingFixer": true,
+ "NativeFunctionCasingFixer": true,
+ "NativeTypeDeclarationCasingFixer": true,
+ "NewWithParenthesesFixer": true,
+ "NoAlternativeSyntaxFixer": true,
+ "NoBlankLineBetweenImportsFixer": true,
+ "NoBlankLinesAfterClassOpeningFixer": true,
+ "NoBlankLinesAfterPhpdocFixer": true,
+ "NoEmptyCommentFixer": true,
+ "NoEmptyPhpdocFixer": true,
+ "NoEmptyStatementFixer": true,
+ "NoExtraBlankLinesFixer": true,
+ "NoLeadingNamespaceWhitespaceFixer": true,
+ "NoMultilineWhitespaceAroundDoubleArrowFixer": true,
+ "NoNullPropertyInitializationFixer": true,
+ "NoShortBoolCastFixer": true,
+ "NoSinglelineWhitespaceBeforeSemicolonsFixer": true,
+ "NoSpacesAroundOffsetFixer": true,
+ "NoSuperfluousElseifFixer": true,
+ "NoSuperfluousPhpdocTagsFixer": true,
+ "NoTrailingCommaInSinglelineFixer": true,
+ "NoTrailingWhitespaceInCommentFixer": true,
+ "NoUnneededControlParenthesesFixer": true,
+ "NoUnneededCurlyBracesFixer": true,
+ "NoUnneededImportAliasFixer": true,
+ "NoUnusedImportsFixer": true,
+ "NoUselessConcatOperatorFixer": true,
+ "NoUselessNullsafeOperatorFixer": true,
+ "NoUselessReturnFixer": true,
+ "NoWhitespaceBeforeCommaInArrayFixer": true,
+ "NoWhitespaceInBlankLineFixer": true,
+ "NoWhitespaceInEmptyArrayFixer": true,
+ "NotOperatorWithSuccessorSpaceFixer": true,
+ "NullableTypeDeclarationForDefaultNullValueFixer": true,
+ "ObjectOperatorWithoutWhitespaceFixer": true,
+ "OrderedImportsFixer": true,
+ "ParamReturnAndVarTagMalformsFixer": true,
+ "PhpdocIndentFixer": true,
+ "PhpdocInlineTagNormalizerFixer": true,
+ "PhpdocLineSpanFixer": true,
+ "PhpdocNoAccessFixer": true,
+ "PhpdocNoAliasTagFixer": true,
+ "PhpdocNoDuplicateTypesFixer": true,
+ "PhpdocNoEmptyReturnFixer": true,
+ "PhpdocNoPackageFixer": true,
+ "PhpdocOrderByValueFixer": true,
+ "PhpdocReturnSelfReferenceFixer": true,
+ "PhpdocScalarFixer": true,
+ "PhpdocSingleLineVarSpacingFixer": true,
+ "PhpdocTagCasingFixer": true,
+ "PhpdocTrimConsecutiveBlankLineSeparationFixer": true,
+ "PhpdocTrimFixer": true,
+ "PhpdocTypesFixer": true,
+ "PhpdocVarWithoutNameFixer": true,
+ "ProtectedToPrivateFixer": true,
+ "RemoveDeadParamFixer": true,
+ "RemoveDeadVarThisFixer": true,
+ "RemoveEventSubscriberDescriptionFixer": true,
+ "RemoveMethodNameDuplicateDescriptionFixer": true,
+ "RemovePHPStormAnnotationFixer": true,
+ "RemoveParamNameReferenceFixer": true,
+ "RemovePropertyVariableNameDescriptionFixer": true,
+ "RemoveSuperfluousReturnNameFixer": true,
+ "RemoveSuperfluousVarNameFixer": true,
+ "RemoveUselessDefaultCommentFixer": true,
+ "ReturnTypeDeclarationFixer": true,
+ "SelfAccessorFixer": true,
+ "SingleBlankLineBeforeNamespaceFixer": true,
+ "SingleClassElementPerStatementFixer": true,
+ "SingleLineCommentSpacingFixer": true,
+ "SingleLineInlineVarDocBlockFixer": true,
+ "SingleQuoteFixer": true,
+ "SingleTraitInsertPerStatementFixer": true,
+ "SpaceAfterCommaHereNowDocFixer": true,
+ "SpaceAfterSemicolonFixer": true,
+ "StandaloneLinePromotedPropertyFixer": true,
+ "StandaloneLineRequiredParamFixer": true,
+ "StandardizeIncrementFixer": true,
+ "StandardizeNotEqualsFixer": true,
+ "SwitchContinueToBreakFixer": true,
+ "SwitchedTypeAndNameFixer": true,
+ "TernaryOperatorSpacesFixer": true,
+ "TernaryToNullCoalescingFixer": true,
+ "TrailingCommaInMultilineFixer": true,
+ "TrimArraySpacesFixer": true,
+ "TypeDeclarationSpacesFixer": true,
+ "TypeToVarTagFixer": true,
+ "TypesSpacesFixer": true,
+ "WhitespaceAfterCommaInArrayFixer": true,
+ "YodaStyleFixer": true,
+}
diff --git a/blink/internal/set/set_test.go b/blink/internal/set/set_test.go
new file mode 100644
index 0000000000..afa14063e0
--- /dev/null
+++ b/blink/internal/set/set_test.go
@@ -0,0 +1,25 @@
+package set
+
+import "testing"
+
+func TestGet(t *testing.T) {
+ if _, ok := Get("spaces"); !ok {
+ t.Fatal("spaces set should exist")
+ }
+ if _, ok := Get("does-not-exist"); ok {
+ t.Fatal("unknown set should not resolve")
+ }
+}
+
+func TestSpacesLevelClamps(t *testing.T) {
+ full := len(Spaces())
+ if got := len(SpacesLevel(-5)); got != 0 {
+ t.Fatalf("negative level should give 0, got %d", got)
+ }
+ if got := len(SpacesLevel(1000)); got != full {
+ t.Fatalf("overflow level should clamp to %d, got %d", full, got)
+ }
+ if got := len(SpacesLevel(2)); got != 2 {
+ t.Fatalf("level 2 should give 2, got %d", got)
+ }
+}
diff --git a/blink/internal/token/token.go b/blink/internal/token/token.go
new file mode 100644
index 0000000000..045518678c
--- /dev/null
+++ b/blink/internal/token/token.go
@@ -0,0 +1,53 @@
+package token
+
+// Kind is the lexical category of a token.
+type Kind int
+
+const (
+ Unknown Kind = iota
+ OpenTag //
+ InlineHTML // text outside PHP tags
+ Whitespace // spaces, tabs, newlines
+ Comment // // # /* */
+ DocComment // /** */
+ Variable // $foo
+ Ident // names (T_STRING): function/class names, constants, types
+ Keyword // reserved words: function, class, return, namespace, ...
+ Number
+ String // '...' "..."
+ Punct // operators, braces, ; , etc.
+ EOF
+)
+
+var kindNames = map[Kind]string{
+ Unknown: "Unknown",
+ OpenTag: "OpenTag",
+ CloseTag: "CloseTag",
+ InlineHTML: "InlineHTML",
+ Whitespace: "Whitespace",
+ Comment: "Comment",
+ DocComment: "DocComment",
+ Variable: "Variable",
+ Ident: "Ident",
+ Keyword: "Keyword",
+ Number: "Number",
+ String: "String",
+ Punct: "Punct",
+ EOF: "EOF",
+}
+
+func (k Kind) String() string {
+ if n, ok := kindNames[k]; ok {
+ return n
+ }
+ return "Kind(?)"
+}
+
+// Token is a single lexical unit. The stream is lossless: concatenating every
+// Value in order reproduces the original source byte for byte.
+type Token struct {
+ Kind Kind
+ Value string
+ Pos int // byte offset in source
+}
diff --git a/blink/internal/tokens/stream.go b/blink/internal/tokens/stream.go
new file mode 100644
index 0000000000..ab18ee8dbe
--- /dev/null
+++ b/blink/internal/tokens/stream.go
@@ -0,0 +1,138 @@
+// Package tokens holds a flat, mutable, index-addressable token stream. This is
+// the ECS/PHP-CS-Fixer working model: fixers read tokens by index and insert,
+// replace or remove them in place, then Render rebuilds the source.
+package tokens
+
+import (
+ "strings"
+
+ "blink/internal/token"
+)
+
+type Stream struct {
+ toks []token.Token
+}
+
+func New(toks []token.Token) *Stream {
+ return &Stream{toks: toks}
+}
+
+func (s *Stream) Len() int { return len(s.toks) }
+
+func (s *Stream) At(i int) token.Token { return s.toks[i] }
+
+// Kind returns just the kind of the token at i, avoiding a full Token copy in
+// the hot index-scanning helpers.
+func (s *Stream) Kind(i int) token.Kind { return s.toks[i].Kind }
+
+func (s *Stream) Set(i int, t token.Token) { s.toks[i] = t }
+
+// SetValue replaces only the Value of the token at i, keeping its kind.
+func (s *Stream) SetValue(i int, v string) { s.toks[i].Value = v }
+
+func (s *Stream) RemoveAt(i int) {
+ s.toks = append(s.toks[:i], s.toks[i+1:]...)
+}
+
+func (s *Stream) InsertAt(i int, t token.Token) {
+ s.toks = append(s.toks, token.Token{})
+ copy(s.toks[i+1:], s.toks[i:])
+ s.toks[i] = t
+}
+
+// MatchForward returns the index of the delimiter matching the opener at i
+// ("(", "{" or "["), or -1 if there is none. Strings and comments are single
+// tokens, so scanning punctuation is safe.
+func (s *Stream) MatchForward(i int) int {
+ if i < 0 || i >= len(s.toks) || s.toks[i].Kind != token.Punct {
+ return -1
+ }
+ open := s.toks[i].Value
+ var closer string
+ switch open {
+ case "(":
+ closer = ")"
+ case "{":
+ closer = "}"
+ case "[":
+ closer = "]"
+ default:
+ return -1
+ }
+ depth := 0
+ for j := i; j < len(s.toks); j++ {
+ if s.toks[j].Kind != token.Punct {
+ continue
+ }
+ switch s.toks[j].Value {
+ case open:
+ depth++
+ case closer:
+ depth--
+ if depth == 0 {
+ return j
+ }
+ }
+ }
+ return -1
+}
+
+// MatchBackward returns the index of the delimiter matching the closer at i
+// (")", "}" or "]"), or -1 if there is none.
+func (s *Stream) MatchBackward(i int) int {
+ if i < 0 || i >= len(s.toks) || s.toks[i].Kind != token.Punct {
+ return -1
+ }
+ closer := s.toks[i].Value
+ var opener string
+ switch closer {
+ case ")":
+ opener = "("
+ case "}":
+ opener = "{"
+ case "]":
+ opener = "["
+ default:
+ return -1
+ }
+ depth := 0
+ for j := i; j >= 0; j-- {
+ if s.toks[j].Kind != token.Punct {
+ continue
+ }
+ switch s.toks[j].Value {
+ case closer:
+ depth++
+ case opener:
+ depth--
+ if depth == 0 {
+ return j
+ }
+ }
+ }
+ return -1
+}
+
+// ReplaceRange swaps tokens [start, end] (inclusive) for repl.
+func (s *Stream) ReplaceRange(start, end int, repl []token.Token) {
+ tail := append([]token.Token(nil), s.toks[end+1:]...)
+ s.toks = append(s.toks[:start], repl...)
+ s.toks = append(s.toks, tail...)
+}
+
+// Render concatenates every token value back into source.
+func (s *Stream) Render() string {
+ n := 0
+ for i := range s.toks {
+ n += len(s.toks[i].Value)
+ }
+ var b strings.Builder
+ b.Grow(n)
+ for i := range s.toks {
+ b.WriteString(s.toks[i].Value)
+ }
+ return b.String()
+}
+
+// Tokens returns the underlying slice (read-only use).
+func (s *Stream) Tokens() []token.Token { return s.toks }
diff --git a/blink/internal/tokens/stream_test.go b/blink/internal/tokens/stream_test.go
new file mode 100644
index 0000000000..2ead04eb84
--- /dev/null
+++ b/blink/internal/tokens/stream_test.go
@@ -0,0 +1,65 @@
+package tokens
+
+import (
+ "testing"
+
+ "blink/internal/token"
+)
+
+func mk(vals ...string) *Stream {
+ var toks []token.Token
+ for _, v := range vals {
+ toks = append(toks, token.Token{Kind: token.Punct, Value: v})
+ }
+ return New(toks)
+}
+
+func TestInsertRemoveRender(t *testing.T) {
+ s := mk("a", "b", "d")
+ s.InsertAt(2, token.Token{Value: "c"})
+ if got := s.Render(); got != "abcd" {
+ t.Fatalf("insert: got %q", got)
+ }
+ s.RemoveAt(0)
+ if got := s.Render(); got != "bcd" {
+ t.Fatalf("remove: got %q", got)
+ }
+}
+
+func TestInsertAtEnd(t *testing.T) {
+ s := mk("a", "b")
+ s.InsertAt(s.Len(), token.Token{Value: "c"})
+ if got := s.Render(); got != "abc" {
+ t.Fatalf("append: got %q", got)
+ }
+}
+
+func TestSetValue(t *testing.T) {
+ s := mk("a", "b")
+ s.SetValue(1, "B")
+ if got := s.Render(); got != "aB" {
+ t.Fatalf("setvalue: got %q", got)
+ }
+}
+
+func TestMatchForward(t *testing.T) {
+ // ( a [ b ] c ) -> outer "(" at 0 matches ")" at 6
+ s := mk("(", "a", "[", "b", "]", "c", ")")
+ if got := s.MatchForward(0); got != 6 {
+ t.Fatalf("outer match: got %d, want 6", got)
+ }
+ if got := s.MatchForward(2); got != 4 {
+ t.Fatalf("inner match: got %d, want 4", got)
+ }
+ if got := s.MatchForward(1); got != -1 {
+ t.Fatalf("non-opener should be -1, got %d", got)
+ }
+}
+
+func TestReplaceRange(t *testing.T) {
+ s := mk("a", "b", "c", "d")
+ s.ReplaceRange(1, 2, []token.Token{{Kind: token.Punct, Value: "X"}})
+ if got := s.Render(); got != "aXd" {
+ t.Fatalf("replace: got %q", got)
+ }
+}
diff --git a/blink/main.go b/blink/main.go
new file mode 100644
index 0000000000..ae06821820
--- /dev/null
+++ b/blink/main.go
@@ -0,0 +1,155 @@
+// Command blink is a token-based coding-standard checker/fixer for PHP,
+// modeled on symplify/easy-coding-standard.
+package main
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "runtime"
+ "runtime/debug"
+ "time"
+
+ "blink/internal/config"
+ "blink/internal/fixer/rules"
+ "blink/internal/reporter"
+ "blink/internal/runner"
+)
+
+func main() {
+ // A short-lived batch process: relax the GC so it collects far less during
+ // the run instead of reclaiming memory the process is about to release anyway.
+ debug.SetGCPercent(400)
+ os.Exit(run(os.Args[1:]))
+}
+
+func run(args []string) int {
+ fix := false
+ configPath := ""
+ ecsConfigPath := ""
+ var paths []string
+
+ for i := 0; i < len(args); i++ {
+ a := args[i]
+ switch {
+ case a == "--fix":
+ fix = true
+ case a == "list-checkers":
+ return listCheckers()
+ case a == "-h" || a == "--help":
+ usage()
+ return 0
+ case a == "--config":
+ if i+1 < len(args) {
+ configPath = args[i+1]
+ i++
+ }
+ case len(a) > 9 && a[:9] == "--config=":
+ configPath = a[9:]
+ case a == "--ecs-config":
+ if i+1 < len(args) {
+ ecsConfigPath = args[i+1]
+ i++
+ }
+ case len(a) > 13 && a[:13] == "--ecs-config=":
+ ecsConfigPath = a[13:]
+ default:
+ paths = append(paths, a)
+ }
+ }
+
+ var cfg *config.Config
+ var err error
+ if ecsConfigPath != "" {
+ var resolution *config.ECSResolution
+ cfg, resolution, err = config.LoadECS(ecsConfigPath)
+ if err == nil {
+ reportECSResolution(os.Stderr, resolution)
+ }
+ } else {
+ cfg, err = loadConfig(configPath)
+ }
+ if err != nil {
+ fmt.Fprintln(os.Stderr, "error:", err)
+ return 2
+ }
+ // CLI paths override the config; runs across all CPU cores by default
+ cfg.WithPaths(paths...)
+
+ start := time.Now()
+ progress := reporter.NewProgress(os.Stderr)
+
+ results, err := runner.Run(cfg, fix, progress)
+ progress.Finish()
+ if err != nil {
+ fmt.Fprintln(os.Stderr, "error:", err)
+ return 2
+ }
+
+ code := reporter.Report(os.Stdout, results, fix)
+
+ var mem runtime.MemStats
+ runtime.ReadMemStats(&mem)
+ reporter.Footer(os.Stdout, progress.Total(), time.Since(start), mem.Sys)
+ return code
+}
+
+// loadConfig uses an explicit --config path, else a blink.json in the working
+// directory, else the built-in defaults (all rules).
+func loadConfig(configPath string) (*config.Config, error) {
+ if configPath != "" {
+ return config.Load(configPath)
+ }
+ if _, err := os.Stat("blink.json"); err == nil {
+ return config.Load("blink.json")
+ }
+ return config.Configure(), nil
+}
+
+// reportECSResolution prints, to w, how an ECS turbo config mapped: how many
+// rules resolved to blink fixers and everything that could not, so a turbo run
+// is never silently narrower than the ECS config it stands in for.
+func reportECSResolution(w io.Writer, resolution *config.ECSResolution) {
+ _, _ = fmt.Fprintf(w, "turbo: mapped %d of %d ECS rules to blink fixers\n", resolution.Mapped, resolution.Total)
+ if len(resolution.Unsupported) > 0 {
+ _, _ = fmt.Fprintf(w, " %d unsupported (no blink fixer), skipped:\n", len(resolution.Unsupported))
+ for _, class := range resolution.Unsupported {
+ _, _ = fmt.Fprintf(w, " - %s\n", class)
+ }
+ }
+ if len(resolution.ConfigIgnored) > 0 {
+ _, _ = fmt.Fprintf(w, " %d configured rule(s) applied with blink's built-in behaviour (config not modelled):\n", len(resolution.ConfigIgnored))
+ for _, class := range resolution.ConfigIgnored {
+ _, _ = fmt.Fprintf(w, " - %s\n", class)
+ }
+ }
+ if len(resolution.PerPathSkips) > 0 {
+ _, _ = fmt.Fprintln(w, " per-path rule skips applied project-wide (not yet honoured per path):")
+ for _, class := range resolution.PerPathSkips {
+ _, _ = fmt.Fprintf(w, " - %s\n", class)
+ }
+ }
+}
+
+func listCheckers() int {
+ fmt.Println("Registered checkers:")
+ for _, r := range rules.All() {
+ fmt.Printf(" - %s\n", r.Name())
+ }
+ return 0
+}
+
+func usage() {
+ fmt.Print(`blink - token-based PHP coding standard tool
+
+Usage:
+ blink [paths...] check paths (default: .)
+ blink --fix [paths...] fix paths in place
+ blink --config FILE ... use a blink.json config
+ blink --ecs-config FILE ... use an ECS dump-config JSON (turbo mode)
+ blink list-checkers list registered fixers
+
+Loads blink.json from the working directory when present.
+Runs across all CPU cores by default.
+`)
+}
diff --git a/blink/psr12-left.txt b/blink/psr12-left.txt
new file mode 100644
index 0000000000..991e37ef93
--- /dev/null
+++ b/blink/psr12-left.txt
@@ -0,0 +1,60 @@
+PSR-12 rules left to implement
+==============================
+
+Reference: PHP-CS-Fixer @PSR12 = @PSR2 (+ @PSR1) plus extra rules.
+Below: what remains NOT implemented in blink. 47 fixers are done (see bottom).
+
+A statement/scope layer exists: Stream.MatchForward/MatchBackward, classifyBrace
+(labels each "{"), and classMemberStarts (iterates class members). The rules
+below need more of it (member reordering, type spans) or a fuller type model.
+
+
+NEEDS FULLER AST / TYPE MODEL
+-----------------------------
+function_declaration "function" signature spacing, closures
+compact_nullable_type_declaration "? int" -> "?int" in type positions
+modifier_keywords modifier ordering (casing/presence done)
+new_with_parentheses "new Foo" -> "new Foo()" (needs class-name ctx)
+
+Notes:
+- method_argument_space is implemented for single-line comma spacing only; the
+ multi-line "one argument per line" reflow is not done.
+- ordered_class_elements is conservative: it skips any class containing comments
+ or attributes (attributes lex as # comments here), reordering only simple
+ classes. Broadening it needs first-class attribute tokens.
+
+
+LEFTOVERS (bounded / low value)
+-------------------------------
+no_break_comment add "// no break" on fallthrough (heuristic)
+binary_operator_spaces arithmetic/bitwise (+ - * / % & | ^): unary-
+ ambiguous, need operand context
+
+
+IMPLEMENTED (47)
+----------------
+casing: lowercase_keywords, constant_case, lowercase_static_reference,
+ lowercase_cast, short_scalar_cast
+spacing: no_leading_namespace_whitespace, no_singleline_whitespace_before_semicolons,
+ no_whitespace_in_blank_line, no_extra_blank_lines, space_after_semicolon,
+ binary_operator_spaces (=, =>, comparison, logical), concat_space,
+ cast_spaces, ternary_operator_spaces, blank_line_after_opening_tag,
+ no_trailing_whitespace, no_trailing_whitespace_in_comment,
+ single_blank_line_at_eof
+functions: method_argument_space (single-line), return_type_declaration,
+ no_spaces_after_function_name
+constructs: single_space_around_construct, spaces_inside_parentheses,
+ unary_operator_spaces, elseif,
+ no_leading_import_slash, declare_equal_normalize,
+ switch_case_semicolon_to_colon, switch_case_space,
+ no_multiple_statements_per_line
+php tag: full_opening_tag, no_closing_tag
+braces: braces_position
+class: visibility_required, single_trait_insert_per_statement,
+ single_class_element_per_statement, class_definition,
+ ordered_class_elements (conservative)
+imports: single_import_per_statement, ordered_imports,
+ blank_line_between_import_groups, single_line_after_imports
+structural: blank_lines_before_namespace, blank_line_after_namespace,
+ no_blank_lines_after_class_opening, indentation_type,
+ statement_indentation
diff --git a/blink/testdata/dirty.php b/blink/testdata/dirty.php
new file mode 100644
index 0000000000..4c1a5f5aaa
--- /dev/null
+++ b/blink/testdata/dirty.php
@@ -0,0 +1,12 @@
+=8.4",