diff --git a/CHANGELOG.md b/CHANGELOG.md index 88dac8f9..aa0f91c6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,13 @@ supported as exact pairs; on the 0.x line they are independent. See the ## Unreleased (next release) +- Generated function variants and persistent local copies avoid authored and + generated member names, including names ending in `_cs1` and composed names + that overlap collection-history or requested-context storage. Persistent + declarations in sibling blocks also retain distinct storage when a script + uses their generated spelling. Declarations, calls and history storage use + the same allocated identities. Regenerate C++ and relink affected strategies. + - 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/analyzer/base.py b/pineforge_codegen/analyzer/base.py index 772e2426..5b2fd285 100644 --- a/pineforge_codegen/analyzer/base.py +++ b/pineforge_codegen/analyzer/base.py @@ -265,6 +265,7 @@ def __init__(self, ast: Program, filename: str = "", self._block_var_owner: dict[str, int] = {} self._block_var_renames: dict[int, dict[str, str]] = {} self._block_var_seq = 0 + self._block_var_taken: set[str] | None = None # Identifier node identity -> the lexical Symbol.scope resolved while # that node's source scope is live. Codegen uses this narrow # provenance to distinguish true global aliases from same-named local @@ -5018,6 +5019,31 @@ def _record_script_block_binding(self, sym: Symbol, outer: Symbol | None) -> Non or any(id(body) == outer_owner for body in self._block_node_stack) ) + def _allocate_block_var_member(self, node: VarDecl) -> str: + """Keep generated lexical storage apart from every syntax spelling.""" + if self._block_var_taken is None: + self._block_var_taken = set() + for item, _depth in iter_ast_nodes(self._ast): + if self._budget is not None: + self._budget.check(item.loc, Phase.ANALYZER) + for attr in ("name", "var", "member"): + value = getattr(item, attr, None) + if isinstance(value, str): + self._block_var_taken.add(value) + for attr in ("names", "vars", "params", "members"): + self._block_var_taken.update( + value for value in (getattr(item, attr, None) or ()) + if isinstance(value, str) + ) + while True: + if self._budget is not None: + self._budget.check(node.loc, Phase.ANALYZER) + self._block_var_seq += 1 + member_name = f"{node.name}__blk{self._block_var_seq}" + if member_name not in self._block_var_taken: + self._block_var_taken.add(member_name) + return member_name + def _visit_VarDecl(self, node: VarDecl) -> PineType: if (not node.is_var and not node.is_varip and node.type_hint is None and isinstance(node.value, NaLiteral) @@ -5276,8 +5302,7 @@ def _visit_VarDecl(self, node: VarDecl) -> PineType: self._block_var_owner[node.name] = block_id elif owner != block_id: # Sibling-scope collision: disambiguate this declaration. - self._block_var_seq += 1 - member_name = f"{node.name}__blk{self._block_var_seq}" + member_name = self._allocate_block_var_member(node) self._block_var_renames.setdefault(block_id, {})[node.name] = member_name self._var_members.append((member_name, val_type, init_str)) scope_cursor = self._symbols.current_scope diff --git a/pineforge_codegen/codegen/base.py b/pineforge_codegen/codegen/base.py index 6bd0a8ad..8d395f90 100644 --- a/pineforge_codegen/codegen/base.py +++ b/pineforge_codegen/codegen/base.py @@ -736,7 +736,12 @@ def func_var_storage(owner: str, raw_name: str) -> str: remap = {} for orig_name in orig_names: safe = self._safe_name(orig_name) - remap[safe] = f"{safe}_cs{cs_idx}" + # Several enclosing owners can refer to the same clone. + # Its identity belongs to the original member + callsite, + # independently of which owner first requests its name. + remap[safe] = self._generated_class_name( + ("var-clone", safe, cs_idx), f"{safe}_cs{cs_idx}" + ) self._func_cs_var_remap[(fname, cs_idx)] = remap self._func_var_members_set.update( orig_name for orig_name in orig_names) @@ -1221,8 +1226,8 @@ def func_var_storage(owner: str, raw_name: str) -> str: _h = _hints[_i] if _i < len(_hints) else None if _h and str(_h).replace(" ", "") in _SKIP_DECL_TYPES: self._visual_drop_vars.add(_p) - # Build set of all member names (series vars, var members) for collision - # detection. It precedes the security metadata below: a timeframe + # Build the authored/analyzer data-member inventory for callable name + # collisions. It precedes the security metadata below: a timeframe # computed by a user function (``tf = tfFromLabel(choice)``) renders # that call through ``_func_safe_name`` at registration time. self._all_member_names: set[str] = set() @@ -1230,6 +1235,15 @@ def func_var_storage(owner: str, raw_name: str) -> str: self._all_member_names.add(self._safe_name(name)) for name, _, _ in ctx.var_members: self._all_member_names.add(self._safe_name(name)) + for name, _ptype in ctx.global_var_decls: + self._all_member_names.add(self._safe_name(name)) + # Freeze natural callable identities before security rendering and + # later support allocators. Calls and declarations must use this same + # allocation even when an authored member is spelled like a clone. + for fi in ctx.func_infos: + self._func_cpp_base_name(fi.name) + for cs_idx in range(ctx.func_call_site_counts.get(fi.name, 0)): + self._func_variant_name(fi.name, cs_idx) # Collect request.security metadata per call self._security_eval_info: list[dict] = [] self._security_ta_variant_names: dict[tuple[int, int, tuple], str] = {} @@ -1573,6 +1587,7 @@ def _prepare_runtime_scalar_var_initializers(self) -> None: self._runtime_var_init_flags: dict[tuple[int, str], str] = {} used_names = set(self._all_member_names) + used_names.update(self._generated_class_names.values()) # ``_all_member_names`` historically covers persistent ``var`` and # Series members only. Plain global declarations are class members as # well, so include them before minting a generated flag; otherwise a @@ -1609,7 +1624,7 @@ def _prepare_runtime_scalar_var_initializers(self) -> None: for callsite in range( self.ctx.func_call_site_counts.get(func_info.name, 0) ): - used_names.add(f"{emitted}_cs{callsite}") + used_names.add(self._func_variant_name(func_info.name, callsite)) used_names.update(inst["name"] for inst in self._fresh_instances) def allocate_flag(base: str) -> str: @@ -2059,7 +2074,7 @@ def fixnan_originals(fname: str) -> list[str]: return list(self._func_cs_fixnan_remap.get((fname, 0), {}).keys()) def natural_name(fname: str, cs_idx: int) -> str: - return f"{self._func_cpp_base_name(fname)}_cs{cs_idx}" + return self._func_variant_name(fname, cs_idx) interned: dict[tuple, dict] = {} worklist: list[dict] = [] @@ -2178,17 +2193,28 @@ def natural_name(fname: str, cs_idx: int) -> str: ginst = interned.get(key) if ginst is None: fresh_counter += 1 - inst_name = f"{self._func_cpp_base_name(g_name)}__ni{fresh_counter}" + inst_name = self._generated_class_name( + ("function-instance", fresh_counter), + f"{self._func_cpp_base_name(g_name)}__ni{fresh_counter}", + ) fvar_remap: dict[str, str] = {} for v in var_originals(g_name): - fresh_member = f"{v}__ni{fresh_counter}" + fresh_member = self._generated_class_name( + ("var-instance", fresh_counter, v), + f"{v}__ni{fresh_counter}", + ) fvar_remap[v] = fresh_member self._fresh_var_members.append((g_name, v, fresh_member)) # Fresh fixnan members: each path gets its OWN previous- # value member so two call paths never share fixnan state. + # These are the owners of the reserved fixnan namespace, + # rather than identities composed from Pine spellings. ffixnan_remap: dict[str, str] = {} for orig_fn_member in fixnan_originals(g_name): - fresh_fn_member = f"{orig_fn_member}__ni{fresh_counter}" + fresh_fn_member = self._generated_helper_name( + ("fixnan-instance", fresh_counter, orig_fn_member), + f"{orig_fn_member}__ni{fresh_counter}", + ) ffixnan_remap[orig_fn_member] = fresh_fn_member # Find the original FixnanCallSite to carry its type. orig_fn_site = None @@ -3948,6 +3974,15 @@ def _func_cpp_base_name(self, fname: str) -> str: return self._emit_udt_method_cpp_name(fi) return self._func_safe_name(fname) + def _func_variant_name(self, fname: str, cs_idx: int) -> str: + """Resolve a callable clone once for emission, dispatch and history.""" + name = self._generated_class_name( + ("function-clone", fname, cs_idx), + f"{self._func_cpp_base_name(fname)}_cs{cs_idx}", + ) + self._func_variant_callsite[(fname, name)] = cs_idx + return name + def _inline_history_contexts_for_owner(self, owner: str | None) -> list[str | None]: """Return every method-emission context that owns one source AST site. @@ -3970,7 +4005,7 @@ def _inline_history_contexts_for_owner(self, owner: str | None) -> list[str | No ) and total_cs > 0 if cloned: contexts: list[str | None] = [ - f"{self._func_cpp_base_name(owner)}_cs{idx}" + self._func_variant_name(owner, idx) for idx in range(total_cs) ] else: @@ -4131,11 +4166,7 @@ def owner_cs_for_context( ) -> int | None: if owner is None or context is None: return None - prefix = f"{self._func_cpp_base_name(owner)}_cs" - if not context.startswith(prefix): - return None - suffix = context[len(prefix):] - return int(suffix) if suffix.isdigit() else None + return self._func_variant_callsite.get((owner, context)) def target_cs_for_context( fi, @@ -4271,7 +4302,7 @@ def emitted_context_for_call( fi, call, owner, owner_context ) if target_cs is not None: - return f"{self._func_cpp_base_name(fi.name)}_cs{target_cs}" + return self._func_variant_name(fi.name, target_cs) return None requested_roots: set[tuple[str, str | None]] = set() @@ -4733,6 +4764,7 @@ def _prepare_udt_generated_names(self) -> None: getattr(self, "_runtime_var_init_flag_used_names", ()) ) class_used.update(self._all_member_names) + class_used.update(self._generated_class_names.values()) class_used.update( self._safe_name(name) for name in self._all_bound_names ) @@ -6209,12 +6241,14 @@ def allocate_legacy_flag(base: str) -> str: for fi in self.ctx.func_infos: if fi.name not in self.ctx.func_var_members: continue - emitted = self._func_cpp_base_name(fi.name) total_cs = self.ctx.func_call_site_counts.get(fi.name, 0) variants = range(total_cs) if total_cs > 0 else (None,) for cs_idx in variants: - suffix = f"_cs{cs_idx}" if cs_idx is not None else "" - flag = allocate_legacy_flag(f"_fvinit_{emitted}{suffix}") + emitted = ( + self._func_variant_name(fi.name, cs_idx) + if cs_idx is not None else self._func_cpp_base_name(fi.name) + ) + flag = allocate_legacy_flag(f"_fvinit_{emitted}") lines.append(f" bool {flag} = false;") for inst in self._fresh_instances: diff --git a/pineforge_codegen/codegen/emit_top.py b/pineforge_codegen/codegen/emit_top.py index d9c67b33..c23911e4 100644 --- a/pineforge_codegen/codegen/emit_top.py +++ b/pineforge_codegen/codegen/emit_top.py @@ -2358,10 +2358,14 @@ def _emit_udt_method_cpp_name(self, fi: FuncInfo) -> str: allocated = {} for key, name in methods: encoded = cpp_identifier_fragment(name) - allocated[key] = ( + preferred = ( name if encoded == name else self._allocate_generated_cpp_name(encoded, used) ) + allocated[key] = self._generated_class_name( + ("typed-method", key), preferred + ) + used.add(allocated[key]) self._escaped_method_cpp_names = allocated return self._func_safe_name(allocated[fi.name]) @@ -2703,7 +2707,7 @@ def _emit_func_def_body(self, fi: FuncInfo, lines: list[str], self._active_call_site_idx = None self._current_instance_name = instance["name"] elif call_site_idx is not None: - func_name = f"{func_name}_cs{call_site_idx}" + func_name = self._func_variant_name(fi.name, call_site_idx) remap = self._func_cs_ta_remap.get((fi.name, call_site_idx), {}) self._active_ta_remap = remap var_remap = self._func_cs_var_remap.get((fi.name, call_site_idx), {}) diff --git a/pineforge_codegen/codegen/helpers.py b/pineforge_codegen/codegen/helpers.py index d0d666cc..b5274b03 100644 --- a/pineforge_codegen/codegen/helpers.py +++ b/pineforge_codegen/codegen/helpers.py @@ -717,6 +717,14 @@ def _initialise_safe_names(self, ast) -> None: ctx = getattr(self, "ctx", None) if "time_close" in getattr(ctx, "series_vars", ()): bound.add("time_close") + # Sibling-block and owner-qualified persistent identities need not + # occur in the syntax. Reserve them before escaping any name, and let + # their declarations and consumers use the same safe-name mapping. + storage_names = { + name for name, _, _ in getattr(ctx, "var_members", ()) + } + bound.update(storage_names) + authored.update(storage_names) self._safe_name_map: dict[str, str] = {} self._safe_name_occupied = authored self._safe_name_bound = bound @@ -750,6 +758,43 @@ def _initialise_safe_names(self, ast) -> None: self._local_function_names[name] = self._safe_name(name) self._allocate_safe_name(name) + # Analyzer-qualified storage (including sibling-block members) and + # TA/fixnan sites can have names absent from the authored AST. Clones + # and generated methods share their C++ class namespace. Reserve exact + # identities, rather than treating every authored _csN suffix as private. + self._safe_name_occupied.update( + self._safe_name(name) for name in member_names + ) + self._safe_name_occupied.update( + self._safe_name(name) + for name, _ptype in getattr(ctx, "global_var_decls", ()) + ) + for sites in ( + getattr(ctx, "ta_call_sites", ()), + getattr(ctx, "fixnan_sites", ()), + ): + self._safe_name_occupied.update(site.member_name for site in sites) + self._generated_class_names: dict[tuple, str] = {} + self._func_variant_callsite: dict[tuple[str, str], int] = {} + + def _generated_class_name(self, key: tuple, preferred: str) -> str: + """Allocate a composed Pine identity outside fixed helper namespaces.""" + if (preferred in CPP_RESERVED or preferred in BUILTIN_ACCESSOR_NAMES + or is_emitter_temporary(preferred)): + # Suffixing a reserved family such as _secN_* never escapes it. + # Change the leading token before checking exact occupied names. + preferred = f"pf_safe_{preferred}" + return self._generated_helper_name(key, preferred) + + def _generated_helper_name(self, key: tuple, preferred: str) -> str: + """Allocate one stable identity, including a helper's own namespace.""" + allocated = self._generated_class_names + if key not in allocated: + allocated[key] = self._allocate_generated_cpp_name( + preferred, self._safe_name_occupied + ) + return allocated[key] + def _allocate_safe_name(self, name: str) -> str: if name in LEGACY_CPP_RESERVED or name in BUILTIN_ACCESSOR_NAMES: base = f"_{name}_" @@ -784,12 +829,14 @@ def _safe_name(self, name: str) -> str: return name def _func_safe_name(self, name: str) -> str: - """Prefix function names that collide with class members (series vars or var members).""" + """Allocate function names that collide with class data members.""" safe = getattr(self, "_local_function_names", {}).get( name, self._safe_name(name), ) if safe in self._all_member_names: - return f"_fn_{safe}" + return self._generated_class_name( + ("function", name), f"_fn_{safe}" + ) return safe def _resolve_callee(self, callee) -> tuple[str | None, str | None]: diff --git a/pineforge_codegen/codegen/ta.py b/pineforge_codegen/codegen/ta.py index 765796f6..29b2985a 100644 --- a/pineforge_codegen/codegen/ta.py +++ b/pineforge_codegen/codegen/ta.py @@ -547,7 +547,7 @@ def allocate(base: str, reserved: set[str]) -> str: reserved_types.add(emitted) total = self.ctx.func_call_site_counts.get(info.name, 0) for callsite in range(total): - reserved_members.add(f"{emitted}_cs{callsite}") + reserved_members.add(self._func_variant_name(info.name, callsite)) for instance in getattr(self, "_fresh_instances", ()): reserved_members.add(instance["name"]) self._lazy_source_clock_type_name = allocate("_PFLazySourceClock", reserved_types) diff --git a/pineforge_codegen/codegen/visit_call.py b/pineforge_codegen/codegen/visit_call.py index efb19c5c..3fe33c25 100644 --- a/pineforge_codegen/codegen/visit_call.py +++ b/pineforge_codegen/codegen/visit_call.py @@ -428,12 +428,12 @@ def _udt_method_call_emit_name(self, fi, node: FuncCall) -> str: cs_info = self.ctx.func_call_cs_map.get(id(node)) if self._active_call_site_idx is not None and cs_info is not None: - return f"{base}_cs{self._active_call_site_idx}" + return self._func_variant_name(fi.name, self._active_call_site_idx) if cs_info is not None and cs_info[0] == fi.name: - return f"{base}_cs{cs_info[1]}" + return self._func_variant_name(fi.name, cs_info[1]) if (self._active_call_site_idx is not None and self.ctx.func_call_site_counts.get(fi.name, 0) > 1): - return f"{base}_cs{self._active_call_site_idx}" + return self._func_variant_name(fi.name, self._active_call_site_idx) return base def _typed_user_method_info(self, receiver, member: str): @@ -3612,16 +3612,16 @@ def _visit_arg_for_series(arg_node, arg_idx): # the parent's active call-site index. This ensures sub-functions # called from ma_cs6() use their _cs6 variant, not _cs0. fname, _ = cs_info - emit_name = f"{self._func_safe_name(fname)}_cs{self._active_call_site_idx}" + emit_name = self._func_variant_name(fname, self._active_call_site_idx) elif cs_info is not None: fname, cs_idx = cs_info - emit_name = f"{self._func_safe_name(fname)}_cs{cs_idx}" + emit_name = self._func_variant_name(fname, cs_idx) elif (self._active_call_site_idx is not None and func_name in self._func_names and self.ctx.func_call_site_counts.get(func_name, 0) > 1): # Inside a per-call-site variant: propagate call-site index to # sub-functions that also have variants (for state isolation) - emit_name = f"{self._func_safe_name(func_name)}_cs{self._active_call_site_idx}" + emit_name = self._func_variant_name(func_name, self._active_call_site_idx) call_head = emit_name if namespace is None and func_name in self._func_names: return self._ordered_user_call_expr( diff --git a/tests/test_clone_name_allocation.py b/tests/test_clone_name_allocation.py new file mode 100644 index 00000000..348a3143 --- /dev/null +++ b/tests/test_clone_name_allocation.py @@ -0,0 +1,638 @@ +"""Generated state and methods share a namespace with authored identifiers.""" + +from __future__ import annotations + +import os +import re +from unittest.mock import patch + +import pytest + +from pineforge_codegen import transpile +from pineforge_codegen.codegen import CodeGen +from pineforge_codegen.codegen.helpers import is_emitter_temporary +from tests._compile import compile_cpp +from tests._e2e import reference_codegen, transpile_json + + +_VAR_CLONE = """//@version=6 +strategy("clone member spelling") +f() => + var float acc = 0.0 + acc += ta.ema(close, 3) + acc +a = f() +b = f() +var float acc_cs1 = 0.0 +acc_cs1 := acc_cs1 + 1.0 +plot(a + b + acc_cs1) +""" + +_METHOD_CLONE = """//@version=6 +strategy("clone method spelling") +f(src) => ta.ema(src, 3) +a = f(close) +b = f(open) +var float f_cs1 = 2.0 +plot(a + b + f_cs1) +""" + +_COLLECTION_CLONE = """//@version=6 +strategy("clone versus collection history") +f() => + var float _pf_collection_hist = 0.0 + _pf_collection_hist += ta.ema(close, 3) + _pf_collection_hist +a = f() +b = f() +var cs1 = array.new(1, 0.0) +array.set(cs1, 0, close) +prev = cs1[1] +plot(a + b + (na(prev) ? 0.0 : array.get(prev, 0))) +""" + +_SECURITY_CLONE = """//@version=6 +strategy("clone versus security state") +f() => + var float _sec1 = 0.0 + _sec1 += ta.ema(close, 3) + _sec1 +a = f() +b = f() +c = f() +var float cs2 = 0.0 +cs2 := cs2 + 1.0 +h() => close + cs2 +v0 = request.security(syminfo.tickerid, "60", close) +v1 = request.security(syminfo.tickerid, "60", h()) +plot(a + b + c + v0 + v1) +""" + +_BLOCK_MEMBER = """//@version=6 +strategy("block member spelling") +var float x__blk1 = 100.0 +float up = na +float down = na +if close > open + var float x = 0.0 + x += 1.0 + up := x +if close <= open + var float x = 0.0 + x += 2.0 + down := x +plot(x__blk1) +plot(nz(up) + nz(down)) +""" + +_RESERVED_CALLABLE = """//@version=6 +strategy("reserved callable history") +inner(float src) => src[1] +_sec7(float src) => inner(src + 1.0) +a = _sec7(close) +b = _sec7(open) +plot(a + b) +""" + +_FUNCTION_HISTORY_PREFIX = """//@version=6 +strategy("callable prefix and global history") +global_hist_1(float src) => src + 1.0 +var float global_hist_1 = 10.0 +a = global_hist_1(close) +var float total = 0.0 +total += close +observe() => total[1] +b = observe() +plot(a + global_hist_1 + b) +""" + +_FRESH_FIXNAN = """//@version=6 +strategy("nested fixnan storage") +leaf(float src) => fixnan(src) +left(float src) => leaf(src) +right(float src) => leaf(src) +a = left(bar_index % 3 == 0 ? na : close) +b = left(bar_index % 4 == 0 ? na : open) +c = right(bar_index % 5 == 0 ? na : high) +plot(a + b + c) +""" + + +def _emit(source: str) -> tuple[CodeGen, str]: + # Observe the actual final generator without replacing any pipeline pass. + # Public transpile still runs support checks, re-analysis and the allowlist. + generated: list[CodeGen] = [] + generate = CodeGen.generate + + def record(generator: CodeGen) -> str: + cpp = generate(generator) + generated.append(generator) + return cpp + + with patch.object(CodeGen, "generate", record): + cpp = transpile(source, check_support=True, libraries={}) + return generated[-1], cpp + + +def _scalar_member(cpp: str, name: str) -> None: + declarations = re.findall( + rf"^ double {re.escape(name)}(?: = [^;\n]+)?;$", cpp, re.M + ) + assert len(declarations) == 1, name + + +def _method_body(cpp: str, name: str) -> str: + declarations = list(re.finditer( + rf"^ double {re.escape(name)}\([^\n]*\) \{{\n", cpp, re.M + )) + assert len(declarations) == 1, name + start = declarations[0].end() + return cpp[start:cpp.index("\n }", start)] + + +def _has_identifier(cpp: str, name: str) -> bool: + return re.search(rf"\b{re.escape(name)}\b", cpp) is not None + + +@pytest.mark.parametrize("spelling", ["acc_cs1", "aa"]) +def test_persistent_clone_reproducer_and_rename_control(spelling: str) -> None: + generator, cpp = _emit(_VAR_CLONE.replace("acc_cs1", spelling)) + clone = generator._func_cs_var_remap[("f", 1)]["acc"] + + assert generator._safe_name(spelling) == spelling + _scalar_member(cpp, spelling) + _scalar_member(cpp, clone) + assert clone == ("acc_cs1__pf2" if spelling == "acc_cs1" else "acc_cs1") + body = _method_body(cpp, "f_cs1") + assert _has_identifier(body, clone) + assert not _has_identifier(body, spelling) + assert re.search(rf"return {re.escape(clone)};", body) + compile_cpp(cpp, label=f"persistent-clone-{spelling}") + + +@pytest.mark.parametrize("spelling", ["f_cs1", "aa"]) +def test_callable_clone_reproducer_and_rename_control(spelling: str) -> None: + generator, cpp = _emit(_METHOD_CLONE.replace("f_cs1", spelling)) + first = generator._func_variant_name("f", 0) + second = generator._func_variant_name("f", 1) + + assert generator._safe_name(spelling) == spelling + _scalar_member(cpp, spelling) + assert first == "f_cs0" + assert second == ("f_cs1__pf2" if spelling == "f_cs1" else "f_cs1") + for output, method in (("a", first), ("b", second)): + _method_body(cpp, method) + assert re.search(rf"\b{output} = {re.escape(method)}\(", cpp) + compile_cpp(cpp, label=f"callable-clone-{spelling}") + + +def test_clone_fallback_also_avoids_authored_fallback_spelling() -> None: + source = ( + _VAR_CLONE + + "var float acc_cs1__pf2 = 7.0\n" + + "plot(acc_cs1__pf2)\n" + ) + generator, cpp = _emit(source) + clone = generator._func_cs_var_remap[("f", 1)]["acc"] + + assert clone == "acc_cs1__pf3" + for name in ("acc_cs1", "acc_cs1__pf2", clone): + _scalar_member(cpp, name) + body = _method_body(cpp, "f_cs1") + assert _has_identifier(body, clone) + assert not _has_identifier(body, "acc_cs1__pf2") + compile_cpp(cpp, label="occupied-clone-fallback") + + +def test_clone_member_cannot_be_hidden_by_an_authored_parameter() -> None: + generator, cpp = _emit("""//@version=6 +strategy("clone parameter spelling") +f(float acc_cs1) => + var float acc = 0.0 + acc += acc_cs1 + acc +a = f(close) +b = f(open) +plot(a + b) +""") + clone = generator._func_cs_var_remap[("f", 1)]["acc"] + assert clone == "acc_cs1__pf2" + _scalar_member(cpp, clone) + body = _method_body(cpp, "f_cs1") + assert _has_identifier(body, "acc_cs1") + assert _has_identifier(body, clone) + assert re.search(rf"return {re.escape(clone)};", body) + compile_cpp(cpp, label="clone-versus-parameter") + + +@pytest.mark.parametrize("storage", ["var ", ""], ids=["persistent", "ordinary"]) +def test_function_member_prefix_is_allocated_against_authored_members( + storage: str, +) -> None: + source = """//@version=6 +strategy("callable prefix spelling") +echo(float src) => src + 1.0 +var float echo = 10.0 +var float _fn_echo = 20.0 +a = echo(close) +plot(a + echo + _fn_echo) +""" + generator, cpp = _emit(source.replace("var float ", f"{storage}float ")) + method = generator._func_cpp_base_name("echo") + + assert method == "_fn_echo__pf2" + _method_body(cpp, method) + assert re.search(rf"\ba = {re.escape(method)}\(", cpp) + for name in ("echo", "_fn_echo"): + assert generator._safe_name(name) == name + _scalar_member(cpp, name) + compile_cpp(cpp, label="occupied-function-prefix") + + +def test_generated_method_base_cannot_alias_generated_storage_clone() -> None: + generator, cpp = _emit("""//@version=6 +strategy("generated method and storage spelling") +type Holder + float value +method sample_cs1(Holder self) => self.value +leaf() => + var float _udt_Holder_sample = 0.0 + _udt_Holder_sample += close + _udt_Holder_sample +a = leaf() +b = leaf() +var Holder holder = Holder.new(3.0) +c = holder.sample_cs1() +plot(a + b + c) +""") + storage = generator._func_cs_var_remap[("leaf", 1)]["_udt_Holder_sample"] + info = next(fi for fi in generator.ctx.func_infos if fi.is_udt_method) + method = generator._func_cpp_base_name(info.name) + + assert storage == "_udt_Holder_sample_cs1" + assert method == "_udt_Holder_sample_cs1__pf2" + _scalar_member(cpp, storage) + _method_body(cpp, method) + assert re.search(rf"\bc = {re.escape(method)}\(", cpp) + compile_cpp(cpp, label="generated-method-versus-storage") + + +def test_nested_instances_reserve_authored_method_and_state_spellings() -> None: + generator, cpp = _emit("""//@version=6 +strategy("nested instance spelling") +leaf(int size, float src) => + var float state = 0.0 + state += ta.highest(src, size) + state +f_get(int len, float src) => leaf(len, src) +g_get(int len, float src) => leaf(len, src) +a = f_get(10, close) +b = f_get(20, open) +c = g_get(30, high) +var float leaf__ni1 = 2.0 +var float state__ni1 = 3.0 +plot(a + b + c + leaf__ni1 + state__ni1) +""") + authored = {"leaf__ni1", "state__ni1"} + assert generator._fresh_instances + generated: list[str] = [] + for instance in generator._fresh_instances: + method = instance["name"] + generated.append(method) + body = _method_body(cpp, method) + for storage in instance["var_remap"].values(): + generated.append(storage) + _scalar_member(cpp, storage) + assert _has_identifier(body, storage) + assert all(not _has_identifier(body, name) for name in authored) + assert authored.isdisjoint(generated) + assert len(generated) == len(set(generated)) + assert "leaf__ni1__pf2" in generated + assert "state__ni1__pf2" in generated + for name in authored: + _scalar_member(cpp, name) + compile_cpp(cpp, label="occupied-nested-instances") + + +def test_renamed_callable_context_keeps_compound_argument_history() -> None: + generator, cpp = _emit("""//@version=6 +strategy("clone context history spelling") +inner(float src) => src[1] +wrapped(float src) => inner(src + 1.0) +a = wrapped(close) +b = wrapped(open) +var float wrapped_cs1 = 2.0 +plot(a + b + wrapped_cs1) +""") + contexts = generator._inline_history_contexts_for_owner("wrapped") + assert contexts == ["wrapped_cs0", "wrapped_cs1__pf2"] + bridges = [ + info for info in generator._inline_history_members + if info["kind"] in {"series_arg", "udf_series_arg"} + ] + assert set(contexts) <= {info["context"] for info in bridges} + for index, context in enumerate(contexts): + assert generator._func_variant_callsite[("wrapped", context)] == index + body = _method_body(cpp, context) + owned = [info for info in bridges if info["context"] == context] + assert all(_has_identifier(body, info["member_name"]) for info in owned) + compile_cpp(cpp, label="renamed-callable-history-context") + + +@pytest.mark.parametrize("named", [False, True], ids=["positional", "named"]) +def test_typed_method_variants_reserve_authored_clone_spelling(named: bool) -> None: + source = """//@version=6 +strategy("typed method clone spelling") +type Holder + float seed +method sample(Holder self, float src) => self.seed + src[1] +var Holder holder = Holder.new(3.0) +a = holder.sample(close + 1.0) +b = holder.sample(open + 1.0) +var float _udt_Holder_sample_cs1 = 2.0 +plot(a + b + _udt_Holder_sample_cs1) +""" + if named: + source = source.replace( + "sample(close + 1.0)", "sample(src=close + 1.0)", + ).replace("sample(open + 1.0)", "sample(src=open + 1.0)") + generator, cpp = _emit(source) + info = next(fi for fi in generator.ctx.func_infos if fi.is_udt_method) + first = generator._func_variant_name(info.name, 0) + second = generator._func_variant_name(info.name, 1) + + assert first == "_udt_Holder_sample_cs0" + assert second == "_udt_Holder_sample_cs1__pf2" + _scalar_member(cpp, "_udt_Holder_sample_cs1") + for output, method in (("a", first), ("b", second)): + _method_body(cpp, method) + assert re.search(rf"\b{output} = {re.escape(method)}\(", cpp) + assert any(info["kind"] == "series_arg" + for info in generator._inline_history_members) + compile_cpp(cpp, label="occupied-typed-method-clone") + + +@pytest.mark.parametrize("spelling", ["cs1", "aa"]) +def test_clone_and_collection_history_keep_distinct_state(spelling: str) -> None: + generator, cpp = _emit(re.sub(r"\bcs1\b", spelling, _COLLECTION_CLONE)) + clone = generator._func_cs_var_remap[("f", 1)]["_pf_collection_hist"] + variable, = generator._collection_history_variables() + history = generator._collection_history_member(variable) + + assert clone == "pf_safe__pf_collection_hist_cs1" + assert history == f"_pf_collection_hist_{spelling}" + assert clone != history + _scalar_member(cpp, clone) + body = _method_body(cpp, "f_cs1") + assert _has_identifier(body, clone) + assert not _has_identifier(body, history) + assert f"return {clone};" in body + assert f"{history}.open_slot({spelling}," in cpp + assert re.search(rf"{re.escape(history)}\.(?:reference|value)\(1\)", cpp) + assert f"{history}.close({spelling}" in cpp + compile_cpp(cpp, label=f"clone-collection-history-{spelling}") + + +def test_reserved_authored_escape_and_composed_clone_do_not_alias() -> None: + generator, cpp = _emit( + _COLLECTION_CLONE + + "var float _pf_collection_hist_cs1 = 7.0\n" + + "plot(_pf_collection_hist_cs1)\n" + ) + authored = generator._safe_name("_pf_collection_hist_cs1") + clone = generator._func_cs_var_remap[("f", 1)]["_pf_collection_hist"] + assert authored == "pf_safe__pf_collection_hist_cs1" + assert clone == f"{authored}__pf2" + for member in (authored, clone): + _scalar_member(cpp, member) + body = _method_body(cpp, "f_cs1") + assert f"return {clone};" in body + assert not _has_identifier(body, authored) + compile_cpp(cpp, label="authored-escape-versus-composed-clone") + + +@pytest.mark.parametrize("spelling", ["cs2", "aa"]) +def test_clone_and_requested_mutable_state_stay_distinct(spelling: str) -> None: + generator, cpp = _emit(re.sub(r"\bcs2\b", spelling, _SECURITY_CLONE)) + clone = generator._func_cs_var_remap[("f", 2)]["_sec1"] + state = generator._security_state_name(1, spelling) + + assert clone == "pf_safe__sec1_cs2" + assert state == f"_sec1_{spelling}" + assert clone != state + assert _has_identifier(cpp, state) + _scalar_member(cpp, clone) + body = _method_body(cpp, "f_cs2") + assert _has_identifier(body, clone) + assert not _has_identifier(body, state) + assert f"return {clone};" in body + compile_cpp(cpp, label=f"clone-requested-state-{spelling}") + + +@pytest.mark.parametrize("spelling", ["x__blk1", "aa"]) +def test_sibling_storage_avoids_an_authored_derived_name(spelling: str) -> None: + generator, cpp = _emit(_BLOCK_MEMBER.replace("x__blk1", spelling)) + members = [ + meta[1] for meta in generator.ctx.var_member_metadata_by_node.values() + if meta[0].name == "x" + ] + assert members == ["x", "x__blk2" if spelling == "x__blk1" else "x__blk1"] + assert spelling not in members + for member in [spelling, *members]: + _scalar_member(cpp, member) + assert f"up = {members[0]};" in cpp + assert f"down = {members[1]};" in cpp + assert f"{members[0]} += 1.0;" in cpp + assert f"{members[1]} += 2.0;" in cpp + compile_cpp(cpp, label=f"sibling-storage-{spelling}") + + +@pytest.mark.parametrize("stem", [ + "_pf_collection_hist", "_sec7", "_precalc", "_strat", +]) +def test_composed_reserved_storage_avoids_a_parameter_at_its_escape( + stem: str, +) -> None: + parameter = f"pf_safe_{stem}_cs1" + generator, cpp = _emit(f"""//@version=6 +strategy("reserved clone parameter") +f(float {parameter}) => + var float {stem} = 0.0 + {stem} += {parameter} + {stem} +a = f(close) +b = f(open) +plot(a + b) +""") + clone = generator._func_cs_var_remap[("f", 1)][stem] + assert is_emitter_temporary(f"{stem}_cs1") + assert not is_emitter_temporary(clone) + assert clone == f"{parameter}__pf2" + _scalar_member(cpp, clone) + body = _method_body(cpp, "f_cs1") + assert _has_identifier(body, parameter) + assert _has_identifier(body, clone) + assert f"return {clone};" in body + checkpoint = cpp.split("_pf_script_state_checkpoint_.emplace(_PFScriptState{", 1)[1] + checkpoint = checkpoint.split("\n });", 1)[0] + assert re.search(rf"^\s+{re.escape(clone)},$", checkpoint, re.M) + compile_cpp(cpp, label="reserved-clone-versus-escaped-parameter") + + +@pytest.mark.parametrize("named", [False, True], ids=["positional", "named"]) +def test_reserved_callable_variants_keep_their_history_contexts(named: bool) -> None: + source = _RESERVED_CALLABLE + if named: + source = source.replace( + "_sec7(close)", "_sec7(src=close)", + ).replace("_sec7(open)", "_sec7(src=open)") + generator, cpp = _emit(source) + contexts = generator._inline_history_contexts_for_owner("_sec7") + assert contexts == ["pf_safe__sec7_cs0", "pf_safe__sec7_cs1"] + bridges = [ + info for info in generator._inline_history_members + if info["kind"] in {"series_arg", "udf_series_arg"} + ] + for index, context in enumerate(contexts): + assert generator._func_variant_callsite[("_sec7", context)] == index + body = _method_body(cpp, context) + owned = [info for info in bridges if info["context"] == context] + assert owned + assert all(_has_identifier(body, info["member_name"]) for info in owned) + assert re.search(rf"\b{'ab'[index]} = {context}\(", cpp) + compile_cpp(cpp, label="reserved-callable-history-contexts") + + +def test_callable_prefix_cannot_capture_fixed_global_history_storage() -> None: + generator, cpp = _emit(_FUNCTION_HISTORY_PREFIX) + method = generator._func_cpp_base_name("global_hist_1") + assert method == "pf_safe__fn_global_hist_1" + _method_body(cpp, method) + assert re.search(rf"\ba = {method}\(", cpp) + assert re.search(r"^ Series _fn_global_hist_1;$", cpp, re.M) + assert any( + info["kind"] == "fn_global_hist" and info["member_name"] == "_fn_global_hist_1" + for info in generator._inline_history_members + ) + _scalar_member(cpp, "global_hist_1") + compile_cpp(cpp, label="callable-prefix-versus-global-history") + + +def test_sibling_allocation_reserves_later_names_and_history_storage() -> None: + source = _BLOCK_MEMBER.replace("up := x", "up := nz(x[1])").replace( + "down := x", "down := nz(x[1])", + ) + "var float x__blk2 = 7.0\nplot(x__blk2)\n" + generator, cpp = _emit(source) + members = [ + generator._safe_name(meta[1]) + for meta in generator.ctx.var_member_metadata_by_node.values() + if meta[0].name == "x" + ] + assert members == ["x", "x__blk3"] + for member in members: + assert member in generator._series_var_member_names + assert re.search(rf"^ Series {member};$", cpp, re.M) + for output, member in zip(("up", "down"), members): + assignment = [ + line for line in cpp.splitlines() if re.match(rf"\s+{output} = ", line) + ][-1] + assert _has_identifier(assignment, member) + _scalar_member(cpp, "x__blk1") + _scalar_member(cpp, "x__blk2") + compile_cpp(cpp, label="sibling-later-name-and-history") + + +def test_analyzer_only_storage_uses_collision_safe_cpp_escaping() -> None: + source = re.sub( + r"\bx\b", "_sec7", + _BLOCK_MEMBER.replace("x__blk1", "pf_safe__sec7__blk1"), + ) + generator, cpp = _emit(source) + members = [ + meta[1] for meta in generator.ctx.var_member_metadata_by_node.values() + if meta[0].name == "_sec7" + ] + assert members == ["_sec7", "_sec7__blk1"] + safe = generator._safe_name(members[1]) + assert safe == "pf_safe__sec7__blk1_2" + for member in ["pf_safe__sec7__blk1", members[0], safe]: + _scalar_member(cpp, member) + assert f"up = {members[0]};" in cpp + assert f"down = {safe};" in cpp + compile_cpp(cpp, label="analyzer-storage-escaping") + + +def test_callable_block_storage_keeps_parameters_and_clones_distinct() -> None: + generator, cpp = _emit("""//@version=6 +strategy("callable block member spelling") +f(float x__blk1) => + float result = x__blk1 + if close > open + var float x = 0.0 + x += x__blk1 + result += x + if close <= open + var float x = 0.0 + x += x__blk1 * 2.0 + result += x + result +a = f(close) +b = f(open) +plot(a + b) +""") + assert generator.ctx.block_var_renames + for index in (0, 1): + remap = generator._func_cs_var_remap[("f", index)] + members = [remap[name] for name in ("x", "x__blk2")] + assert len(set(members)) == 2 + body = _method_body(cpp, f"f_cs{index}") + assert "double x__blk1" in cpp + assert _has_identifier(body, "x__blk1") + for member in members: + _scalar_member(cpp, member) + assert _has_identifier(body, member) + compile_cpp(cpp, label="callable-block-parameter-and-clones") + + +def test_fixed_fixnan_instances_retain_their_helper_namespace() -> None: + generator, cpp = _emit(_FRESH_FIXNAN) + fresh = generator._fresh_fixnan_members + assert fresh + for site, member in fresh: + assert member.startswith(f"{site.member_name}__ni") + assert not member.startswith("pf_safe_") + _scalar_member(cpp, member) + assert any( + _has_identifier(_method_body(cpp, instance["name"]), member) + for instance in generator._fresh_instances + ) + compile_cpp(cpp, label="fixed-fixnan-instance-namespace") + + +@pytest.fixture(scope="module") +def clone_reference(): + reference = reference_codegen("4e51f6d00e3a015194d93b06e51ad90f2404cc14") + if reference is None: + unavailable = (pytest.fail if os.environ.get("PINEFORGE_REQUIRE_NATIVE") == "1" + else pytest.skip) + unavailable("MISSING INPUT: the clone spelling reference commit is unavailable") + return reference + + +@pytest.mark.parametrize("source, original", [ + (_VAR_CLONE, "acc_cs1"), + (_METHOD_CLONE, "f_cs1"), + (_BLOCK_MEMBER, "x__blk1"), + (_RESERVED_CALLABLE, "_sec7"), + (_FRESH_FIXNAN, None), +]) +def test_noncolliding_controls_keep_complete_reference_cpp( + source, original, clone_reference, tmp_path +) -> None: + if original is not None: + source = source.replace(original, "aa") + pine = tmp_path / "strategy.pine" + pine.write_text(source, encoding="utf-8") + reference = transpile_json(pine, root=clone_reference) + assert reference["ok"], reference + assert transpile(source, check_support=True, libraries={}) == reference["cpp"]