Plan v2: Fix #4088 — Default Arguments as Type-Level Method Overloads

[SeanTAllen]

Change classification: Fixed (bug fix) and Changed (breaking subtyping change) for issue #4088. Requires a release notes file and both changelog - fixed and changelog - changed PR labels. Since this is multi-type, the CHANGELOG is updated manually after merge.

Supersedes: Plan v1, which scoped out interfaces/traits.

Mental Model

Default arguments are not call-site syntactic sugar. They are type-level method overloads: a method declaration f(x: A = expr) on a type is equivalent to that type providing two methods:

f(x: A)       // the real method
f() { f(expr) }  // a reduced-arity overload that fills in the default

Each type carries its own reduced-arity methods with its own defaults. At runtime, vtable dispatch picks the concrete type's overload, ensuring the correct defaults are applied regardless of how the call site sees the receiver — union, intersection, interface, or trait.

Problem

The current compiler treats defaults as call-site sugar: apply_default_arg() extracts the default from whichever method lookup() finds and splices it into the call AST. For abstract receivers:

• Union/intersection types: lookup_union()/lookup_isect() picks a "representative" method. All members silently get the representative's defaults at runtime.
• Interface/trait types: lookup_nominal() finds the interface's own method. The interface's default is used, even when the concrete type declares a different one.

Both are wrong under the new model. Each concrete type should use its own defaults.

Approach: Shim Functions via Selector Coloring

For each concrete type with defaulted parameters, create per-concrete-type "shim" methods with reduced arity. These shims:

1. Accept only the explicitly-provided arguments
2. Fill in the correct per-type defaults for the remaining parameters
3. Call the real full-arity method with all arguments

The shims participate in selector coloring (paint.c) and get their own vtable slots. At the call site, a reduced-arity call dispatches through the shim's vtable slot, ensuring each concrete type uses its own defaults at runtime.

Scope

• In scope: Union types, intersection types, interfaces, traits, functions, behaviors
• Limitation: Named arguments that skip middle defaulted parameters are not handled by shims (see Appendix: Non-Trailing Default Gaps). For this pattern on abstract type calls, if defaults differ across members, an error is emitted.

Subtyping Change (Breaking)

Under the new model, if an interface declares fun foo(x: U32 = 1), it means callers of the interface may call foo() with no arguments. Any type claiming to implement this interface must therefore be able to handle a zero-argument foo() call — which means it must have its own default for x.

Current behavior (broken):

interface Configurable
  fun config(verbose: Bool = false): String

class Quiet
  fun config(verbose: Bool): String => "quiet"  // no default

let c: Configurable = Quiet  // ← currently allowed
c.config()  // silently uses interface's default (false)

New behavior:

let c: Configurable = Quiet  // ← compile error: Quiet doesn't provide config()

Quiet doesn't satisfy Configurable because Configurable requires both config(Bool): String and config(): String, but Quiet only provides the first.

Rule: When checking if method sub is a subtype of method super, if super has a default at parameter position i, then sub must also have a default at position i. The default expressions need not be identical — each type provides its own. What matters is that the sub method can handle the same reduced arities as the super method.

This check lives in is_reified_fun_sub_fun(), which is called from multiple places:

