coop/rose-ash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9acdbcb8d89ee5705e93abcf1cf3ca588f764a34
rose-ash/lib/go/tests/parse.sx
giles 9acdbcb8d8
Some checks failed
Test, Build, and Deploy / test-build-deploy (push) Failing after 20s
Details
go: parse.sx — func type expressions (anonymous params) + 9 tests [nothing] 
Adds Go func-type parsing to gp-parse-type:
  func()                  →  (list :ty-func () ())
  func() int              →  (list :ty-func () [int])
  func(int, string)       →  (list :ty-func [int string] ())
  func(int) string        →  (list :ty-func [int] [string])
  func() (int, error)     →  (list :ty-func () [int error])

gp-parse-func-type-params handles the param list inside (...);
gp-parse-func-type-results dispatches between bare single-return,
multi-return parenthesised list, or no return.

Anonymous-only — named params (`func(a int, b string)`) require a
different shape and are mainly needed for func DECLARATIONS, not for
pure func-type expressions in type position. Variadic ('...T')
deferred.

Covers nested cases: func returning func, chan of func, func with
pointer/slice operands.

parse 90/90, total 219/219.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-27 08:06:53 +00:00

517 lines
14 KiB
Plaintext
Raw Blame History

;; Go parser tests.
(define go-parse-test-count 0)
(define go-parse-test-pass 0)
(define go-parse-test-fails (list))
(define
go-parse-test
(fn
(name actual expected)
(set! go-parse-test-count (+ go-parse-test-count 1))
(if
(= actual expected)
(set! go-parse-test-pass (+ go-parse-test-pass 1))
(append! go-parse-test-fails {:name name :expected expected :actual actual}))))
;; ── primary: literals ─────────────────────────────────────────────
(go-parse-test "int literal" (go-parse "42") (ast-literal "42"))
(go-parse-test "zero literal" (go-parse "0") (ast-literal "0"))
(go-parse-test "hex literal" (go-parse "0xFF") (ast-literal "0xFF"))
(go-parse-test "float literal" (go-parse "3.14") (ast-literal "3.14"))
(go-parse-test "leading-dot float" (go-parse ".5") (ast-literal ".5"))
(go-parse-test "exponent float" (go-parse "1e10") (ast-literal "1e10"))
(go-parse-test "imag literal" (go-parse "2i") (ast-literal "2i"))
(go-parse-test "string literal" (go-parse "\"hi\"") (ast-literal "hi"))
(go-parse-test "empty string" (go-parse "\"\"") (ast-literal ""))
(go-parse-test "raw string" (go-parse "`a\nb`") (ast-literal "a\nb"))
(go-parse-test "rune literal" (go-parse "'a'") (ast-literal "a"))
;; ── primary: identifiers ──────────────────────────────────────────
(go-parse-test "ident: simple" (go-parse "x") (ast-var "x"))
(go-parse-test "ident: underscore" (go-parse "_foo") (ast-var "_foo"))
(go-parse-test "ident: mixed case" (go-parse "fooBar") (ast-var "fooBar"))
(go-parse-test "ident: with digit" (go-parse "x123") (ast-var "x123"))
;; ── primary: non-primary returns nil ──────────────────────────────
(go-parse-test
"bin: a + b"
(go-parse "a + b")
(ast-app (ast-var "+") (list (ast-var "a") (ast-var "b"))))
(go-parse-test
"bin: int + int"
(go-parse "1 + 2")
(ast-app (ast-var "+") (list (ast-literal "1") (ast-literal "2"))))
;; ── report ────────────────────────────────────────────────────────
(go-parse-test
"bin: left-assoc a + b + c"
(go-parse "a + b + c")
(ast-app
(ast-var "+")
(list
(ast-app (ast-var "+") (list (ast-var "a") (ast-var "b")))
(ast-var "c"))))
(go-parse-test
"bin: * tighter than + → a + b * c"
(go-parse "a + b * c")
(ast-app
(ast-var "+")
(list
(ast-var "a")
(ast-app (ast-var "*") (list (ast-var "b") (ast-var "c"))))))
(go-parse-test
"bin: * tighter than + → a * b + c"
(go-parse "a * b + c")
(ast-app
(ast-var "+")
(list
(ast-app (ast-var "*") (list (ast-var "a") (ast-var "b")))
(ast-var "c"))))
(go-parse-test
"bin: && tighter than || → a || b && c"
(go-parse "a || b && c")
(ast-app
(ast-var "||")
(list
(ast-var "a")
(ast-app (ast-var "&&") (list (ast-var "b") (ast-var "c"))))))
(go-parse-test
"bin: comparison tighter than &&"
(go-parse "a == b && c < d")
(ast-app
(ast-var "&&")
(list
(ast-app (ast-var "==") (list (ast-var "a") (ast-var "b")))
(ast-app (ast-var "<") (list (ast-var "c") (ast-var "d"))))))
(go-parse-test
"bin: long left-assoc chain a + b - c + d"
(go-parse "a + b - c + d")
(ast-app
(ast-var "+")
(list
(ast-app
(ast-var "-")
(list
(ast-app (ast-var "+") (list (ast-var "a") (ast-var "b")))
(ast-var "c")))
(ast-var "d"))))
(go-parse-test
"bin: equal-prec left-assoc — a | b ^ c → (a | b) ^ c"
(go-parse "a | b ^ c")
(ast-app
(ast-var "^")
(list
(ast-app (ast-var "|") (list (ast-var "a") (ast-var "b")))
(ast-var "c"))))
(go-parse-test
"unary: -a"
(go-parse "-a")
(ast-app (ast-var "-") (list (ast-var "a"))))
(go-parse-test
"unary: +a"
(go-parse "+a")
(ast-app (ast-var "+") (list (ast-var "a"))))
(go-parse-test
"unary: !x"
(go-parse "!x")
(ast-app (ast-var "!") (list (ast-var "x"))))
(go-parse-test
"unary: ^x (bitwise NOT)"
(go-parse "^x")
(ast-app (ast-var "^") (list (ast-var "x"))))
(go-parse-test
"unary: *p (pointer deref)"
(go-parse "*p")
(ast-app (ast-var "*") (list (ast-var "p"))))
(go-parse-test
"unary: &v (address-of)"
(go-parse "&v")
(ast-app (ast-var "&") (list (ast-var "v"))))
(go-parse-test
"unary: <-ch (channel recv)"
(go-parse "<-ch")
(ast-app (ast-var "<-") (list (ast-var "ch"))))
(go-parse-test
"unary: -1 (on literal)"
(go-parse "-1")
(ast-app (ast-var "-") (list (ast-literal "1"))))
(go-parse-test
"unary: !!x (chained, right-recursive)"
(go-parse "!!x")
(ast-app
(ast-var "!")
(list (ast-app (ast-var "!") (list (ast-var "x"))))))
(go-parse-test
"unary: -a + b → ((-a) + b) — unary tighter than binary"
(go-parse "-a + b")
(ast-app
(ast-var "+")
(list (ast-app (ast-var "-") (list (ast-var "a"))) (ast-var "b"))))
(go-parse-test
"unary: a + -b → unary applies to RHS"
(go-parse "a + -b")
(ast-app
(ast-var "+")
(list (ast-var "a") (ast-app (ast-var "-") (list (ast-var "b"))))))
(go-parse-test
"call: f() (no args)"
(go-parse "f()")
(ast-app (ast-var "f") (list)))
(go-parse-test
"call: f(x)"
(go-parse "f(x)")
(ast-app (ast-var "f") (list (ast-var "x"))))
(go-parse-test
"call: f(x, y, z)"
(go-parse "f(x, y, z)")
(ast-app (ast-var "f") (list (ast-var "x") (ast-var "y") (ast-var "z"))))
(go-parse-test
"call: f(1, 2)"
(go-parse "f(1, 2)")
(ast-app (ast-var "f") (list (ast-literal "1") (ast-literal "2"))))
(go-parse-test
"call: f(a + b) — arg can be a binary expr"
(go-parse "f(a + b)")
(ast-app
(ast-var "f")
(list (ast-app (ast-var "+") (list (ast-var "a") (ast-var "b"))))))
(go-parse-test
"call: f(g(x)) — nested"
(go-parse "f(g(x))")
(ast-app
(ast-var "f")
(list (ast-app (ast-var "g") (list (ast-var "x"))))))
(go-parse-test
"select: x.y"
(go-parse "x.y")
(list :select (ast-var "x") "y"))
(go-parse-test
"select: x.y.z (chained left-assoc)"
(go-parse "x.y.z")
(list :select (list :select (ast-var "x") "y") "z"))
(go-parse-test
"method: obj.method()"
(go-parse "obj.method()")
(ast-app (list :select (ast-var "obj") "method") (list)))
(go-parse-test
"method: obj.method(x, y)"
(go-parse "obj.method(x, y)")
(ast-app
(list :select (ast-var "obj") "method")
(list (ast-var "x") (ast-var "y"))))
(go-parse-test
"postfix: -f(x) → unary applies after call"
(go-parse "-f(x)")
(ast-app
(ast-var "-")
(list (ast-app (ast-var "f") (list (ast-var "x"))))))
(go-parse-test
"postfix: f(x) + 1 → call binds tighter than binary +"
(go-parse "f(x) + 1")
(ast-app
(ast-var "+")
(list (ast-app (ast-var "f") (list (ast-var "x"))) (ast-literal "1"))))
(go-parse-test
"index: a[0]"
(go-parse "a[0]")
(list :index (ast-var "a") (ast-literal "0")))
(go-parse-test
"index: a[i]"
(go-parse "a[i]")
(list :index (ast-var "a") (ast-var "i")))
(go-parse-test
"index: a[i + 1] (expr index)"
(go-parse "a[i + 1]")
(list
:index (ast-var "a")
(ast-app (ast-var "+") (list (ast-var "i") (ast-literal "1")))))
(go-parse-test
"index: m[\"key\"] (string index)"
(go-parse "m[\"key\"]")
(list :index (ast-var "m") (ast-literal "key")))
(go-parse-test
"index: a[0][1] (chained)"
(go-parse "a[0][1]")
(list
:index (list :index (ast-var "a") (ast-literal "0"))
(ast-literal "1")))
(go-parse-test
"index: a[0].field (mixed with selector)"
(go-parse "a[0].field")
(list :select (list :index (ast-var "a") (ast-literal "0")) "field"))
(go-parse-test
"slice: a[:]"
(go-parse "a[:]")
(list :slice (ast-var "a") nil nil nil))
(go-parse-test
"slice: a[1:]"
(go-parse "a[1:]")
(list :slice (ast-var "a") (ast-literal "1") nil nil))
(go-parse-test
"slice: a[:2]"
(go-parse "a[:2]")
(list :slice (ast-var "a") nil (ast-literal "2") nil))
(go-parse-test
"slice: a[1:2]"
(go-parse "a[1:2]")
(list :slice (ast-var "a") (ast-literal "1") (ast-literal "2") nil))
(go-parse-test
"slice: a[1:2:3] (full slice)"
(go-parse "a[1:2:3]")
(list
:slice (ast-var "a")
(ast-literal "1")
(ast-literal "2")
(ast-literal "3")))
(go-parse-test
"slice: a[i:j] (var bounds)"
(go-parse "a[i:j]")
(list :slice (ast-var "a") (ast-var "i") (ast-var "j") nil))
(go-parse-test
"assert: v.(int)"
(go-parse "v.(int)")
(list :assert (ast-var "v") (list :ty-name "int")))
(go-parse-test
"assert: v.(string)"
(go-parse "v.(string)")
(list :assert (ast-var "v") (list :ty-name "string")))
(go-parse-test
"assert: v.(MyType) (user-defined)"
(go-parse "v.(MyType)")
(list :assert (ast-var "v") (list :ty-name "MyType")))
(go-parse-test
"assert: v.(*T) (pointer type)"
(go-parse "v.(*T)")
(list :assert (ast-var "v") (list :ty-ptr (list :ty-name "T"))))
(go-parse-test
"assert: v.(**T) (pointer-to-pointer)"
(go-parse "v.(**T)")
(list
:assert (ast-var "v")
(list :ty-ptr (list :ty-ptr (list :ty-name "T")))))
(go-parse-test
"assert: v.(pkg.T) (qualified type)"
(go-parse "v.(pkg.T)")
(list :assert (ast-var "v") (list :ty-sel "pkg" "T")))
(go-parse-test
"assert: f().(int) (on call result)"
(go-parse "f().(int)")
(list :assert (ast-app (ast-var "f") (list)) (list :ty-name "int")))
(go-parse-test
"assert: obj.field.(int) (after selector)"
(go-parse "obj.field.(int)")
(list
:assert (list :select (ast-var "obj") "field")
(list :ty-name "int")))
(go-parse-test
"assert: v.(int) + 1 (assert binds tighter than binary +)"
(go-parse "v.(int) + 1")
(ast-app
(ast-var "+")
(list
(list :assert (ast-var "v") (list :ty-name "int"))
(ast-literal "1"))))
(go-parse-test
"ty: []int (slice)"
(go-parse "v.([]int)")
(list :assert (ast-var "v") (list :ty-slice (list :ty-name "int"))))
(go-parse-test
"ty: [10]int (array)"
(go-parse "v.([10]int)")
(list
:assert (ast-var "v")
(list :ty-array (ast-literal "10") (list :ty-name "int"))))
(go-parse-test
"ty: map[string]int"
(go-parse "v.(map[string]int)")
(list
:assert (ast-var "v")
(list :ty-map (list :ty-name "string") (list :ty-name "int"))))
(go-parse-test
"ty: chan int (bidirectional)"
(go-parse "v.(chan int)")
(list :assert (ast-var "v") (list :ty-chan :both (list :ty-name "int"))))
(go-parse-test
"ty: chan<- int (send-only)"
(go-parse "v.(chan<- int)")
(list :assert (ast-var "v") (list :ty-chan :send (list :ty-name "int"))))
(go-parse-test
"ty: <-chan int (recv-only)"
(go-parse "v.(<-chan int)")
(list :assert (ast-var "v") (list :ty-chan :recv (list :ty-name "int"))))
(go-parse-test
"ty: []*T (slice of pointers)"
(go-parse "v.([]*T)")
(list
:assert (ast-var "v")
(list :ty-slice (list :ty-ptr (list :ty-name "T")))))
(go-parse-test
"ty: [][]int (slice of slice)"
(go-parse "v.([][]int)")
(list
:assert (ast-var "v")
(list :ty-slice (list :ty-slice (list :ty-name "int")))))
(go-parse-test
"ty: map[string][]int (map with slice value)"
(go-parse "v.(map[string][]int)")
(list
:assert (ast-var "v")
(list
:ty-map (list :ty-name "string")
(list :ty-slice (list :ty-name "int")))))
(go-parse-test
"ty: chan map[K]V (chan of map type)"
(go-parse "v.(chan map[K]V)")
(list
:assert (ast-var "v")
(list
:ty-chan :both
(list :ty-map (list :ty-name "K") (list :ty-name "V")))))
(go-parse-test
"ty: *[]int (pointer to slice)"
(go-parse "v.(*[]int)")
(list
:assert (ast-var "v")
(list :ty-ptr (list :ty-slice (list :ty-name "int")))))
(go-parse-test
"ty: func() (no params, no return)"
(go-parse "v.(func())")
(list :assert (ast-var "v") (list :ty-func (list) (list))))
(go-parse-test
"ty: func() int (no params, one return)"
(go-parse "v.(func() int)")
(list
:assert (ast-var "v")
(list :ty-func (list) (list (list :ty-name "int")))))
(go-parse-test
"ty: func(int)"
(go-parse "v.(func(int))")
(list
:assert (ast-var "v")
(list :ty-func (list (list :ty-name "int")) (list))))
(go-parse-test
"ty: func(int, string)"
(go-parse "v.(func(int, string))")
(list
:assert (ast-var "v")
(list
:ty-func (list (list :ty-name "int") (list :ty-name "string"))
(list))))
(go-parse-test
"ty: func(int) string"
(go-parse "v.(func(int) string)")
(list
:assert (ast-var "v")
(list
:ty-func (list (list :ty-name "int"))
(list (list :ty-name "string")))))
(go-parse-test
"ty: func() (int, error) (multi return)"
(go-parse "v.(func() (int, error))")
(list
:assert (ast-var "v")
(list
:ty-func (list)
(list (list :ty-name "int") (list :ty-name "error")))))
(go-parse-test
"ty: func(*T) []int (pointer param, slice return)"
(go-parse "v.(func(*T) []int)")
(list
:assert (ast-var "v")
(list
:ty-func (list (list :ty-ptr (list :ty-name "T")))
(list (list :ty-slice (list :ty-name "int"))))))
(go-parse-test
"ty: func() func() (nested func type as return)"
(go-parse "v.(func() func())")
(list
:assert (ast-var "v")
(list :ty-func (list) (list (list :ty-func (list) (list))))))
(go-parse-test
"ty: chan func() int (chan of func type)"
(go-parse "v.(chan func() int)")
(list
:assert (ast-var "v")
(list
:ty-chan :both
(list :ty-func (list) (list (list :ty-name "int"))))))
(go-parse-test "non-primary: '+'" (go-parse "+") nil)
(go-parse-test "non-primary: empty" (go-parse "") nil)
(define
go-parse-test-summary
(str "parse " go-parse-test-pass "/" go-parse-test-count))
Reference in New Issue View Git Blame Copy Permalink