From b2db9774d30fc1a2f8162950dfefbc67edc40bf6 Mon Sep 17 00:00:00 2001 From: luisleo526 <20812494+luisleo526@users.noreply.github.com> Date: Sun, 15 Nov 2026 14:07:38 +0800 Subject: [PATCH 1/2] fix(codegen): allocate function clone names against authored members Keep generated state and callable clone identities distinct from authored members and use the same allocated identities at declarations and calls. Preserve noncolliding names and duplicate-state assertions. --- CHANGELOG.md | 5 + pineforge_codegen/codegen/base.py | 68 ++++-- pineforge_codegen/codegen/emit_top.py | 8 +- pineforge_codegen/codegen/helpers.py | 34 ++- pineforge_codegen/codegen/ta.py | 2 +- pineforge_codegen/codegen/visit_call.py | 12 +- tests/test_clone_name_allocation.py | 299 ++++++++++++++++++++++++ 7 files changed, 399 insertions(+), 29 deletions(-) create mode 100644 tests/test_clone_name_allocation.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 88dac8f9..8e86efa4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,11 @@ 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`. 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/codegen/base.py b/pineforge_codegen/codegen/base.py index 6bd0a8ad..2abc379f 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,26 @@ 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. 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_class_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 +3972,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 +4003,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 +4164,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 +4300,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 +4762,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 +6239,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..d1693e09 100644 --- a/pineforge_codegen/codegen/helpers.py +++ b/pineforge_codegen/codegen/helpers.py @@ -750,6 +750,34 @@ 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 one stable member/method identity outside authored names.""" + 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 +812,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..b55a5d53 --- /dev/null +++ b/tests/test_clone_name_allocation.py @@ -0,0 +1,299 @@ +"""Generated state and methods share a namespace with authored identifiers.""" + +from __future__ import annotations + +import re + +import pytest + +from pineforge_codegen import transpile +from pineforge_codegen.analyzer import Analyzer +from pineforge_codegen.codegen import CodeGen +from pineforge_codegen.lexer import Lexer +from pineforge_codegen.parser import Parser +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) +""" + + +def _emit(source: str) -> tuple[CodeGen, str]: + program = Parser(Lexer(source).tokenize(), source=source).parse() + generator = CodeGen(Analyzer(program).analyze()) + return generator, generator.generate() + + +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") + + +def test_typed_method_variants_reserve_authored_clone_spelling() -> None: + generator, cpp = _emit("""//@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) +""") + 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.fixture(scope="module") +def clone_reference(): + reference = reference_codegen("4e51f6d00e3a015194d93b06e51ad90f2404cc14") + if reference is None: + pytest.skip("The clone spelling reference commit is unavailable") + return reference + + +@pytest.mark.parametrize("source, original", [ + (_VAR_CLONE, "acc_cs1"), + (_METHOD_CLONE, "f_cs1"), +]) +def test_noncolliding_controls_keep_complete_reference_cpp( + source, original, clone_reference, tmp_path +) -> 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) == reference["cpp"] From 4da8042d9d00f671ec6afcc957fb59a3e1d652bc Mon Sep 17 00:00:00 2001 From: luisleo526 <20812494+luisleo526@users.noreply.github.com> Date: Sun, 15 Nov 2026 18:20:51 +0800 Subject: [PATCH 2/2] fix(codegen): separate composed helper and lexical storage names Allocate composed callable and persistent-storage identities outside reserved helper families, and reserve all authored spellings before sibling-block qualification. Keep declarations, calls and history consumers on the same allocated identity. Exercise collision cases through the public pipeline. --- CHANGELOG.md | 8 +- pineforge_codegen/analyzer/base.py | 29 ++- pineforge_codegen/codegen/base.py | 4 +- pineforge_codegen/codegen/helpers.py | 19 +- tests/test_clone_name_allocation.py | 363 ++++++++++++++++++++++++++- 5 files changed, 404 insertions(+), 19 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8e86efa4..aa0f91c6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,9 +23,11 @@ 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`. Declarations, - calls and history storage use the same allocated identities. Regenerate C++ - and relink affected strategies. + 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. 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 2abc379f..8d395f90 100644 --- a/pineforge_codegen/codegen/base.py +++ b/pineforge_codegen/codegen/base.py @@ -2207,9 +2207,11 @@ def natural_name(fname: str, cs_idx: int) -> str: 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 = self._generated_class_name( + fresh_fn_member = self._generated_helper_name( ("fixnan-instance", fresh_counter, orig_fn_member), f"{orig_fn_member}__ni{fresh_counter}", ) diff --git a/pineforge_codegen/codegen/helpers.py b/pineforge_codegen/codegen/helpers.py index d1693e09..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 @@ -770,7 +778,16 @@ def _initialise_safe_names(self, ast) -> None: self._func_variant_callsite: dict[tuple[str, str], int] = {} def _generated_class_name(self, key: tuple, preferred: str) -> str: - """Allocate one stable member/method identity outside authored names.""" + """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( diff --git a/tests/test_clone_name_allocation.py b/tests/test_clone_name_allocation.py index b55a5d53..348a3143 100644 --- a/tests/test_clone_name_allocation.py +++ b/tests/test_clone_name_allocation.py @@ -2,15 +2,15 @@ from __future__ import annotations +import os import re +from unittest.mock import patch import pytest from pineforge_codegen import transpile -from pineforge_codegen.analyzer import Analyzer from pineforge_codegen.codegen import CodeGen -from pineforge_codegen.lexer import Lexer -from pineforge_codegen.parser import Parser +from pineforge_codegen.codegen.helpers import is_emitter_temporary from tests._compile import compile_cpp from tests._e2e import reference_codegen, transpile_json @@ -37,11 +37,101 @@ 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]: - program = Parser(Lexer(source).tokenize(), source=source).parse() - generator = CodeGen(Analyzer(program).analyze()) - return generator, generator.generate() + # 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: @@ -249,8 +339,9 @@ def test_renamed_callable_context_keeps_compound_argument_history() -> None: compile_cpp(cpp, label="renamed-callable-history-context") -def test_typed_method_variants_reserve_authored_clone_spelling() -> None: - generator, cpp = _emit("""//@version=6 +@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 @@ -260,7 +351,12 @@ def test_typed_method_variants_reserve_authored_clone_spelling() -> None: 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) @@ -276,24 +372,267 @@ def test_typed_method_variants_reserve_authored_clone_spelling() -> None: 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: - pytest.skip("The clone spelling reference commit is unavailable") + 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: - source = source.replace(original, "aa") + 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) == reference["cpp"] + assert transpile(source, check_support=True, libraries={}) == reference["cpp"]