LANG: \Mod::fn(x)\ value call unwired in expression position (\.\-form fixed by #253; \::\ residual)

[hyperpolymath]

Updated 2026-05-19 — scope narrowed. The originally-reported .-form
is fixed; this issue now tracks only the distinct :: residual.

Fixed (not this issue any more)

use Mod; (or use Mod as M;) + .-qualified value call Mod.fn(x) /
M.fn(x) now resolves + typechecks — wired by #253 (merged): the pure
parse-boundary lowering Resolve.lower_qualified_value_paths rewrites
ExprField(ExprVar m, fld) → ExprVar fld when m is an ImportSimple
qualifier. Regression-locked by the "E2E Qualified Value #178" suite.

Remaining (this issue)

Mod::fn(x) in expression position is a parse error: :: is
reserved for Type::Variant in expressions, so the ::-qualified
value call form never parses (the .-form is what the lowering
handles). ADR-014 makes :: the canonical type/effect separator; the
value-expression :: path is the matching surface gap.

Options: (a) accept Pkg::fn in expression position in the grammar and
fold it into the same lowering; (b) doctrine: .-form is the canonical
value-qualifier surface and :: stays type/effect-only.

Refs #228 (ADR-014), #253 (the .-form fix), #178 (INT-01).

[hyperpolymath]

Verification 2026-06-11 — closing recommended

Re-probed against affinescript HEAD (post-#523):

Probe	Result
use Mod; Mod::fn(x) (UpperCase head)	✅ Type checking passed
use mod; mod::fn(x) (lowercase head — covered by #523 / #448 item 1)	✅ parses + type-checks
End-to-end: use math; math::abs(-5) + Deno-ESM compile + deno run	✅ runs; emitted JS strips the qualifier (const x = abs(-5);)
Int::to_string(n) / String::len(s) (builtin-type qualified)	✅ parses + resolves (line 920-948 of parser.mly)

The :: value-call form is wired end-to-end:

• Parser (parser.mly:909 INT-01 follow-up): upper_ident COLONCOLON lower_ident → ExprField (ExprVar Mod, lower_ident), plus the builtin-type variants at lines 920-948 and the lowercase-head extension from feat(parser): accept lower_ident head in qualified_type_name (closes #448 item 1) #523.
• Resolver (Resolve.lower_qualified_value_paths, INT-01: cross-module WASM import emission (substrate) #178/feat(resolve): INT-01 — wire qualified-value path use Mod; Mod.fn(x) #253): rewrites ExprField(ExprVar m, fld) → ExprVar fld when m is an ImportSimple qualifier — handles both .-form and ::-form identically.
• Codegen: emits a bare reference (no JS-side module access required), so the runtime call lands on the imported binding directly.

Remaining adjacent gap (NOT this issue)

Multi-segment qualified value paths like Mod::Sub::fn(x) still parse-error:

pub fn f() -> Int { Mod::Sub::fn(1) }   # parse error at col 26
use Mod::Sub; ...                        # parse error at col 8 (the second ::)

That's the same adjacency tracked in #448 items 2-3 (multi-segment use, brace-list at multi-segment depth), which was closed earlier as a deferred-by-design slice. If multi-segment value paths become a blocker for a real consumer port, file a fresh issue scoped to that specifically.

Separately observed during the probe: math::min_int resolved-error because min_int isn't pub-marked on the current HEAD of stdlib/math.affine. That gap is what affinescript#546 (the pub-mark sweep for io/math/option/result/testing) closes — orthogonal to #249.

Recommendation

Close #249. The single-segment Mod::fn(x) value-call form this issue tracks is fully wired and regression-locked by the "E2E Qualified Value #178" suite.

🤖 Cross-estate AS-status sweep on 2026-06-11.