Inline input.*() as a TA length behaves like its bound spelling (fixes #132) - #133

…ound spelling (C2 W2)

Root cause. 6545234 (#29, first shipped in 0.8.1) added the TA-constructor
guard in _emit_constructor: a ctor arg must fold to a literal or expand,
through _runtime_ctor_arg_for_reset, to a runtime expression whose every
identifier token is input-backed, a known constant or structural. Ctor args
travel as Pine source spellings, and the token scan read an inline call's
own argument text -- `input`, `int`, the title `fast` -- as unknown names,
so the length was refused. Before that commit 0.7.5-0.8.0 "accepted" it by
sizing both EMAs at 1 with no runtime reset (ta::EMA(1): fast == slow ==
close, a strategy that can never trade). 8390364 later let the bare word
`input` through, which admitted argument-free spellings such as input(15)
but not a title; and the analyzer's _expr_to_str dropped keyword arguments,
so `input.int(defval=9, title="fast")` reached codegen as `input.int()` and
silently became ta::EMA(get_input_int("", 0)).

Fix:
  * pine_spelling.py: string-literal-aware helpers -- the Pine literal of a
    string, identifier substitution that leaves string contents alone, the
    extent of each inline input call, and a full spelling of an input call.
  * analyzer _expr_to_str spells an input call with its keyword arguments,
    escapes string literals and spells list literals (options=[...]).
  * codegen: an inline input call is admitted exactly when its bound
    spelling `v = <call>` would make v input-backed (_is_stable_inline_input:
    not a source input, constant defval; _input_default_value is now the one
    rule for both). The reset gate masks each admitted call to the bare word
    `input`; the placeholder, precalc and prepare_script_run sizes read its
    defval (_fold_inline_input_defaults), as a bound name does through
    _known_vars; derived-length tracking (`n = input.int(9, "fast") * 2`,
    `var n = input.int(9, "fast")`) spells it in full and counts it as an
    input reference; _expand_derived no longer rewrites a title that happens
    to spell a derived name.
  * The input manifest lists every global-scope input call, inline ones too,
    one entry per call site in source order, titled with the key the C++
    reads the input by.

The inline spelling now emits the bound spelling's C++ except for the bound
twin's own member and its source-line call-site ids. A length that is
otherwise a series (a bar field, bar_index, a source input) is still refused
with the same diagnostic.

Evidence: tests/test_e2e_inline_input_ta_length.py 79 passed (was 74 failed);
all 312 corpus/validation generated.cpp re-transpile byte-identical; the
manifest of two corpus probes gains the inputs their C++ already reads
(analyzer-anvil-percent-costs-01: "Stop %", "Target %";
na-ledger-history-anchor-01: "Entry Deviation %").

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

…ounts (C2 W3)

Adds "Known codegen quirks" entry 10: an inline input.*() call is one leaf
of a TA length -- pine_spelling.py keeps it whole in the ctor-arg spelling,
the codegen masks its argument text out of every identifier scan, it is
admitted exactly when its bound spelling would be input-backed, a length
that is otherwise a series stays refused, and the manifest lists every
global-scope input call with the key the C++ reads it by. Lists
pine_spelling.py in the file map.

Re-measured on 2026-09-23 with the engine at engine-main fc7aad62 (corpus
gitlink 9182e3d), Eigen and a built runtime: 2937 passed, 2 skipped (the two
documented skips), 0 failed; without a compile environment 1952 passed,
674 skipped. The corpus sweep is unchanged at 314 passed.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>