• Structural subtyping (interface/trait conformance): the primary intended use. is_nominal_sub_structural() calls is_fun_sub_fun() → is_reified_fun_sub_fun().
• Union/intersection lookup: lookup_union()/lookup_isect() call is_subtype_fun() → is_reified_fun_sub_fun() when selecting the representative method. The effect is beneficial: when one member has foo(x: U32 = 1) and another has foo(x: U32), the defaultless method becomes the representative (it's the supertype). This means apply_default_arg() correctly fails with "not enough arguments" rather than silently using the wrong default. The new check doesn't create problems here — it refines representative selection in the right direction.

The expr pass validation (check_union_defaults() in Step 2) provides better error messages for union/intersection cases. Since it runs BEFORE check_arg_types() (which calls apply_default_arg()), the custom error fires first. But even without it, the subtyping-influenced representative selection would produce a correct (if less descriptive) error.

Implementation Steps

Step 1: Subtyping — Require Matching Defaults (subtype.c)

Goal: When checking method subtyping, verify that the sub method has defaults wherever the super method has defaults.

Changes in is_reified_fun_sub_fun() (subtype.c:243-397):

After the existing contravariant parameter type check loop (lines 348-381), add a second pass over the parameter lists to check default argument compatibility:

// Default argument compatibility.
// If the super method has a default at position i, the sub method must also
// have a default at position i.
sub_param = ast_child(sub_params);
super_param = ast_child(super_params);

while((sub_param != NULL) && (super_param != NULL))
{
  ast_t* super_def = ast_childidx(super_param, 2);
  ast_t* sub_def = ast_childidx(sub_param, 2);

  if((ast_id(super_def) != TK_NONE) && (ast_id(sub_def) == TK_NONE))
  {
    if(errorf != NULL)
    {
      const char* name = ast_name(ast_child(super_param));
      ast_error_frame(errorf, sub,
        "parameter '%s' must have a default argument: "
        "the supertype provides a default", name);
    }
    return false;
  }

  sub_param = ast_sibling(sub_param);
  super_param = ast_sibling(super_param);
}

This is the minimal, correct check. It answers: "can every call that works on the super type also work on the sub type?" If the super declares a default, callers may omit that argument, so the sub must be able to handle that omission too.

Reification preserves defaults: is_reified_fun_sub_fun() works on reified copies created by reify_method_def() (reify.c:239). That function's dup_child array marks params (index 3) as true, so default argument nodes (child 2 of each param) are preserved in the reified copy. Confirmed by reading the code.

No changes to is_fun_sub_fun(): The parameter count check at line 466 remains the same. Both methods have the same total parameter count; what changes is which parameters have defaults.

Step 2: Annotate Call Sites (expr pass — call.c)

Goal: Detect when default arguments are applied on an abstract receiver, validate compatibility, and annotate the call AST for codegen.

Changes in method_application() (call.c:610-668):

After extend_positional_args() and apply_named_args() but BEFORE check_arg_types():

1. Guard: only proceed if !partial. For partial application, TK_NONE args represent unfilled positions, not default-needing positions.

2. Count how many positional args are still TK_NONE (need defaults).

3. If there are TK_NONE args, determine whether the receiver is abstract:

   • Get receiver type via method_receiver_type(lhs). Note: this function only digs through TK_FUNREF/TK_FUNAPP/TK_FUNCHAIN, but it works for TK_BEREF calls too — the receiver is the direct first child for behavior references, so no dig-through is needed.
   • For TK_UNIONTYPE or TK_ISECTTYPE: abstract.
   • For TK_NOMINAL: check ast_id((ast_t*)ast_data(r_type)) — abstract if TK_INTERFACE or TK_TRAIT.

4. If the receiver is abstract and there are TK_NONE args:
   a. For TRAILING defaults only (all TK_NONE args at the end): record the explicit arg count for shim dispatch.
   b. For NON-TRAILING defaults (gaps from named args): check whether all members have the SAME default expression for each gap. If they differ, emit an error. If they're the same, proceed normally.

5. After check_arg_types() succeeds, annotate the TK_CALL node: ast_setdata(ast, (void*)(uintptr_t)(explicit_count + 1)). The +1 distinguishes "0 explicit args" from "no annotation" (NULL). Note: treecheckdef.h must be updated to add HAS_DATA to the TK_CALL rule so the tree checker doesn't flag this annotation as an error.

   Interaction with check_arg_types(): By the time codegen runs, apply_default_arg() (called from check_arg_types()) has already spliced the representative's default expressions into the positional args AST — all N args are present. The annotation tells codegen to generate only the first explicit_count args and dispatch through the shim, which fills in the correct per-type defaults. The representative's defaults remain in the AST for type-checking purposes only.

Validation for unions/intersections: New helper check_union_defaults() iterates members, looks up the method on each via lookup(), and validates defaults at the specified positions. Error conditions:

• Member lacks a default at a trailing position: "cannot omit argument '%s': not all members of the union/intersection provide a default"
• Non-trailing gap with differing defaults: "cannot omit argument '%s': members of the union/intersection have different defaults for this parameter"

Validation for interfaces/traits: The subtyping check (Step 1) already ensures all implementors have defaults wherever the interface does. No additional validation needed at the call site — if the code type-checks, all concrete types that could be dispatched have compatible defaults.

Step 3: Create Shim Methods (reach pass — reach.c)

Goal: For each concrete type that participates in abstract type dispatch and has defaulted parameters, create shim reach_method_t entries with reduced arity.

Two creation points:

a. Concrete subtype shims: New function add_default_shim_to_subtype() — called from add_rmethod_to_subtype() after creating the normal forwarding method. For each concrete subtype:

1. Look up the concrete type's OWN method definition via lookup().
2. Inspect parameters for defaults (child index 2 of each TK_PARAM: TK_SEQ if default exists, TK_NONE if not).
3. Skip parameters where the default is TK_LOCATION (__loc). Since __loc expands to the call-site location, all members produce the same value — no shim is needed.
4. For each valid trailing reduced arity k (from total_params - 1 down to first non-defaulted param, excluding TK_LOCATION defaults):
   • Allocate a new reach_method_t with param_count = k.
   • Copy only the first k entries from the parent method's params array (abstract type's param types, for consistent mangled names).
   • Compute mangled_name via make_mangled_name().
   • Compute name (genname) via genname_fun_shim(): "{cap}_{method_name}[_TypeArgs]$d{k}".
   • Set forwarding = true and default_shim = true.
   • Set fun = deferred_reify_dup(m->fun) (required for make_prototype()/make_signature()).
   • Set result = m->result (the abstract type's result type, matching the pattern used for forwarding methods — ensures consistent mangled names across all concrete types).
   • Add to BOTH r_methods (for lookup) and r_mangled (for painting).

b. Abstract type shims: New function add_default_shims_to_abstract() — called from add_rmethod() after add_rmethod_to_subtypes() completes, for all abstract types (TK_UNIONTYPE, TK_ISECTTYPE, TK_INTERFACE, TK_TRAIT). For each valid trailing reduced arity k:

• Create a shim reach_method_t without forwarding or default_shim flags (abstract types don't get bodies).
• Set fun = deferred_reify_dup(m->fun) (required for make_prototype()).
• Add to BOTH r_methods and r_mangled.
• Uses same mangled_name as concrete subtypes' shims → same vtable slot.

New field on reach_method_t: bool default_shim. Initialized to false by existing memset(0, ...). Set to true only on concrete subtype shim methods.

New function in genname.c: genname_fun_shim(cap, name, typeargs, arity) → "{cap}_{name}[_TypeArgs]$d{arity}".

New lookup function: reach_method_shim() — mirrors cap normalization from reach_method(), computes shim genname via genname_fun_shim(), looks up in r_methods.

Step 4: Paint Phase — No Changes Needed

Shims have different mangled names from full methods → separate vtable slots. All concrete types' shims for a given arity share the same mangled name → same vtable slot. The painting algorithm handles this automatically.

Step 5: Codegen — Function Signatures (genfun.c) — No Changes Needed

make_signature() and make_prototype() use m->param_count and m->params. Shims with reduced values get correct LLVM signatures automatically.

Step 6: Codegen — Shim Body Generation (genfun.c)

New function: genfun_default_shim() — modeled on genfun_forward(). Called from genfun_method() when m->default_shim is true (checked BEFORE m->forwarding).

Generates a shim body on a concrete type:

1. Look up the REAL method: reach_method(t, m->cap, n->name, m->typeargs) → full-arity method.
2. Get default expressions from concrete type's method AST: m_real->fun->ast → ast_childidx(method_ast, 3).
3. Start function with codegen_startfun(c, c_m->func, ..., m_real->fun, ...). Pass the REAL method's deferred_reification_t for correct type parameter mappings. Note: name_params() (genfun.c:58-83) iterates the params AST using m->param_count as the loop bound. Since m->fun->ast has the full-arity param list but m->param_count = k, the loop safely walks only the first k children — this works because ast_sibling() traversal doesn't depend on total child count.
4. Build args buffer (m_real->param_count + 1):
   • args[0] = receiver (pass through)
   • args[1..m->param_count] = explicitly-provided params (pass through with casts)
   • args[m->param_count+1..m_real->param_count] = defaulted params: apply deferred_reify() on default expression, gen_expr(), cast, free reified AST.
5. Call real method with all args. Cast and return result.

Step 7: Codegen — Call Site Dispatch (gencall.c)

After resolving the method via reach_method(), check the TK_CALL annotation:

uintptr_t shim_data = (uintptr_t)ast_data(ast);
if(shim_data > 0)
{
  size_t explicit_count = shim_data - 1;
  m = reach_method_shim(t, cap, method_name, typeargs, explicit_count);
  pony_assert(m != NULL);
}

Ordering is critical: The shim check and method switch must happen BEFORE the argument buffer allocation (line 772: size_t count = m->param_count + 1) and before the first argument generation loop (lines 776-792). The implementation places the shim check between lines 766 (method resolution) and 772 (buffer allocation), so that m->param_count is already the shim's reduced arity when the buffer is sized and loops are bounded.

• Limit both argument loops to m->param_count. After the expr pass, the positional args AST has ALL N arguments (defaults were spliced in by apply_default_arg()). With a shim, the buffer is sized for k+1 entries. Both while(arg != NULL) loops (lines 779-792 and 881-888) must be changed to also check (size_t)(i - 1) < m->param_count, otherwise they iterate all N AST children and write past the buffer end.
• When shim_data > 0, force is_message = false (shim handles calling the real sender).
• Update can_inline_message_send() defensively: when m->default_shim, use reach_method_shim() for subtype lookup.

Step 8: Handle Behaviors

Same as v1 — shims for behaviors are simple functions that fill in defaults and call the real behavior's sender. No func_handler or add_dispatch_case() needed. Behavior shims automatically become senders through the existing make_prototype mechanism: when ast_id(m->fun->ast) == TK_BE, make_prototype generates a sender prototype (with _send suffix). Since m->forwarding = true, handler creation is suppressed — this follows the same pattern as genfun_forward() for behavior forwarding methods.

Step 9: Partial Application

Unaffected. The !partial guard in Step 2 prevents annotation. Partial application on abstract types with differing defaults remains out of scope.

Step 10: Tests

Good Pony (should compile):

1. Union with different trailing defaults — basic Type unions: default arguments applied to the wrong function #4088 case
2. Union with same defaults
3. Union with multiple defaulted params, varying arities
4. Intersection type with different defaults
5. NEW: Interface with different defaults from implementor — shim dispatch gives concrete type's default
6. NEW: Trait with different defaults from implementor
7. NEW: Generic method with type-parameter-referencing default (e.g., fun foo[A: Stringable val](x: (A | None) = None)) — exercises the deferred reification path in shim codegen

Bad Pony (should error):

8. Union with partial defaults (one member lacks default) — error at call site
9. Named args skipping middle default with differing defaults — error at call site
10. NEW: Class implementing interface but missing a default the interface requires — subtyping error

Behavior tests:

11. Actor union with different behavior defaults
12. NEW: Actor implementing interface with different behavior defaults

Step 11: Build and Run Tests

make test-ci

Step 12: Release Notes

Create a release notes file. This is both a bug fix (union/intersection defaults) and a breaking change (subtyping now requires matching defaults). Since both changelog - fixed and changelog - changed apply, the CHANGELOG is updated manually after merge.

The release note should describe:

• Fixed: Default arguments on union/intersection/interface/trait calls now dispatch to the correct per-type default at runtime
• Changed: Types implementing an interface or trait that declares default arguments must now provide their own defaults for those parameters (breaking)

Files Modified

File	Changes
src/libponyc/type/subtype.c	Default compatibility check in is_reified_fun_sub_fun()
src/libponyc/expr/call.c	Annotate TK_CALL for abstract receivers (union, intersection, interface, trait); new check_union_defaults()
src/libponyc/ast/treecheckdef.h	Add HAS_DATA to TK_CALL rule
src/libponyc/reach/reach.h	Add bool default_shim; declare reach_method_shim()
src/libponyc/reach/reach.c	Shim creation functions; shim lookup
src/libponyc/codegen/genname.h	Declare genname_fun_shim()
src/libponyc/codegen/genname.c	New genname_fun_shim()
src/libponyc/codegen/genfun.c	New genfun_default_shim() body generator
src/libponyc/codegen/gencall.c	Shim dispatch in gen_call(); update can_inline_message_send()
test/libponyc/badpony.cc	Error tests
test/libponyc/goodpony.cc	Compilation tests

---

Appendix: Non-Trailing Default Gaps

Shims work by reduced arity — a shim for arity k accepts the first k positional arguments and fills in defaults for the rest. This naturally handles trailing defaults (omitting arguments from the end), but not non-trailing gaps where named arguments skip over middle defaulted parameters.

Example

class A
  fun foo(x: U32, y: U32 = 10, z: Bool = true) => None

class B
  fun foo(x: U32, y: U32 = 20, z: Bool = false) => None

actor Main
  new create(env: Env) =>
    let ab: (A | B) = A
    ab.foo(42 where z = true)  // provides x and z, skips y

After apply_named_args(), the positional argument list is [42, TK_NONE, true] — there's a gap at position 1 (y), not at the trailing end. No single arity value represents "provided x and z but not y":

• A shim for arity 1 accepts just (x) and fills in both y and z
• A shim for arity 2 accepts (x, y) and fills in just z
• Neither matches "provided x and z, fill in y"

Why shims don't cover this

Handling arbitrary subsets of defaulted parameters would require either:

• Combinatorial shims: One shim for every possible subset of defaulted parameters. For a method with d defaulted parameters, that's 2^d - d - 1 additional shims beyond the trailing ones (exponential growth).
• Bitmask dispatch: A mechanism to encode which specific parameters were omitted, dispatching to the right shim via a bitmask rather than a simple arity count. This would require changes to the vtable structure.

Neither is justified for what is an uncommon calling pattern.

Current behavior

When a non-trailing gap is detected on an abstract type call:

• If all members have the same default for the gap position: the shared default is correct, no shim needed.
• If members have different defaults for the gap position: error emitted. The programmer can provide the argument explicitly to resolve it.

This is an improvement over the current silent wrong-default behavior.