Don't emit named-arg values in bindInvokable, so generic helpers can't collapse curried types

[BoussonKarel]

Problem

A generic helper that returns a function, used as a named arg of {{component}}/{{helper}}/{{modifier}}, breaks the curried value's type. ember-set-helper's (set this "el") is the common case:

declare function setter<T extends object, K extends keyof T & string>(
  target: T,
  path: K,
): (value?: unknown) => T[K];

export class YieldCase extends Component<{
  Blocks: { default: [WithBoundArgs<typeof myModifier, 'onCreate'>] };
}> {
  el: HTMLElement | null = null;
  <template>{{yield (modifier myModifier onCreate=(setter this "el"))}}</template>
}

error TS2345: Argument of type '(element: HTMLElement, named: NamedArgs<{ onCreate: … }>) => ModifierReturn'
is not assignable to parameter of type '(element: HTMLElement, named?: PrebindArgs<{ onCreate: … }, "onCreate"> | undefined) => ModifierReturn'.

• The same bind through {{#let}} doesn't error. That's only because its type has collapsed to Invokable<(...args: unknown[]) => unknown>, which accepts anything.
• onCreate=this.onCreate (not generic) works.
• This worked on @glint/ember-tsc 1.0.7 / @glint/template 1.7.2. It fails on 1.11.x / template 1.9.0.

Root cause

Since #1078 (fix for #1068, released in @glint/ember-tsc 1.2.3 / @glint/template 1.7.7), a curried keyword with named args emits a comma pair:

(resolve(modifier)((() => resolveForBind(myModifier))(), { onCreate: setter(this, "el") }),
 bindInvokable(resolveForBind(myModifier), { onCreate: setter(this, "el") }))

During its first inference pass, TypeScript skips any argument that is a call to a generic function returning a function (SkipGenericFunctions). setter(...) is such a call, and so is resolveForBind(...). With both skipped, bindInvokable infers none of its type parameters, and the result collapses to Invokable<(...args: unknown[]) => unknown>. When the value is yielded against WithBoundArgs, Args gets inferred from the expected type instead, and the modifier fails against it.

This is the mechanism behind #1147. The fix there only covered fn, by swapping it for the non-generic bindPositional inside bindInvokable. Any other helper with this shape still broke it.

It isn't caused by ember-set-helper's loose (value?: unknown) => T[K] return type. Before this change, all of these fail the same way:

hash value	fails before
ember-set-helper's real signature	yes
accurate overloads ((value: T[K]) => void / () => void)	yes
strict (value: T[K]) => void	yes
unconstrained <T>(x: T) => (e: HTMLElement) => void	yes
generic helper returning a non-function (string)	no
non-generic helper returning a function	no

Fix

bindInvokable only reads the keys of its named args (keyof GivenNamed). The keyword call in the other half already validates the values, with the invokable's arg types as context. So the bindInvokable half now emits a placeholder for each value:

bindInvokable(resolveForBind(myModifier), { onCreate: boundArg, ...NamedArgsMarker })

As a result, fn's bindPositional special case can't be reached anymore, so it's removed. fn now always emits a plain call, which keeps the #1247 contextual typing.

Tests

• New test-packages/ts-gts-7-1-app/src/bind-generic-helper-arg.test.gts covers:
  • a generic helper in a yielded (modifier), and the same through (component)
  • the {{#let}} case, which now asserts the curried value keeps its type
  • a non-generic function
  • a mismatched generic helper, which must still be rejected
• Transform snapshots are updated.
• The {{component}} with named args on generic class components produces TS2589 #1068, Type inference error in (component) helper when pre-binding optional union arguments #1144, Issues with fn helper in combination with component helper #1147 and {{fn}} with a generic callback no longer infers from the arg's type (regression from #1189) #1247 regression tests still pass.

🤖 Generated with Claude Code