fix: preserve trailing empty suffix in ɵɵtextInterpolateN calls

[BenjaminDobler]

Summary

ɵɵtextInterpolateN functions in the Angular runtime always require all positional string arguments. The signature follows the pattern:

ɵɵtextInterpolate1(prefix: string, v0: any, suffix: string)
ɵɵtextInterpolate2(prefix: string, v0: any, i0: string, v1: any, suffix: string)
// ... and so on: always N+1 strings interleaved with N expressions

Internally these delegate to interpolationN(lView, prefix, v0, ..., suffix) which concatenates all arguments:

prefix + renderStringify(v0) + suffix

When suffix is omitted in JavaScript, it becomes undefined, and string concatenation produces "undefined" in the output — e.g. #1undefined instead of #1.

Root cause

In reify_interpolation, the trailing string argument is only emitted when it is non-empty or when has_extra_args is true. The InterpolateText call site passed has_extra_args: false, causing the trailing "" to be dropped for templates like #{{ idx }} where:

• strings = ["#", ""] — the prefix is "#", the suffix is ""
• expressions = [idx]

The empty suffix "" was silently dropped, producing ɵɵtextInterpolate1("Remove #", idx) (2 args) instead of the correct ɵɵtextInterpolate1("Remove #", idx, "") (3 args).

The plain {{ expr }} case (no surrounding text) is unaffected — it takes an early-return path that emits ɵɵtextInterpolate(v0) which only takes a single argument.

The Angular compiler always emits the trailing suffix

The official Angular compiler (@angular/compiler) always includes all string segments in textInterpolateN calls, including trailing empty strings. For example, {{ first }} and {{ second }} produces:

ɵɵtextInterpolate2("", ctx.first, " and ", ctx.second, "");

This fix aligns the OXC compiler output with the Angular compiler.

Fix

Pass has_extra_args: true for the InterpolateText case, ensuring the trailing empty string is always preserved. This is safe because:

• The simple {{ expr }} case takes an early-return branch before the trailing-string logic, so true vs false makes no difference there
• No extra args are appended after text interpolation (unlike property/attribute bindings which may append a sanitizer or namespace), so keeping the trailing "" does not break positional argument alignment

Reproduction

Any template with a static prefix before an interpolation in a text node:

<span>#{{ index() + 1 }}</span>

Renders #1undefined instead of #1.

The existing test for_listener_with_index also encodes this bug in its snapshot:

// Before (wrong — 2 args):
i0.ɵɵtextInterpolate1("Remove #",ɵ$index_1_r2);
// After (correct — 3 args, matching Angular compiler output):
i0.ɵɵtextInterpolate1("Remove #",ɵ$index_1_r2,"");

Test plan

• All 262 existing tests pass
• Updated 3 snapshot files and 3 manual assertions to match corrected output
• Verify with a real Angular app that text like #{{ idx }} no longer appends undefined

🤖 Generated with Claude Code

[BenjaminDobler]

Closing this PR — after deeper investigation, the root cause analysis in the bug report is incorrect.

Findings:

1. The Angular compiler also explicitly drops trailing empty strings in textInterpolateN calls (see callVariadicInstructionExpr in @angular/compiler).

2. The Angular runtime uses default parameters (suffix = '') in interpolation1/interpolation2, so omitting the trailing empty string is safe and won't produce "undefined".

3. OXC's output already matches Angular's output — both emit e.g. textInterpolate1("#", value) with 2 args (no trailing "").

4. A local test with the playground (child component using signal inputs with #{{ index() }} template) renders correctly without undefined.

The reported #1undefined issue likely has a different root cause. Further investigation is needed with the specific project where the bug was observed.