From 85b9100d39fcecbfadcbbb815ebbd854e4cd7483 Mon Sep 17 00:00:00 2001 From: luisleo526 <20812494+luisleo526@users.noreply.github.com> Date: Sun, 15 Nov 2026 00:27:53 +0800 Subject: [PATCH 1/2] Resolve empty timeframe arguments to the chart period --- CHANGELOG.md | 4 + pineforge_codegen/codegen/helpers.py | 1 + pineforge_codegen/codegen/visit_call.py | 39 ++-- tests/fixtures/empty_timeframe/arguments.pine | 186 +++++++++++++++ .../empty_timeframe/reporter-change.pine | 10 + .../empty_timeframe/reporter-seconds.pine | 10 + tests/test_e2e_empty_timeframe.py | 219 ++++++++++++++++++ tests/test_e2e_temporary_name_hygiene.py | 10 +- 8 files changed, 464 insertions(+), 15 deletions(-) create mode 100644 tests/fixtures/empty_timeframe/arguments.pine create mode 100644 tests/fixtures/empty_timeframe/reporter-change.pine create mode 100644 tests/fixtures/empty_timeframe/reporter-seconds.pine create mode 100644 tests/test_e2e_empty_timeframe.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 83af3833..bd73cb2d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,10 @@ supported as exact pairs; on the 0.x line they are independent. See the ## Unreleased (next release) +- `timeframe.in_seconds` and `timeframe.change` resolve an evaluated empty + string to the chart period, including input, variable, function-return and + named arguments. The argument is evaluated once, and nonempty strings keep + their explicit period. (#394) - A zone name the engine rejects now makes calendar-form `timestamp()` stop the run at its first evaluation, instead of silently calculating a UTC value. The paired engine reports a typed timezone error identifying the failed bar. diff --git a/pineforge_codegen/codegen/helpers.py b/pineforge_codegen/codegen/helpers.py index f292996f..aacef1e4 100644 --- a/pineforge_codegen/codegen/helpers.py +++ b/pineforge_codegen/codegen/helpers.py @@ -533,6 +533,7 @@ def cpp_code_only(cpp: str) -> str: _pf_series_raw _pf_raw _pf_val_t _pf_out _pf_prior _pf_hist_offset_raw _pf_hist_offset_numeric _pf_hist_offset _pf_hist_bar _pf_calendar_ts _pf_calendar_tz + _pf_timeframe_arg _tz _yr _mo _dy _hr _min _sc _res _old _old_tz _had_old _secs _last_tz _last_yr _last_mo _last_dy _last_hr _last_min _last_sc _last_res diff --git a/pineforge_codegen/codegen/visit_call.py b/pineforge_codegen/codegen/visit_call.py index efb19c5c..fb34cb61 100644 --- a/pineforge_codegen/codegen/visit_call.py +++ b/pineforge_codegen/codegen/visit_call.py @@ -3211,22 +3211,35 @@ def _visit_func_call(self, node: FuncCall) -> str: return f'{log_funcs[func_name]}({self._visit_expr(message)})' return '"" /* unsupported log */' - # timeframe.* calls (e.g., timeframe.change) — not supported in single-TF backtest + # An empty timeframe argument denotes the chart period, whether it + # comes from a literal, an input or a user call. Bind by parameter + # name and resolve the evaluated string, not the argument's AST form. if namespace == "timeframe": - if func_name == "change": - tf_arg = self._visit_expr(node.args[0]) if node.args else 'script_tf_' - # Symbol-clock overload: D/W/M boundaries fall on the SYMBOL's - # session day (17:00 ET on OANDA forex, 09:30 ET RTH on - # equities), intraday buckets on the session-open grid — the - # same clock request.security aggregation uses. UTC/24x7 - # syminfo reduces to the tz-less epoch math bit-for-bit. + if func_name in ("change", "in_seconds"): + argument = self._resolve_func_args( + node, f"timeframe.{func_name}", + ).get("timeframe") + tf_arg = ( + "script_tf_" if argument is None else + "(_pf_timeframe_arg.empty() ? script_tf_ : _pf_timeframe_arg)" + ) + if func_name == "change": + # Keep the symbol-clock overload for calendar and + # session-anchored intraday boundaries. + call = ( + f'tf_change(prev_bar_timestamp_, current_bar_.timestamp, {tf_arg}, ' + 'syminfo_.timezone, syminfo_.session)' + ) + else: + call = f'tf_to_seconds({tf_arg})' + if argument is None: + return call + # A function-return argument can carry state. Evaluate it + # once before testing emptiness and passing the chosen value. return ( - f'tf_change(prev_bar_timestamp_, current_bar_.timestamp, {tf_arg}, ' - 'syminfo_.timezone, syminfo_.session)' + '([&]() { const std::string _pf_timeframe_arg = ' + f'({self._visit_expr(argument)}); return {call}; }}())' ) - if func_name == "in_seconds": - tf_arg = self._visit_expr(node.args[0]) if node.args else 'script_tf_' - return f'tf_to_seconds({tf_arg})' # Defensive: support_checker.NOT_YET_FUNC should already have rejected # any unhandled timeframe.* call. Reaching here implies the checker was # bypassed. diff --git a/tests/fixtures/empty_timeframe/arguments.pine b/tests/fixtures/empty_timeframe/arguments.pine new file mode 100644 index 00000000..99afec55 --- /dev/null +++ b/tests/fixtures/empty_timeframe/arguments.pine @@ -0,0 +1,186 @@ +//@version=6 +strategy("Empty timeframe arguments", currency = currency.NONE) +frameInput = input.timeframe("", "Frame input") +frameString = input.string("", "String input") +frameVariable = frameString +_pf_timeframe_arg = frameString +pf_safe__pf_timeframe_arg = "240" +plainVariable = "" +var string persistentFrame = "" +emptyFrame() => "" +returnedFrame(string frameArg) => frameArg +secondsPos(string frameArg) => timeframe.in_seconds(frameArg) +secondsNamed(string frameArg) => timeframe.in_seconds(timeframe = frameArg) +changePos(string frameArg) => timeframe.change(frameArg) +changeNamed(string frameArg) => timeframe.change(timeframe = frameArg) +secondsCapturedPos(string _pf_timeframe_arg) => timeframe.in_seconds(_pf_timeframe_arg) +secondsCapturedNamed(string _pf_timeframe_arg) => timeframe.in_seconds(timeframe = _pf_timeframe_arg) +changeCapturedPos(string _pf_timeframe_arg) => timeframe.change(_pf_timeframe_arg) +changeCapturedNamed(string _pf_timeframe_arg) => timeframe.change(timeframe = _pf_timeframe_arg) +secondsStatefulPos(string frameArg) => + var string savedFrame = frameArg + timeframe.in_seconds(savedFrame) +secondsStatefulNamed(string frameArg) => + var string savedFrame = frameArg + timeframe.in_seconds(timeframe = savedFrame) +changeStatefulPos(string frameArg) => + var string savedFrame = frameArg + timeframe.change(savedFrame) +changeStatefulNamed(string frameArg) => + var string savedFrame = frameArg + timeframe.change(timeframe = savedFrame) +countedFrame(array counter, string frameArg) => + array.set(counter, 0, array.get(counter, 0) + 1) + frameArg +S_literal_pos = timeframe.in_seconds("") +S_literal_named = timeframe.in_seconds(timeframe = "") +S_input_pos = timeframe.in_seconds(frameInput) +S_input_named = timeframe.in_seconds(timeframe = frameInput) +S_string_input_pos = timeframe.in_seconds(frameString) +S_string_input_named = timeframe.in_seconds(timeframe = frameString) +S_variable_pos = timeframe.in_seconds(frameVariable) +S_variable_named = timeframe.in_seconds(timeframe = frameVariable) +S_temporary_name_pos = timeframe.in_seconds(_pf_timeframe_arg) +S_temporary_name_named = timeframe.in_seconds(timeframe = _pf_timeframe_arg) +S_parameter_name_pos = secondsCapturedPos(frameString) +S_parameter_name_named = secondsCapturedNamed(frameString) +S_occupied_escape_pos = timeframe.in_seconds(pf_safe__pf_timeframe_arg) +S_occupied_escape_named = timeframe.in_seconds(timeframe = pf_safe__pf_timeframe_arg) +S_plain_variable_pos = timeframe.in_seconds(plainVariable) +S_plain_variable_named = timeframe.in_seconds(timeframe = plainVariable) +S_persistent_pos = timeframe.in_seconds(persistentFrame) +S_persistent_named = timeframe.in_seconds(timeframe = persistentFrame) +S_return_pos = timeframe.in_seconds(emptyFrame()) +S_return_named = timeframe.in_seconds(timeframe = emptyFrame()) +S_return_input_pos = timeframe.in_seconds(returnedFrame(frameInput)) +S_return_input_named = timeframe.in_seconds(timeframe = returnedFrame(frameInput)) +S_period_pos = timeframe.in_seconds(timeframe.period) +S_period_named = timeframe.in_seconds(timeframe = timeframe.period) +S_explicit_pos = timeframe.in_seconds("240") +S_explicit_named = timeframe.in_seconds(timeframe = "240") +S_helper_empty_pos = secondsPos("") +S_helper_explicit_pos = secondsPos("240") +S_helper_empty_named = secondsNamed("") +S_helper_explicit_named = secondsNamed("240") +S_stateful_empty_pos = secondsStatefulPos("") +S_stateful_explicit_pos = secondsStatefulPos("240") +S_stateful_empty_named = secondsStatefulNamed("") +S_stateful_explicit_named = secondsStatefulNamed("240") +S_omitted = timeframe.in_seconds() +C_literal_pos = timeframe.change("") ? 1 : 0 +C_literal_named = timeframe.change(timeframe = "") ? 1 : 0 +C_input_pos = timeframe.change(frameInput) ? 1 : 0 +C_input_named = timeframe.change(timeframe = frameInput) ? 1 : 0 +C_string_input_pos = timeframe.change(frameString) ? 1 : 0 +C_string_input_named = timeframe.change(timeframe = frameString) ? 1 : 0 +C_variable_pos = timeframe.change(frameVariable) ? 1 : 0 +C_variable_named = timeframe.change(timeframe = frameVariable) ? 1 : 0 +C_temporary_name_pos = timeframe.change(_pf_timeframe_arg) ? 1 : 0 +C_temporary_name_named = timeframe.change(timeframe = _pf_timeframe_arg) ? 1 : 0 +C_parameter_name_pos = changeCapturedPos(frameString) ? 1 : 0 +C_parameter_name_named = changeCapturedNamed(frameString) ? 1 : 0 +C_occupied_escape_pos = timeframe.change(pf_safe__pf_timeframe_arg) ? 1 : 0 +C_occupied_escape_named = timeframe.change(timeframe = pf_safe__pf_timeframe_arg) ? 1 : 0 +C_plain_variable_pos = timeframe.change(plainVariable) ? 1 : 0 +C_plain_variable_named = timeframe.change(timeframe = plainVariable) ? 1 : 0 +C_persistent_pos = timeframe.change(persistentFrame) ? 1 : 0 +C_persistent_named = timeframe.change(timeframe = persistentFrame) ? 1 : 0 +C_return_pos = timeframe.change(emptyFrame()) ? 1 : 0 +C_return_named = timeframe.change(timeframe = emptyFrame()) ? 1 : 0 +C_return_input_pos = timeframe.change(returnedFrame(frameInput)) ? 1 : 0 +C_return_input_named = timeframe.change(timeframe = returnedFrame(frameInput)) ? 1 : 0 +C_period_pos = timeframe.change(timeframe.period) ? 1 : 0 +C_period_named = timeframe.change(timeframe = timeframe.period) ? 1 : 0 +C_explicit_pos = timeframe.change("240") ? 1 : 0 +C_explicit_named = timeframe.change(timeframe = "240") ? 1 : 0 +C_helper_empty_pos = changePos("") ? 1 : 0 +C_helper_explicit_pos = changePos("240") ? 1 : 0 +C_helper_empty_named = changeNamed("") ? 1 : 0 +C_helper_explicit_named = changeNamed("240") ? 1 : 0 +C_stateful_empty_pos = changeStatefulPos("") ? 1 : 0 +C_stateful_explicit_pos = changeStatefulPos("240") ? 1 : 0 +C_stateful_empty_named = changeStatefulNamed("") ? 1 : 0 +C_stateful_explicit_named = changeStatefulNamed("240") ? 1 : 0 +C_omitted = timeframe.change() ? 1 : 0 +dynamicFrame = bar_index % 2 == 0 ? "" : "240" +C_dynamic_pos = timeframe.change(dynamicFrame) ? 1 : 0 +C_dynamic_named = timeframe.change(timeframe = dynamicFrame) ? 1 : 0 +var calls = array.new_int(1, 0) +C_once_pos = timeframe.change(countedFrame(calls, frameInput)) ? 1 : 0 +C_once_named = timeframe.change(timeframe = countedFrame(calls, frameInput)) ? 1 : 0 +callCount = array.get(calls, 0) +// @pf-trace S_literal_pos=S_literal_pos +// @pf-trace S_literal_named=S_literal_named +// @pf-trace S_input_pos=S_input_pos +// @pf-trace S_input_named=S_input_named +// @pf-trace S_string_input_pos=S_string_input_pos +// @pf-trace S_string_input_named=S_string_input_named +// @pf-trace S_variable_pos=S_variable_pos +// @pf-trace S_variable_named=S_variable_named +// @pf-trace S_temporary_name_pos=S_temporary_name_pos +// @pf-trace S_temporary_name_named=S_temporary_name_named +// @pf-trace S_parameter_name_pos=S_parameter_name_pos +// @pf-trace S_parameter_name_named=S_parameter_name_named +// @pf-trace S_occupied_escape_pos=S_occupied_escape_pos +// @pf-trace S_occupied_escape_named=S_occupied_escape_named +// @pf-trace S_plain_variable_pos=S_plain_variable_pos +// @pf-trace S_plain_variable_named=S_plain_variable_named +// @pf-trace S_persistent_pos=S_persistent_pos +// @pf-trace S_persistent_named=S_persistent_named +// @pf-trace S_return_pos=S_return_pos +// @pf-trace S_return_named=S_return_named +// @pf-trace S_return_input_pos=S_return_input_pos +// @pf-trace S_return_input_named=S_return_input_named +// @pf-trace S_period_pos=S_period_pos +// @pf-trace S_period_named=S_period_named +// @pf-trace S_explicit_pos=S_explicit_pos +// @pf-trace S_explicit_named=S_explicit_named +// @pf-trace S_helper_empty_pos=S_helper_empty_pos +// @pf-trace S_helper_explicit_pos=S_helper_explicit_pos +// @pf-trace S_helper_empty_named=S_helper_empty_named +// @pf-trace S_helper_explicit_named=S_helper_explicit_named +// @pf-trace S_stateful_empty_pos=S_stateful_empty_pos +// @pf-trace S_stateful_explicit_pos=S_stateful_explicit_pos +// @pf-trace S_stateful_empty_named=S_stateful_empty_named +// @pf-trace S_stateful_explicit_named=S_stateful_explicit_named +// @pf-trace S_omitted=S_omitted +// @pf-trace C_literal_pos=C_literal_pos +// @pf-trace C_literal_named=C_literal_named +// @pf-trace C_input_pos=C_input_pos +// @pf-trace C_input_named=C_input_named +// @pf-trace C_string_input_pos=C_string_input_pos +// @pf-trace C_string_input_named=C_string_input_named +// @pf-trace C_variable_pos=C_variable_pos +// @pf-trace C_variable_named=C_variable_named +// @pf-trace C_temporary_name_pos=C_temporary_name_pos +// @pf-trace C_temporary_name_named=C_temporary_name_named +// @pf-trace C_parameter_name_pos=C_parameter_name_pos +// @pf-trace C_parameter_name_named=C_parameter_name_named +// @pf-trace C_occupied_escape_pos=C_occupied_escape_pos +// @pf-trace C_occupied_escape_named=C_occupied_escape_named +// @pf-trace C_plain_variable_pos=C_plain_variable_pos +// @pf-trace C_plain_variable_named=C_plain_variable_named +// @pf-trace C_persistent_pos=C_persistent_pos +// @pf-trace C_persistent_named=C_persistent_named +// @pf-trace C_return_pos=C_return_pos +// @pf-trace C_return_named=C_return_named +// @pf-trace C_return_input_pos=C_return_input_pos +// @pf-trace C_return_input_named=C_return_input_named +// @pf-trace C_period_pos=C_period_pos +// @pf-trace C_period_named=C_period_named +// @pf-trace C_explicit_pos=C_explicit_pos +// @pf-trace C_explicit_named=C_explicit_named +// @pf-trace C_helper_empty_pos=C_helper_empty_pos +// @pf-trace C_helper_explicit_pos=C_helper_explicit_pos +// @pf-trace C_helper_empty_named=C_helper_empty_named +// @pf-trace C_helper_explicit_named=C_helper_explicit_named +// @pf-trace C_stateful_empty_pos=C_stateful_empty_pos +// @pf-trace C_stateful_explicit_pos=C_stateful_explicit_pos +// @pf-trace C_stateful_empty_named=C_stateful_empty_named +// @pf-trace C_stateful_explicit_named=C_stateful_explicit_named +// @pf-trace C_omitted=C_omitted +// @pf-trace C_dynamic_pos=C_dynamic_pos +// @pf-trace C_dynamic_named=C_dynamic_named +// @pf-trace C_once_pos=C_once_pos +// @pf-trace C_once_named=C_once_named +// @pf-trace callCount=callCount diff --git a/tests/fixtures/empty_timeframe/reporter-change.pine b/tests/fixtures/empty_timeframe/reporter-change.pine new file mode 100644 index 00000000..7b69fac4 --- /dev/null +++ b/tests/fixtures/empty_timeframe/reporter-change.pine @@ -0,0 +1,10 @@ +//@version=6 +strategy("timeframe.change empty string", overlay = true, initial_capital = 10000) +fast = ta.ema(close, 10) +slow = ta.ema(close, 30) +chg = timeframe.change("") ? 1 : 0 +// @pf-trace chg=chg +if ta.crossover(fast, slow) + strategy.entry("Long", strategy.long, qty = 0.01) +if ta.crossunder(fast, slow) + strategy.close("Long") diff --git a/tests/fixtures/empty_timeframe/reporter-seconds.pine b/tests/fixtures/empty_timeframe/reporter-seconds.pine new file mode 100644 index 00000000..e9667c37 --- /dev/null +++ b/tests/fixtures/empty_timeframe/reporter-seconds.pine @@ -0,0 +1,10 @@ +//@version=6 +strategy("timeframe.in_seconds empty string", overlay = true, initial_capital = 10000) +fast = ta.ema(close, 10) +slow = ta.ema(close, 30) +secs = timeframe.in_seconds("") +// @pf-trace secs=secs +if ta.crossover(fast, slow) + strategy.entry("Long", strategy.long, qty = 0.01) +if ta.crossunder(fast, slow) + strategy.close("Long") diff --git a/tests/test_e2e_empty_timeframe.py b/tests/test_e2e_empty_timeframe.py new file mode 100644 index 00000000..f7670011 --- /dev/null +++ b/tests/test_e2e_empty_timeframe.py @@ -0,0 +1,219 @@ +"""Empty timeframe strings resolve after argument evaluation. + +The complete reporter strategies pin the two original defects. The argument +matrix observes native values for inputs, variables, returns and helpers on +several chart periods, and counts evaluations of a stateful string argument. +""" + +from __future__ import annotations + +from datetime import datetime, timezone +import math +from pathlib import Path + +import pytest + +from tests._e2e import ( + Build, assert_same_runs, build_strategy_library, chart_feed_head, + execute_all, ok, run_strategy, skip_unless_e2e_env, transpile_json, +) +from tests._requests import Feed + + +FIXTURES = Path(__file__).parent / "fixtures" / "empty_timeframe" +REPORTER_BARS = 1441 +FIXED_SECONDS = {"1S": 1, "5": 300, "60": 3600, "D": 86400, "W": 604800} +ARGUMENTS = { + "literal": "chart", + "input": "input", + "string_input": "input", + "variable": "input", + "temporary_name": "input", + "parameter_name": "input", + "occupied_escape": "explicit", + "plain_variable": "chart", + "persistent": "chart", + "return": "chart", + "return_input": "input", + "period": "chart", + "explicit": "explicit", +} +BUILTINS = {"S": "in_seconds", "C": "change"} +STYLES = ("pos", "named") + + +@pytest.fixture(scope="module") +def reporter_runs(tmp_path_factory): + engine = skip_unless_e2e_env() + base = tmp_path_factory.mktemp("reporter_empty_timeframe") + # A public corpus replay, distinct from the reporter's BTC date window. + input_bars = REPORTER_BARS * 4 + expanded = chart_feed_head(engine, base, input_bars + 4) + rows = expanded.read_text().splitlines() + first = next(index for index, line in enumerate(rows[1:], 1) + if int(line.split(",", 1)[0]) % 3_600_000 == 0) + selected = rows[first:first + input_bars] + assert len(selected) == input_bars, "public feed has too few hourly chart inputs" + feed = base / "aligned_15m.csv" + feed.write_text("\n".join([rows[0], *selected]) + "\n") + builds = {} + for kind, function in (("seconds", "in_seconds"), ("change", "change")): + source = (FIXTURES / f"reporter-{kind}.pine").read_text() + original = f'timeframe.{function}("")' + assert source.count(original) == 1 + for variant, argument in (("empty", '""'), ("period", "timeframe.period"), + ("omitted", "")): + builds[f"{kind}_{variant}"] = Build( + source.replace(original, f"timeframe.{function}({argument})", 1), + overrides={ + "input_tf": "15", "script_tf": "60", + "runtime_overrides": {"currency": "USDT", "timezone": "UTC"}, + }, + trace=True, + ) + return execute_all(engine, feed, base, builds) + + +@pytest.mark.parametrize("kind", ("seconds", "change"), ids=("in_seconds", "change")) +def test_reporter_empty_matches_chart_controls(kind, reporter_runs): + subject = ok(reporter_runs, f"{kind}_empty") + period = ok(reporter_runs, f"{kind}_period") + omitted = ok(reporter_runs, f"{kind}_omitted") + label = "secs" if kind == "seconds" else "chg" + for tag, count, seconds in (("default", REPORTER_BARS * 4, 900.0), + ("override", REPORTER_BARS, 3600.0)): + control = period.traces[tag] + assert len(control) == count + assert {row["name"] for row in control} == {label} + assert [row["bar_index"] for row in control] == list(range(count)) + assert all(b["timestamp"] - a["timestamp"] == seconds * 1000 + for a, b in zip(control, control[1:])) + expected = ([seconds] * count if kind == "seconds" + else [0.0] + [1.0] * (count - 1)) + assert [row["value"] for row in control] == expected + assert_same_runs(omitted, period) + assert_same_runs(subject, period) + + +def _clock_stamps(period): + epoch = int(datetime(2024, 1, 1, tzinfo=timezone.utc).timestamp() * 1000) + if period == "M": + return [int(datetime(2024, month, 1, tzinfo=timezone.utc).timestamp() * 1000) + for month in range(1, 6)] + return [epoch + index * FIXED_SECONDS[period] * 1000 for index in range(33)] + + +@pytest.fixture(scope="module") +def argument_runs(tmp_path_factory): + engine = skip_unless_e2e_env() + base = tmp_path_factory.mktemp("empty_timeframe_arguments") + pine = FIXTURES / "arguments.pine" + source = pine.read_text() + result = transpile_json(pine) + assert result.get("ok"), result.get("diagnostics") + build_strategy_library(result["cpp"], base) + expected_names = {line.split()[2].split("=", 1)[0] + for line in source.splitlines() if line.startswith("// @pf-trace ")} + outcomes = {} + for period in (*FIXED_SECONDS, "M"): + stamps = _clock_stamps(period) + last_close = ( + int(datetime(2024, 6, 1, tzinfo=timezone.utc).timestamp() * 1000) + if period == "M" else stamps[-1] + stamps[-1] - stamps[-2] + ) + bars = [(stamp, close_stamp, 100.0 + index) + for index, (stamp, close_stamp) + in enumerate(zip(stamps, [*stamps[1:], last_close]))] + feed = base / f"clock_{period}.csv" + feed.write_bytes(Feed("BINANCE:BTCUSDT", period, bars).csv()) + for argument in ("", "240"): + tag = f"{period}_{'empty' if not argument else 'explicit'}" + overrides = { + "input_tf": period, "script_tf": period, + "Frame input": argument, "String input": argument, + "runtime_overrides": { + "currency": "USDT", "timezone": "UTC", "session": "24x7", + }, + } + _trades, records, stderr = run_strategy( + engine, base, feed, overrides, tag, trace=True, + ) + (base / f"run_{tag}.stderr").write_text(stderr) + columns = {} + for row in records: + columns.setdefault(row["name"], []).append(row) + assert set(columns) == expected_names, f"{tag}: missing native trace names" + for name, series in columns.items(): + assert len(series) == len(stamps), (tag, name, "missing native calls") + assert [row["bar_index"] for row in series] == list(range(len(stamps))) + assert [row["timestamp"] for row in series] == stamps + outcomes[period, argument] = { + name: [row["value"] for row in series] for name, series in columns.items() + } + return outcomes + + +def _expected(frame, stamps, chart_seconds): + if frame == "chart": + return [chart_seconds] * len(stamps), [0.0] + [1.0] * (len(stamps) - 1) + assert frame == "explicit" + size = 240 * 60 * 1000 + return ([14400.0] * len(stamps), + [0.0] + [float(now // size != before // size) + for before, now in zip(stamps, stamps[1:])]) + + +@pytest.mark.parametrize("builtin", BUILTINS, ids=("in_seconds", "change")) +@pytest.mark.parametrize("name", ARGUMENTS) +@pytest.mark.parametrize("style", STYLES) +def test_empty_argument_source_uses_the_evaluated_string(builtin, name, style, argument_runs): + for (period, argument), columns in argument_runs.items(): + stamps = _clock_stamps(period) + chart_seconds = columns["S_period_pos"][0] + assert math.isfinite(chart_seconds) + if period in FIXED_SECONDS: + assert chart_seconds == FIXED_SECONDS[period] + # Calendar-only engine periods retain their existing conversion; + # equality to the period control is the empty-argument contract. + assert columns["S_period_pos"] == [chart_seconds] * len(stamps) + assert columns["C_period_pos"] == [0.0] + [1.0] * (len(stamps) - 1) + resolution = ARGUMENTS[name] + frame = ("explicit" if resolution == "explicit" + or (resolution == "input" and argument) else "chart") + seconds, changes = _expected(frame, stamps, chart_seconds) + assert columns[f"{builtin}_{name}_{style}"] == ( + seconds if builtin == "S" else changes + ), (period, argument, builtin, name, style) + + +@pytest.mark.parametrize("builtin", BUILTINS, ids=("in_seconds", "change")) +@pytest.mark.parametrize("style", STYLES) +@pytest.mark.parametrize("body", ("helper", "stateful")) +def test_each_helper_body_preserves_empty_and_explicit_arguments(builtin, style, body, argument_runs): + for (period, argument), columns in argument_runs.items(): + stamps = _clock_stamps(period) + for suffix, frame in (("empty", "chart"), ("explicit", "explicit")): + seconds, changes = _expected(frame, stamps, columns["S_period_pos"][0]) + assert columns[f"{builtin}_{body}_{suffix}_{style}"] == ( + seconds if builtin == "S" else changes + ), (period, argument, builtin, style, body, suffix) + + +def test_omitted_arguments_keep_the_existing_chart_resolution(argument_runs): + for columns in argument_runs.values(): + for builtin in BUILTINS: + assert columns[f"{builtin}_omitted"] == columns[f"{builtin}_period_pos"] + + +def test_change_evaluates_each_string_once_and_can_switch_to_explicit(argument_runs): + for (period, argument), columns in argument_runs.items(): + stamps = _clock_stamps(period) + _, chart = _expected("chart", stamps, columns["S_period_pos"][0]) + _, explicit = _expected("explicit", stamps, columns["S_period_pos"][0]) + dynamic = [chart[index] if index % 2 == 0 else explicit[index] + for index in range(len(stamps))] + assert columns["C_dynamic_pos"] == dynamic + assert columns["C_dynamic_named"] == dynamic + assert columns["C_once_pos"] == (explicit if argument else chart) + assert columns["C_once_named"] == (explicit if argument else chart) + assert columns["callCount"] == [2.0 * (index + 1) for index in range(len(stamps))] diff --git a/tests/test_e2e_temporary_name_hygiene.py b/tests/test_e2e_temporary_name_hygiene.py index e9295016..2e3ec38f 100644 --- a/tests/test_e2e_temporary_name_hygiene.py +++ b/tests/test_e2e_temporary_name_hygiene.py @@ -117,8 +117,14 @@ def test_every_temporary_the_emitter_declares_is_reserved(): # Temporaries derived from emitted C++: every underscore-prefixed local # declared inside a generated lambda that is not a name of the script. names = set() - for name in TAPES: - source = (FIXTURES / f"{name}.pine").read_text() + sources = [(FIXTURES / f"{name}.pine").read_text() for name in TAPES] + sources.append( + HEAD + 'frameChoice = input.timeframe("")\n' + 'secondsValue = timeframe.in_seconds(frameChoice)\n' + 'changedValue = timeframe.change(timeframe = frameChoice)\n' + 'plot(secondsValue)\nplot(changedValue ? 1 : 0)\n' + ) + for source in sources: authored = {t.value for t in Lexer(source).tokenize() if t.type.name == "IDENT"} for line in transpile(source).splitlines(): if "[&]" in line: From 2ed69c9132bfce07a56526732c5039b57f378080 Mon Sep 17 00:00:00 2001 From: luisleo526 <20812494+luisleo526@users.noreply.github.com> Date: Sun, 15 Nov 2026 03:24:39 +0800 Subject: [PATCH 2/2] fix: preserve timeframe arguments and generated-name safety Resolve dotted builtin signatures through the same registry record for argument ordering and validation. Retain direct nonempty stable arguments, single evaluation of effectful arguments and chart fallback for empty values. Reserve the existing coercion temporary family through normal name escaping. Integrate the complete generic corrections for #394's returned 75 cases. Existing tests, fixtures, literals and expectations are unchanged. --- CHANGELOG.md | 6 ++- pineforge_codegen/codegen/helpers.py | 6 ++- pineforge_codegen/codegen/visit_call.py | 56 +++++++++++++++---------- 3 files changed, 43 insertions(+), 25 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 57f4e358..fb497781 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -25,7 +25,11 @@ supported as exact pairs; on the 0.x line they are independent. See the - `timeframe.in_seconds` and `timeframe.change` resolve an evaluated empty string to the chart period, including input, variable, function-return and named arguments. The argument is evaluated once, and nonempty strings keep - their explicit period. (#394) + their explicit period. Dotted builtin signatures retain supplied arguments, + including escaped string literals and VWAP anchors. (#394) +- Script identifiers spelled like integer-to-float conversion temporaries, + including the underscore suffixes of nested conversions, now use the + generator's reserved-name escaping. - A zone name the engine rejects now makes calendar-form `timestamp()` stop the run at its first evaluation, instead of silently calculating a UTC value. The paired engine reports a typed timezone error identifying the failed bar. diff --git a/pineforge_codegen/codegen/helpers.py b/pineforge_codegen/codegen/helpers.py index 9b5236cc..40a79b20 100644 --- a/pineforge_codegen/codegen/helpers.py +++ b/pineforge_codegen/codegen/helpers.py @@ -543,7 +543,7 @@ def cpp_code_only(cpp: str) -> str: _pf_number_text _pf_substring_text _pf_substring_begin _pf_substring_end _pf_substring_error _pf_array_new_size _pf_array_new_value _pf_array_new_size_type _pf_array_new_error - _pf_read _pf_v5_l _pf_v5_r _pf_wide_l _pf_wide_r + _pf_read _pf_v5_l _pf_v5_r _pf_wide_l _pf_wide_r _pf_w _pf_symbol _pf_colon _pf_color _pf_bar_back _pf_ema_seeding _pf_history_array _pf_history_offset _pf_matrix_target _pf_array_index_type @@ -551,7 +551,8 @@ def cpp_code_only(cpp: str) -> str: _pf_sort_left _pf_sort_right _pf_sort_left_na _pf_sort_right_na """.split()) # These numbered members and locals keep their source-order spelling rather -# than allocating against authored names. Reserve their complete spellings, +# than allocating against authored names. Double coercions append underscores +# to _pf_w to distinguish nested temporaries. Reserve their complete spellings, # just as for fixed temporaries, without reserving ordinary underscore names. _CPP_TEMPORARY_PATTERN = re.compile( r"_v\d+|_secval_\d+(?:_v\d+)?|_tuple_result_\d+(?:_elem_\d+)?|_tuple_unused_\d+|__switch_val_\d+" @@ -561,6 +562,7 @@ def cpp_code_only(cpp: str) -> str: r"|_pf_every_bar_ta_\d+|_pf_shared_\d+_\d+|__pf_array\w*|__pf_raw_\w+" r"|_pf_collection_hist_\w+" r"|_pf_substring_arg\d+" + r"|_pf_w_+" r"|_req_sec_(?:lower_tf_)?\d+(?:_\d+)?|_precalc_\w+|_sec\d+_\w+" r"|_pf_(?:sec|rec)_missing_\d+|_eval_security_\d+" r"|_RuntimeSec\d+|_runtime_(?:feed|request)_\d+" diff --git a/pineforge_codegen/codegen/visit_call.py b/pineforge_codegen/codegen/visit_call.py index fb34cb61..eb97f7bd 100644 --- a/pineforge_codegen/codegen/visit_call.py +++ b/pineforge_codegen/codegen/visit_call.py @@ -3219,26 +3219,36 @@ def _visit_func_call(self, node: FuncCall) -> str: argument = self._resolve_func_args( node, f"timeframe.{func_name}", ).get("timeframe") - tf_arg = ( - "script_tf_" if argument is None else - "(_pf_timeframe_arg.empty() ? script_tf_ : _pf_timeframe_arg)" - ) - if func_name == "change": - # Keep the symbol-clock overload for calendar and - # session-anchored intraday boundaries. - call = ( - f'tf_change(prev_bar_timestamp_, current_bar_.timestamp, {tf_arg}, ' - 'syminfo_.timezone, syminfo_.session)' - ) - else: - call = f'tf_to_seconds({tf_arg})' + + def timeframe_call(tf_arg: str) -> str: + if func_name == "change": + # Keep the symbol-clock overload for calendar and + # session-anchored intraday boundaries. + return ( + f'tf_change(prev_bar_timestamp_, current_bar_.timestamp, {tf_arg}, ' + 'syminfo_.timezone, syminfo_.session)' + ) + return f'tf_to_seconds({tf_arg})' + if argument is None: - return call + return timeframe_call("script_tf_") + argument_cpp = self._visit_expr(argument) + if cpp_is_plain_read(argument_cpp): + # Keep resolved locals and parameters as direct engine + # arguments when nonempty. Stable reads can be checked + # without introducing another binding. + return ( + f'(({argument_cpp}).empty() ? {timeframe_call("script_tf_")} : ' + f'{timeframe_call(argument_cpp)})' + ) # A function-return argument can carry state. Evaluate it # once before testing emptiness and passing the chosen value. + call = timeframe_call( + "(_pf_timeframe_arg.empty() ? script_tf_ : _pf_timeframe_arg)" + ) return ( '([&]() { const std::string _pf_timeframe_arg = ' - f'({self._visit_expr(argument)}); return {call}; }}())' + f'({argument_cpp}); return {call}; }}())' ) # Defensive: support_checker.NOT_YET_FUNC should already have rejected # any unhandled timeframe.* call. Reaching here implies the checker was @@ -4418,18 +4428,20 @@ def _resolve_func_args(self, node: FuncCall, sig_key: str) -> dict: Uses the PineScript parameter ordering from signatures registry. """ - # sig_key is like "strategy.entry" -> namespace="strategy", func_name="entry" + # Namespace records use their short name; dotted builtin records use + # the complete key in BUILTIN_FUNCTIONS (e.g. timeframe.change). parts = sig_key.split(".", 1) + intrinsic = ( + sigs.get_intrinsic(parts[0], parts[1]) if len(parts) == 2 else None + ) + if intrinsic is None: + intrinsic = sigs.get_intrinsic(None, sig_key) validate_intrinsic_keywords( - sigs.get_intrinsic(parts[0], parts[1]) if len(parts) == 2 - else sigs.get_intrinsic(None, sig_key), + intrinsic, node.kwargs, pine_version=self.ctx.ast.version, ) - if len(parts) == 2: - param_names = sigs.get_param_names(parts[0], parts[1]) or [] - else: - param_names = sigs.get_param_names(None, sig_key) or [] + param_names = intrinsic.param_names if intrinsic is not None else [] result: dict = {} # Map positional args by parameter name for i, arg in enumerate(node.args):