Plan: Fix #4088 — Default Argument Dispatch on Abstract Types

[SeanTAllen]

Change classification: Fixed (bug fix) for issue #4088. Requires a release notes file and changelog - fixed PR label.

Problem

When calling a method on an abstract type (union, intersection) with omitted arguments, the compiler fills in defaults from a single "representative" method chosen by lookup_union() / lookup_isect(). At runtime, the actual concrete type may have different defaults. The representative's defaults are used for all members — silently applying the wrong defaults or compiling code that should fail.

The same issue exists for interfaces/traits when the interface declares a default that differs from a concrete implementation's default. However, when calling through an interface, using the interface's own default is the expected behavior (the interface defines the behavioral contract). This fix focuses on union and intersection types, where there is no single canonical declaration.

Approach: Selector Coloring with Shim Functions

For each concrete type that participates in a union/intersection and has 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 (the paint.c algorithm) 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, functions and behaviors
• Out of scope: Interfaces/traits called directly (current behavior of using the interface's own default is correct and well-defined)
• Limitation: Named arguments that skip middle defaulted parameters are not handled by shims (see Appendix: Non-Trailing Default Gaps). For this pattern on union/intersection types, if defaults differ across members, an error is emitted. This is an improvement over the current silent wrong-default behavior and can be extended later.

Implementation Steps

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

Goal: Detect when default arguments are applied on a union/intersection receiver, validate that all members have compatible defaults, and annotate the call AST for later use by codegen.

Changes in method_application():

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

1. Guard: only proceed with union/intersection default handling if !partial. For partial application (partial = true), TK_NONE args represent unfilled positions, not default-needing positions — check_arg_types() skips them. Annotating partial application calls would cause incorrect shim dispatch at codegen time.
2. Count how many positional args are still TK_NONE (need defaults).
3. Determine the receiver type via method_receiver_type(lhs).
4. If the receiver is TK_UNIONTYPE or TK_ISECTTYPE and there are TK_NONE args:
   a. For TRAILING defaults only (all TK_NONE args are at the end of the positional list): record the explicit arg count. This will use the shim path.
   b. For NON-TRAILING defaults (gaps due to named args skipping middle params): check whether all members have the SAME default expression for each gap position. If they differ, emit an error. If they're the same, proceed normally (the shared default is correct for all members).
5. After check_arg_types() succeeds (which fills in defaults from the representative for type-checking), annotate the TK_CALL node with the explicit arg count using ast_setdata(ast, (void*)(uintptr_t)(explicit_count + 1)). The +1 distinguishes "0 explicit args" from "no annotation" (NULL data).

check_arg_types() is unchanged — it still fills in defaults from the representative method for type-checking. The annotation is what tells codegen to dispatch through a shim instead of the full method.

New helper function: check_union_defaults() — iterates union/intersection members, looks up the method on each via lookup(), and validates that all members have defaults at the specified parameter positions. Two distinct error conditions:

• If any member LACKS a default at a trailing position: "cannot omit argument '%s': not all union members provide a default"
• If all members have defaults at a non-trailing (gap) position but the defaults DIFFER: "cannot omit argument '%s': union/intersection members have different defaults for this parameter"

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

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

Two creation points for shims — one for concrete subtypes, one for the abstract type itself:

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. Looks up the concrete type's OWN method definition via lookup().
2. Inspects parameters for defaults (third child of each TK_PARAM is TK_SEQ if a default exists, TK_NONE if not).
3. Skips 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. If a parameter has TK_LOCATION on some members but a non-TK_LOCATION default on others, the __loc members are treated as not having a default for shim purposes (error in the expr pass).
4. For each valid trailing reduced arity k:
   • 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, ensuring consistent mangled names across all concrete types).
   • Compute mangled_name via make_mangled_name() — naturally different from the full method since it encodes fewer param types.
   • Compute name (genname) via new genname_fun_shim(): "{cap}_{method_name}[_TypeArgs]$d{k}". The $d{k} suffix distinguishes shims from real methods. The $ character is not valid in Pony identifiers, preventing collisions (it already appears in compiler-generated hygienic IDs).
   • Set forwarding = true and new default_shim = true flag.
   • Set fun = deferred_reify_dup(m->fun) — required because make_prototype() and make_signature() access m->fun->ast to determine method kind. Without valid fun, these crash.
   • 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, conditioned on the type being abstract. 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 — genfun_method_bodies() skips them).
