go: parse.sx — multi-form file parsing + 7 e2e tests; PHASE 2 COMPLETE [nothing]

Final Phase 2 sub-deliverable. go-parse now handles whole Go files:

  - Empty source → nil
  - Single top-level form → that form (backward-compatible with ~169
    existing single-stmt / single-decl tests)
  - Multiple forms → (list :file FORMS), the canonical Go file shape

Implementation: gp-parse-all loops gp-parse-top until eof, tolerating
ASI semis between forms, then returns based on form count.

End-to-end test set (asserts the top-level decl-tag sequence via a
new decl-tags helper, not the full AST tree — that'd be unwieldy):

  - hello-world             :package :import :func-decl
  - recursive fibonacci     :package :func-decl
  - FizzBuzz                :package :import :func-decl
  - goroutine ping-pong     :package :func-decl :func-decl
  - struct + method         :package :type-decl :method-decl :func-decl
  - interface + method      :package :type-decl :type-decl :method-decl
  - defer + select + range  :package :func-decl

Type-switch (`switch v := x.(type) { ... }`) is the one syntactic
shape still deferred from Phase 2; doesn't gate Phase 3.

**Phase 2 (parser) is complete.** parse 176/176, total 305/305. Next:
Phase 3 — bidirectional type checker. The sister-plan diary for
static-types-bidirectional already has the :field binding-group
insight; Phase 3 will add the synth/check shape that emerges.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

lib/go/parse.sx

@@ -1175,4 +1175,34 @@
                      (= (gp-tok-value) "func")))
             (gp-parse-decl)
             :else (gp-parse-stmt))))
-      (gp-parse-top))))
+      (define
+        gp-parse-all
+        ;; Parse all top-level forms until eof. Returns:
+        ;;   nil                 — empty input
+        ;;   single form         — backward-compatible with single-stmt
+        ;;                          /single-decl tests; ~169 of them.
+        ;;   (list :file FORMS)  — multiple forms (canonical Go file shape)
+        (fn
+          ()
+          (let ((forms (list)))
+            (define
+              gp-all-loop
+              (fn
+                ()
+                (cond
+                  (= (gp-tok-type) "eof") nil
+                  (= (gp-tok-type) "semi")
+                  (do (gp-advance!) (gp-all-loop))
+                  :else
+                  (do
+                    (let ((saved-idx gp-idx))
+                      (let ((d (gp-parse-top)))
+                        (when (not (= d nil)) (append! forms d)))
+                      (when (= gp-idx saved-idx) (gp-advance!)))
+                    (gp-all-loop)))))
+            (gp-all-loop)
+            (cond
+              (= (len forms) 0) nil
+              (= (len forms) 1) (first forms)
+              :else (list :file forms)))))
+      (gp-parse-all))))

lib/go/scoreboard.json

@@ -1,10 +1,10 @@
 {
   "language": "go",
-  "total_pass": 298,
-  "total": 298,
+  "total_pass": 305,
+  "total": 305,
   "suites": [
     {"name":"lex","pass":129,"total":129,"status":"ok"},
-    {"name":"parse","pass":169,"total":169,"status":"ok"},
+    {"name":"parse","pass":176,"total":176,"status":"ok"},
     {"name":"types","pass":0,"total":0,"status":"pending"},
     {"name":"eval","pass":0,"total":0,"status":"pending"},
     {"name":"runtime","pass":0,"total":0,"status":"pending"},

lib/go/scoreboard.md

@@ -1,11 +1,11 @@
 # Go-on-SX Scoreboard
 
-**Total: 298 / 298 tests passing**
+**Total: 305 / 305 tests passing**
 
 |  | Suite | Pass | Total |
 |---|---|---|---|
 | ✅ | lex | 129 | 129 |
-| ✅ | parse | 169 | 169 |
+| ✅ | parse | 176 | 176 |
 | ⬜ | types | 0 | 0 |
 | ⬜ | eval | 0 | 0 |
 | ⬜ | runtime | 0 | 0 |

lib/go/tests/parse.sx

@@ -1127,6 +1127,66 @@
         (list (ast-var "a")))
       (list :default (list (ast-var "b"))))))
 
+(define
+  decl-tags
+  (fn
+    (parsed)
+    (cond
+      (and (list? parsed) (= (first parsed) :file))
+      (map (fn (d) (first d)) (nth parsed 1))
+      (list? parsed)
+      (list (first parsed))
+      :else (list))))
+
+(go-parse-test
+  "e2e: hello-world top-level tags"
+  (decl-tags
+    (go-parse
+      "package main\nimport \"fmt\"\nfunc main() { fmt.Println(\"hello, world\") }"))
+  (list :package :import :func-decl))
+
+(go-parse-test
+  "e2e: recursive fibonacci"
+  (decl-tags
+    (go-parse
+      "package main\nfunc fib(n int) int {\n  if n < 2 { return n }\n  return fib(n-1) + fib(n-2)\n}"))
+  (list :package :func-decl))
+
+(go-parse-test
+  "e2e: FizzBuzz with for + if-else chain"
+  (decl-tags
+    (go-parse
+      "package main\nimport \"fmt\"\nfunc fizzbuzz(n int) {\n  for i := 1; i <= n; i++ {\n    if i % 15 == 0 { fmt.Println(\"FizzBuzz\") } else if i % 3 == 0 { fmt.Println(\"Fizz\") } else if i % 5 == 0 { fmt.Println(\"Buzz\") } else { fmt.Println(i) }\n  }\n}"))
+  (list :package :import :func-decl))
+
+(go-parse-test
+  "e2e: goroutine ping-pong (channels)"
+  (decl-tags
+    (go-parse
+      "package main\nfunc sender(ch chan int) { ch <- 1 }\nfunc main() {\n  ch := make(chan int)\n  go sender(ch)\n  x := <-ch\n  print(x)\n}"))
+  (list :package :func-decl :func-decl))
+
+(go-parse-test
+  "e2e: struct + method"
+  (decl-tags
+    (go-parse
+      "package main\ntype Point struct { x, y int }\nfunc (p Point) Sum() int { return p.x + p.y }\nfunc main() {\n  p := Point{1, 2}\n  print(p.Sum())\n}"))
+  (list :package :type-decl :method-decl :func-decl))
+
+(go-parse-test
+  "e2e: interface + structural satisfaction setup"
+  (decl-tags
+    (go-parse
+      "package main\ntype Stringer interface { String() string }\ntype T struct { v int }\nfunc (t T) String() string { return \"t\" }"))
+  (list :package :type-decl :type-decl :method-decl))
+
+(go-parse-test
+  "e2e: defer + select + range"
+  (decl-tags
+    (go-parse
+      "package main\nfunc worker(jobs chan int, results chan int) {\n  defer close(results)\n  for j := range jobs {\n    select {\n    case results <- j * 2:\n    default:\n      return\n    }\n  }\n}"))
+  (list :package :func-decl))
+
 (go-parse-test "non-primary: '+'" (go-parse "+") nil)
 
 (go-parse-test "non-primary: empty" (go-parse "") nil)