Parse foreign Lua files with the compiler's own Lua 5.1 parser - #197

Closes #173.

What changed

Lua.Linker.Foreign no longer splits an FFI file lexically into text blobs. The whole file goes through a new complete Lua 5.1 parser (Language.PureScript.Backend.Lua.Parser, megaparsec) straight into the backend's Lua AST: header statements and export values become real AST nodes, visible to every Lua-level optimization, and a syntax error anywhere in a foreign file is now a compile-time error instead of a luacheck/runtime one. The balanced-paren scanner and the "wrap every export value in parens" contract are gone; comments are preserved through the existing annotation slots and reattached in the printed output.

To support this, the Lua AST grew the missing Lua 5.1 statement and expression forms (loops, local function, multiple assignment, method calls, varargs, array-part table rows, multi-value return), the printer learned to render nested if/else-of-if chains as elseif, and the runtime fixtures are parsed into the AST instead of being emitted as verbatim text.

Parser design

Operator parsing is a transcription of subexpr from Lua 5.1's own lparser.c, priority table included, so associativity and unary binding levels are pinned to the reference. The parser also matches the reference's rejections, each verified against luac 5.1.5 before the corresponding test was written:

• an argument-list ( on a different line than its callee is "ambiguous syntax (function call x new statement)", with a hint about ;; string and table arguments stay legal across a line break, as in the reference;
• ... outside a vararg function is an error (the main chunk counts as vararg);
• syntactic nesting is capped at 500 levels, above both the reference's 200 and the emitter's own NestingCheck limit of 180: the cap exists only to turn adversarially nested input into a clean parse error instead of a compiler stack overflow.

The one deliberate divergence is rejecting goto as an identifier, which Lua 5.1 itself allows. Note [Parsing foreign Lua sources] records the reason: parsed FFI names and generated names share one output chunk, and that chunk has to stay loadable on LuaJIT and Lua 5.2+, where goto is a keyword.

Verification

A parse . print ≡ id round trip alone cannot see a matched pair of defects, where the parser misreads a construct exactly the way the printer misprints it. The suite therefore anchors to arbiters that cannot share a bug with the printer:

• luac must accept everything the printer emits: a property over generated chunks (with comments), plus a deterministic anchor that feeds every snippet of the hand-written round-trip corpus to luac in both source and printed form (new Differential.Spec, with a Test.Lua helper shared with the golden harness).
• A semantic differential renders a typed, runtime-error-free expression twice, once with the real printer and once with a local renderer that parenthesizes every node, then evaluates and compares the two inside lua itself (NaN accounted for). This is the only check of the precedence and associativity tables against the interpreter rather than against themselves.
• The round-trip property now runs on four page widths (1 / 40 / 80 / unbounded), generates comments into statement and table-row slots, and compares annotations too. The one-column layout is the main stress for ; insertion and hardline comments.
• A new traversal identity property (everywhereStat/everywhereExp with identity must be id, comments included) pins the annotation-threading contract the rewrite rules rely on.
• Deterministic units cover the ; separator, the containsReturn branches of foldFieldProjectionThroughScopeCall, and the parser's number, string, and comment edge cases (exponent padding, \r\n escapes, false long-bracket opens, a comment before elseif blocking resugaring in both directions).

Two printer correctness gaps surfaced by all this and are fixed here: a negative numeric literal now carries unary precedence ((-2) ^ 2 used to print as -2 ^ 2, which Lua reads as -(2 ^ 2)), and a statement whose printed form starts with ( is now separated from the previous statement with ;.

Every golden module's rendered output is additionally re-read by the compiler's own parser inside the golden harness, so the whole corpus doubles as a round-trip fixture.

Coverage

hpc over the full suite: Lua.Parser 100% of top-level definitions, 94% of expressions, 85% of alternatives. The remainder is six unreachable-by-design binOpPriority rows (5.3 operators absent from the grammar) and error-message thunks that tests trigger as branches but never force as strings.

Goldens

35 golden.lua files move structurally (mostly elseif resugaring and comment placement); golden.ir and every eval/golden.txt oracle are untouched, so generated-code semantics are unchanged.