• Set fun = deferred_reify_dup(m->fun) — required because make_prototype() accesses m->fun->ast BEFORE the trait early return.
• This entry exists solely for call-site vtable slot lookup and painting.
• Uses same mangled_name as concrete subtypes' shims → same vtable slot.
• Add to BOTH r_methods and r_mangled.

New field on reach_method_t: bool default_shim. Initialized to false by existing memset(0, ...). Explicitly set to true only on shim methods. No serialization code exists for reach_method_t — it is transient.

No collision: Shim genname (box_foo$d2) differs from real method genname (box_foo). Shim mangled name (e.g., box_foo$d2_U32_None) differs from real method mangled name (e.g., box_foo_U32_String_None).

Step 3: Paint Phase — No Changes Needed

Shims have different mangled names from full methods, so they automatically get 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 4: Codegen — Function Signatures (genfun.c)

No changes needed. Existing infrastructure (genfun_allocate_compile_methods, genfun_method_sigs, make_signature, make_prototype) uses m->param_count and m->params to build LLVM function types. Shims with reduced param_count and params get correct signatures automatically.

Step 5: 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. Generates a shim body on a concrete type:

1. Look up the REAL method on the concrete type: reach_method(t, m->cap, n->name, m->typeargs). Returns the full-arity method.
2. Get the concrete type's method AST for default expressions: m_real->fun->ast → ast_childidx(method_ast, 3).
3. Start the function with codegen_startfun(c, c_m->func, ..., m_real->fun, ...). Pass the REAL method's deferred_reification_t so c->frame->reify has correct type parameter mappings — critical for generic methods.
4. Allocate args buffer of size m_real->param_count + 1.
5. Pass through receiver: args[0] = LLVMGetParam(c_m->func, 0).
6. For explicitly-provided params (i = 0 to m->param_count - 1): pass through from shim parameters with type casts.
7. For defaulted params (i = m->param_count to m_real->param_count - 1):
   • TK_LOCATION defaults are never reached (excluded from shim creation in Step 2).
   • Apply deferred reification: deferred_reify(m_real->fun, def_arg, opt) — substitutes type parameters with concrete types.
   • Generate LLVM IR: gen_expr(c, reified_def).
   • Cast to real method's param type; free reified AST.
8. Call the real method with all N arguments.
9. Cast and return the result.

Default expression codegen safety: Default expressions are self-contained (no references to other params), typically literals/primitives/constructors. Method AST has been through all passes. gen_expr() works because the shim has a valid function context, module globals, and receiver. Deferred reification handles generic defaults.

Integration with genfun_method(): default_shim check goes BEFORE forwarding check (shims have both flags).

Step 6: 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);
}

Both argument loops must be limited to m->param_count:

1. Value generation loop: stop after m->param_count args
2. Type casting loop: stop after m->param_count args, use shim's func_type

Message send path must be skipped: When shim_data > 0, force is_message = false. The shim handles calling the real sender internally.

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 7: Handle Behaviors (actor message sends)

Shims for behaviors are simple functions (NOT sender/handler pairs) that fill in defaults and call the real behavior's sender:

1. Caller dispatches through shim vtable slot → calls shim function
2. Shim fills in defaults → calls real sender (c_m_real->func)
3. Real sender packs all N args into message → sends to actor mailbox
4. Actor processes message → dispatches to real handler as normal

