;; lib/go/parse.sx — Go parser. Tokenises via go-tokenize (lib/go/lex.sx),
;; builds canonical AST nodes per lib/guest/ast.sx, and uses the operator
;; entry shape from lib/guest/pratt.sx for precedence climbing (Pratt).
;;
;; First slice: primary expressions only —
;;   int / float / imag / string / rune literal → (ast-literal VALUE)
;;   identifier                                 → (ast-var NAME)
;;
;; Subsequent slices add binary operators (via gp-precedence-table +
;; pratt-op-lookup), function calls, type expressions, declarations,
;; and statements.
;;
;; All scanner locals are gp- prefixed (mirrors lib/go/lex.sx's gl- prefix):
;; SX host primitives silently shadow guest-language defines.

(define
  go-precedence-table
  (list
    (list "*" 5 :left)
    (list "/" 5 :left)
    (list "%" 5 :left)
    (list "<<" 5 :left)
    (list ">>" 5 :left)
    (list "&" 5 :left)
    (list "&^" 5 :left)
    (list "+" 4 :left)
    (list "-" 4 :left)
    (list "|" 4 :left)
    (list "^" 4 :left)
    (list "==" 3 :left)
    (list "!=" 3 :left)
    (list "<" 3 :left)
    (list "<=" 3 :left)
    (list ">" 3 :left)
    (list ">=" 3 :left)
    (list "&&" 2 :left)
    (list "||" 1 :left)))

(define
  go-parse
  (fn
    (src)
    (let
      ((gp-tokens (go-tokenize src)) (gp-idx 0))
      (define gp-cur (fn () (nth gp-tokens gp-idx)))
      (define gp-advance! (fn () (set! gp-idx (+ gp-idx 1))))
      (define gp-tok-type (fn () (get (gp-cur) :type)))
      (define gp-tok-value (fn () (get (gp-cur) :value)))
      (define
        gp-parse-primary
        (fn
          ()
          (let
            ((ty (gp-tok-type)) (v (gp-tok-value)))
            (cond
              (or
                (= ty "int")
                (= ty "float")
                (= ty "imag")
                (= ty "string")
                (= ty "rune"))
              (do (gp-advance!) (ast-literal v))
              (= ty "ident")
              (do (gp-advance!) (ast-var v))
              :else nil))))
      (gp-parse-primary))))