65 lines
2.7 KiB
Markdown
65 lines
2.7 KiB
Markdown
# 0131 — protocol method call with extra arguments compiles and silently drops them
|
|
|
|
## Symptom
|
|
|
|
Calling a protocol method with MORE arguments than the protocol
|
|
declares is accepted by the compiler; the extra arguments are silently
|
|
dropped at the call. Observed: `Allocator.dealloc_bytes` is declared
|
|
`(ptr: *void)`, yet `a.dealloc_bytes(p, 12345)` compiles and runs
|
|
under both `sx run` and `sx build`. Expected: a compile diagnostic
|
|
("expected 1 argument, got 2"), exactly as for plain function calls.
|
|
|
|
Found via std.http (PLAN-HTTPZ S7a): three `dealloc_bytes(ptr, size)`
|
|
calls — written against an imagined two-arg signature — compiled
|
|
clean and survived the full example sweep. Corrected in `81fa50c`;
|
|
this issue is about the missing diagnostic.
|
|
|
|
## Reproduction
|
|
|
|
```sx
|
|
#import "modules/std.sx";
|
|
|
|
main :: () -> i32 {
|
|
gpa := GPA.init();
|
|
a : Allocator = xx gpa;
|
|
p := a.alloc_bytes(64);
|
|
a.dealloc_bytes(p, 12345); // protocol declares (ptr) — must be rejected
|
|
print("compiled and ran\n");
|
|
return 0;
|
|
}
|
|
```
|
|
|
|
Run `sx run repro.sx`: prints "compiled and ran", exit 0. Expected: a
|
|
compile error naming the arity mismatch.
|
|
|
|
## Investigation prompt
|
|
|
|
The sx compiler accepts protocol method calls with extra trailing
|
|
arguments and silently drops them (repro above — `Allocator.
|
|
dealloc_bytes(ptr)` called with `(ptr, extra)` compiles and runs).
|
|
Plain function calls DO arity-check, so the gap is specific to the
|
|
protocol-dispatch call path. Suspected area: the protocol call
|
|
planning/lowering in `src/ir/lower/call.zig` (and/or the protocol
|
|
method resolution in `src/ir/protocols.zig`) — wherever a protocol
|
|
method's parameter list is matched against call-site args, the
|
|
arg-count check that plain calls get is likely skipped, and lowering
|
|
then truncates args to the method's param count. The fix should emit
|
|
the same diagnostic plain calls produce (expected N args, got M) for
|
|
both too many AND verify too few is also caught. Verify with the
|
|
repro (expect a compile error) plus a negative-test example or a
|
|
`call.test.zig` case pinning the diagnostic; then `zig build &&
|
|
zig build test && bash tests/run_examples.sh` all green (existing
|
|
examples must not regress — if any example relied on dropped extra
|
|
args, that example is itself a latent bug to fix in the same
|
|
session).
|
|
|
|
## Resolution
|
|
|
|
RESOLVED (merged master `d7808f6`, 2026-06-12, Agra-directed in-session
|
|
fix). `emitProtocolDispatch` arity-checks exactly (extra AND missing
|
|
args) with the standard "expects N arguments" diagnostic at the call
|
|
span. Regression pinned by examples/1634-protocol-call-arity; sweep
|
|
622/622 + unit tests green — nothing in the tree relied on the
|
|
leniency. The three std.http call sites that exposed the gap were
|
|
corrected separately in `81fa50c`.
|