No func_handler or add_dispatch_case() needed. Follows the genfun_forward() pattern for behaviors.

Prototype naming: When m->fun->ast is TK_BE, make_prototype() generates a sender prototype (appending _send). Shims use this too since m->forwarding = true suppresses handler creation.

can_inline_message_send(): Updated defensively — when m->default_shim is true, uses reach_method_shim() to find matching shim on concrete types. In practice, this path is skipped because is_message = false for shim dispatch.

Step 8: Partial Application

Unaffected. Partial application creates closures at the expression level. The shim annotation logic is guarded with !partial (Step 1). Fixing partial application with per-type defaults would require runtime closure dispatch — out of scope.

Step 9: 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

Bad Pony (should error):

5. Union with partial defaults (one member lacks default) — error: "cannot omit argument 'y': not all union members provide a default"
6. Named args skipping middle default with differing defaults

Behavior tests:

7. Actor union with different behavior defaults

Step 10: Release Notes

Create a release notes file. Bug fix classification. changelog - fixed label.

Files Modified

File	Changes
src/libponyc/expr/call.c	Annotate TK_CALL; new check_union_defaults()
src/libponyc/reach/reach.h	Add bool default_shim; declare reach_method_shim()
src/libponyc/reach/reach.c	New shim creation functions; new 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. Named arguments that skip middle parameters are rare in practice — most default-argument usage either omits trailing arguments or provides all arguments explicitly.

Current behavior

When a non-trailing gap is detected on a union/intersection call:

• If all members have the same default expression for the gap position, the shared default is correct for all members and no shim is needed — the representative's default works.
• If members have different defaults for the gap position, an error is emitted: "cannot omit argument '%s': union/intersection members have different defaults for this parameter".

This is an improvement over the current behavior, which silently applies the representative's default regardless of which concrete type is dispatched at runtime. The error makes the incompatibility visible; the programmer can provide the argument explicitly to resolve it.

[SeanTAllen]

Design Revision: Defaults as Type-Level Method Overloads

After discussion, we're revising the mental model for default arguments. Instead of treating defaults as call-site syntactic sugar, we treat them as defining reduced-arity methods on the type itself:

f(x: A = expr)

is sugar for:

f(x: A)

f()
{
  f(expr)
}

Each type carries its own reduced-arity method that knows its own defaults. Dispatch through vtables naturally gives you the right defaults for the concrete type, regardless of how the call site sees the receiver (union, intersection, interface, or trait).

Impact on Interfaces/Traits

The original plan scoped out interfaces/traits, arguing that using the interface's own default was correct behavior. Under the new model, that's wrong — the interface's default is just the interface's own reduced-arity overload, but vtable dispatch should pick the concrete type's overload at runtime.

interface Greetable
  fun greet(name: String, greeting: String = "hi"): String

class Formal
  fun greet(name: String, greeting: String = "Good day"): String =>
    greeting + ", " + name

let g: Greetable = Formal
g.greet("Sean")  // Current behavior: "hi, Sean" (interface's default)
                  // New model: "Good day, Sean" (Formal's default)

Impact on Subtyping

If fun foo(x: U32 = 1) means the type provides both foo(x: U32) and foo(), then structural subtyping must account for reduced-arity methods:

interface Greetable
  fun greet(greeting: String = "hi"): String

class Formal
  fun greet(greeting: String): String => greeting  // no default

Currently Formal is a valid Greetable. Under the new model, Greetable effectively requires both greet(String): String AND greet(): String. Formal only provides the first, so it would not satisfy Greetable — it can't handle a g.greet() call because it has no default to fill in.

This is a breaking change, but arguably the current behavior is already broken: Formal satisfies Greetable today, but calling g.greet() through the interface silently uses "hi", which Formal never agreed to.

Requiring defaults on implementors makes the contract honest — each type is responsible for its own reduced-arity behavior.

Next Step

A revised plan incorporating this broader model follows.