feat: add struct definitions with field access and assignment 🏗️

[timfennis]

Context

While attempting to implement an advent of code puzzle I needed access to linked lists because currently that can only be emulated with maps which is cumbersome to read and write. This PR is a step in the right direction, but since self references are not allowed yet it doesn't really solve the problem 🪦.

What this adds

struct Point { x: Int, y: Int }

let p = Point(1, 2);   // positional constructor
p.x                    // getter — exactly `x(p)`, nothing special
p.x = 10;              // setter — calls the `x=` binding
p.x += 5;              // augmented, receiver evaluated once

• Lexer/parser/AST — struct keyword, field declarations with required type
  annotations, trailing commas allowed.
• StructRegistry in ndc_core — owns StructInfo; shared by the analyser and
  compiler via Rc<RefCell<…>> so the REPL keeps struct definitions across lines.
• Accessors are ordinary function values. A declaration binds a constructor, plus a
  getter and setter per field. Identity is nominal: two structs with an x field produce
  two distinct getters, so overload resolution picks the right one.
• Expression::MemberAccess — p.x is its own AST node rather than a desugared call,
  while p.x() still lowers to x(p). This is what makes assignability decidable at
  parse time: p.x = v is valid, p.x() = v is not.
• VM — Object::Struct plus Function::{Constructor, GetField, SetField}, all
  completing inline without pushing a frame.
• Editor support — tree-sitter grammar and corpus tests, TextMate grammar, and LSP
  document symbols, inlay hints and go-to-definition.
• Struct names are types. fn dist(p: Point), let p: Point = ...,
  struct Line { a: Point }, and List<Point> all resolve (built on the TypeExpr
  refactor from refactor(parser): resolve type annotations in the analyser 🧭 #198; built-in names take precedence). Struct names are globally
  unique — redeclaration is an analysis error — and the analyser checkpoint rolls the
  registry back, so a failed REPL line frees its struct names.

Bugs found while building this

Three panics, two of which predate the branch:

• Passing a constructor or accessor to a HOF (points.map(x)) corrupted the VM stack and
  overran the chunk. call_callback assumed every dispatch pushed a frame; dispatch now
  reports which happened. This also fixes pure fn as a HOF callback, which hit
  unreachable! on master.
• let l[0] = 5 panicked in the compiler (pre-existing) and let p.x = 5 in the
  analyser. Both are write targets, not new bindings — now rejected while parsing.
• Hashing a field accessor hit todo!(), so %{x: 1} aborted.

Notes for reviewers

• Dispatch enum touches all call dispatch. dispatch_call now returns
  FramePushed / Completed. Shape follows Lua's luaD_precall.
• Augmented assignment on fields is partial by design. +=, -=, *=, %=, &=,
  |= work; /= and ^= on an Int field are rejected because the operator's result
  type widens to Number — identically to an annotated container
  (let l: List<Int> = [10]; l[0] /= 2 gives the same error). A field is a non-widenable
  typed location, so it lands in the behaviour chore: augmented assignment review follow-ups 🧹 #195 established. Deferred with the rest of
  the subtyping rework, not a new regression. (An earlier revision of this note listed
  -=/&=/|= as rejected too; the Binding::None overload work fixed those.)
• Two commits were cherry-picked from the pre-rebase feature/struct-oops branch, with
  authorship preserved; that branch still holds the old history.
• Earlier commits also changed emit_set_var to bump source_locals on every local store,
  and made produces_value exhaustive instead of _ => true.

Remaining work

• Struct names are not usable as types. Done — see "What this adds". Deferred
  to the subtyping/unification rework: self-referential structs
  (struct Node { next: Option<Node> } errors with unknown type, since usable
  recursion also needs None to be assignable to any Option<T>).
• Manual page. Done — manual/src/reference/types/struct.md covers declaration
  syntax, positional constructors, p.x ≡ x(p), accessors as function values,
  field assignment (including the augmented-assignment rules above), reference
  semantics, nominal equality/hashing, JSON encoding, and current limitations. Every
  code block was executed against this branch.
• to_json on a struct is unreachable. Done — the call itself was already fixed
  by the Binding::None overload work. This branch is now stacked on feat(stdlib): make json_encode strict and add json_encode_lossy 🧊 #199 (strict
  json_encode + json_encode_lossy, targeted at master): the strict json_encode
  rejects structs (a JSON object decodes back to a map, not a struct) and
  json_encode_lossy encodes them as objects with field names as keys.
• Duplicate field names are silently accepted. Done — now an analyser error
  (Illegal redefinition of field 'a' in struct 'Dup'), reported at the duplicate
  field's own span; the declaration is not registered, so the name stays free.
• Constructor arity/type errors are runtime-only. Done, and generally: when every
  same-name candidate is a fully-annotated function and none is compatible with the
  call, resolve_call now reports Binding::None instead of falling back to runtime
  dispatch — so Point(1), Point("x", 2), and dist(Other(1, 2)) all fail at
  compile time. Exposed a latent analyser bug (a map default's type wasn't part of the
  map's value type), fixed alongside.
• Setter Display is indistinguishable from the getter — fixed in refactor(vm): model struct accessors as native function closures 🧩 #201 (stacked
  on this branch): the setter prints <fn Point.x=>.
• Decide on struct Empty { } — decided: allowed. A one-flag parser change
  (delimited_comma_separated(..., allow_empty: true)); the rest of the pipeline
  already handled zero fields (construction, printing as Empty {}, equality,
  hashing, type annotations — covered by 015_struct/024_empty_struct.ndc). The
  tree-sitter grammar already accepted an empty body.
• Test gaps. A setter can't be captured as a value, so its hash tag is untested.
  (Nested field assignment is now covered by 015_struct/012_nested_struct.ndc.)
  Moot after refactor(vm): model struct accessors as native function closures 🧩 #201: the setter-specific hash arm no longer exists.
• Consider modelling constructors and accessors as NativeFunction closures instead of
  three Function variants. Would delete ~9 match arms, the per-dispatch StaticType
  allocation, and the getter/setter Display ambiguity. Done in refactor(vm): model struct accessors as native function closures 🧩 #201, stacked on this
  branch.

Unrelated and pre-existing: cargo clippy --all-features fails to compile because
ndc_vm/src/tracer.rs doesn't cover OpCode::CallVec. CI only builds default features.

🤖

[timfennis]

Is there a way to phrase this with shorter sentences. This is a little rough to read for my pea sized brain.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 434543b0bc

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".