Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 7 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand Down
29 changes: 27 additions & 2 deletions pineforge_codegen/analyzer/base.py
Original file line number Diff line number Diff line change
Expand Up @@ -265,6 +265,7 @@ def __init__(self, ast: Program, filename: str = "<stdin>",
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
Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -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
Expand Down
70 changes: 52 additions & 18 deletions pineforge_codegen/codegen/base.py
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down Expand Up @@ -1221,15 +1226,24 @@ 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()
for name in ctx.series_vars:
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] = {}
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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:
Expand Down Expand Up @@ -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] = []
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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.

Expand All @@ -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:
Expand Down Expand Up @@ -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,
Expand Down Expand Up @@ -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()
Expand Down Expand Up @@ -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
)
Expand Down Expand Up @@ -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:
Expand Down
8 changes: 6 additions & 2 deletions pineforge_codegen/codegen/emit_top.py
Original file line number Diff line number Diff line change
Expand Up @@ -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])

Expand Down Expand Up @@ -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), {})
Expand Down
51 changes: 49 additions & 2 deletions pineforge_codegen/codegen/helpers.py
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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}_"
Expand Down Expand Up @@ -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]:
Expand Down
2 changes: 1 addition & 1 deletion pineforge_codegen/codegen/ta.py
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
Loading
Loading