@pineforge/codegen-pyodide 0.7.0

package/pineforge_codegen/codegen/helpers.py

@@ -0,0 +1,163 @@
+"""Pure-utility codegen helpers.
+
+Mixin holding stateless / near-stateless name-mangling and AST-walk
+helpers used everywhere in the codegen. Lives here so the heavier
+visitor / emitter mixins can depend on it without owning its
+implementation. Keep this module free of imports from any other
+``codegen/*`` submodule so it stays at the bottom of the dependency
+graph.
+
+Mixin contract: ``NamingHelper`` reads at most one piece of host state,
+``self._all_member_names`` (used by ``_func_safe_name``). The class
+mixing this in (``CodeGen``) sets that attribute in its constructor.
+"""
+
+from __future__ import annotations
+
+from ..ast_nodes import (
+    Identifier, MemberAccess,
+    VarDecl, Assignment, TupleAssign, ForStmt, ForInStmt,
+)
+
+
+# C++ reserved names that conflict with PineScript identifiers when used
+# verbatim as variable names. Carried forward from the historic codegen.py
+# table; intentionally narrower than the full C++ keyword set because Pine
+# already reserves keywords like ``if``/``else``/``for``/``return`` so they
+# can never reach codegen as identifier strings. Lives here (not base.py)
+# so the mixin can read it without forcing an import cycle on ``base``.
+CPP_RESERVED = {
+    "exp", "log", "abs", "max", "min", "and", "or", "not",
+    "int", "float", "bool", "string", "short", "long", "new", "delete",
+    "class", "struct", "return", "void", "auto", "const", "static",
+}
+
+
+class NamingHelper:
+    """Identifier escaping, callee resolution, and a generic AST walker.
+
+    Mixed into ``CodeGen``; not meant to be instantiated standalone.
+    Methods that need shared state (``_all_member_names``) document the
+    contract explicitly so substitution is safe."""
+
+    # Set by CodeGen.__init__; declared here only as documentation of the
+    # mixin contract. Stays a plain set; the host class owns the value.
+    _all_member_names: set[str]
+
+    @staticmethod
+    def _cpp_string_escape(s: str) -> str:
+        """Escape a Python string for embedding inside a C++ string literal."""
+        return (
+            s.replace("\\", "\\\\")
+            .replace('"', '\\"')
+            .replace("\n", "\\n")
+            .replace("\r", "\\r")
+        )
+
+    def _safe_name(self, name: str) -> str:
+        """Rename identifiers that collide with C++ reserved words."""
+        if name in CPP_RESERVED:
+            return f"_{name}_"
+        return name
+
+    def _func_safe_name(self, name: str) -> str:
+        """Prefix function names that collide with class members (series vars or var members)."""
+        safe = self._safe_name(name)
+        if safe in self._all_member_names:
+            return f"_fn_{safe}"
+        return safe
+
+    def _resolve_callee(self, callee) -> tuple[str | None, str | None]:
+        """Extract ``(func_name, namespace)`` from a callee expression.
+
+        - ``foo()``                        -> ``("foo", None)``
+        - ``ns.foo()``                     -> ``("foo", "ns")``
+        - ``strategy.risk.max_orders(...)`` -> ``("max_orders", "strategy")``
+          (only the outermost root namespace is reported; nested chains
+           collapse to the leftmost identifier — historical behavior).
+        - anything else                    -> ``(None, None)``"""
+        if isinstance(callee, Identifier):
+            return callee.name, None
+        if isinstance(callee, MemberAccess) and isinstance(callee.object, Identifier):
+            return callee.member, callee.object.name
+        if isinstance(callee, MemberAccess) and isinstance(callee.object, MemberAccess):
+            if isinstance(callee.object.object, Identifier):
+                return callee.member, callee.object.object.name
+        return None, None
+
+    def _get_target_name(self, target) -> str | None:
+        """Return the bare name of an assignment target, or ``None`` for non-trivial LHS."""
+        if isinstance(target, Identifier):
+            return target.name
+        return None
+
+    def _walk_ast(self, node):
+        """Yield every node in the subtree rooted at ``node`` (including ``node``).
+
+        Walks every attribute that historically holds an AST child or list
+        of children: ``body``/``else_body``/``cases``/``default_body``,
+        the standard binary/unary/ternary slots, ``args``, ``kwargs``,
+        and ``TypeDecl.fields[*].default``. Order is depth-first; the
+        visit order itself is not part of the public contract — only the
+        set of yielded nodes."""
+        if node is None:
+            return
+        yield node
+        for attr in ("body", "else_body"):
+            children = getattr(node, attr, None)
+            if isinstance(children, list):
+                for child in children:
+                    yield from self._walk_ast(child)
+        if hasattr(node, "cases") and isinstance(node.cases, list):
+            for expr, stmts in node.cases:
+                if expr is not None:
+                    yield from self._walk_ast(expr)
+                for child in stmts:
+                    yield from self._walk_ast(child)
+        if hasattr(node, "default_body") and isinstance(node.default_body, list):
+            for child in node.default_body:
+                yield from self._walk_ast(child)
+        for attr in ("value", "target", "condition", "true_val", "false_val",
+                     "left", "right", "object", "operand", "callee", "index",
+                     "expr"):
+            child = getattr(node, attr, None)
+            if child is not None:
+                yield from self._walk_ast(child)
+        args = getattr(node, "args", None)
+        if isinstance(args, list):
+            for a in args:
+                yield from self._walk_ast(a)
+        kwargs = getattr(node, "kwargs", None)
+        if isinstance(kwargs, dict):
+            for v in kwargs.values():
+                yield from self._walk_ast(v)
+        fields = getattr(node, "fields", None)
+        if isinstance(fields, list):
+            for f in fields:
+                if hasattr(f, "default") and f.default is not None:
+                    yield from self._walk_ast(f.default)
+
+    def _collect_binding_names(self, stmts) -> set[str]:
+        """Return every name bound by a statement in ``stmts`` (recursively):
+        ``var``/plain declarations, assignment targets, tuple-assign names, and
+        ``for`` loop variables. Used to teach the unknown-identifier guard
+        about ordinary function-local scalars, which are emitted inline and are
+        otherwise tracked nowhere (``func_var_members`` only carries vars that
+        become persistent struct members)."""
+        names: set[str] = set()
+        for stmt in stmts or []:
+            for n in self._walk_ast(stmt):
+                if isinstance(n, VarDecl) and n.name:
+                    names.add(n.name)
+                elif isinstance(n, TupleAssign):
+                    names.update(x for x in n.names if x)
+                elif isinstance(n, Assignment) and isinstance(n.target, Identifier):
+                    names.add(n.target.name)
+                elif isinstance(n, ForStmt) and n.var:
+                    names.add(n.var)
+                elif isinstance(n, ForInStmt):
+                    if n.var:
+                        names.add(n.var)
+                    if n.vars:
+                        names.update(x for x in n.vars if x)
+        return names

package/pineforge_codegen/codegen/helpers_syminfo.py

@@ -0,0 +1,132 @@
+"""Syminfo derivation helpers for PineForge codegen.
+
+Emits C++ inline helper functions for syminfo fields that can be derived
+at codegen/runtime from the existing SymInfo struct without requiring
+engine changes:
+
+- ``_pf_derive_main_tickerid(tickerid)``  — strip futures suffix from tickerid
+  e.g., ``"CME_MINI:ES1!"`` → ``"CME_MINI:ES"``, ``"NASDAQ:AAPL"`` → ``"NASDAQ:AAPL"``
+- ``_pf_derive_country(tickerid)``         — lookup country by exchange prefix
+  e.g., ``"NASDAQ:AAPL"`` → ``"US"``, ``"LSE:BP"`` → ``"GB"`` (ISO 3166-1)
+
+These are emitted as ``static inline`` free functions before the
+``GeneratedStrategy`` class definition. They depend only on ``<string>``
+and ``<regex>`` (both already pulled in by the standard includes block).
+"""
+
+# Prefix → country lookup table used for ``syminfo.country`` derivation.
+# Mirrors Pine v6 semantics best-effort; not an exhaustive list. All values
+# MUST be ISO 3166-1 alpha-2 codes (Pine returns ISO codes: LSE → "GB", not
+# "UK"). Prefixes with no single ISO country (pan-European EURONEXT, global
+# crypto venues BINANCE/KRAKEN/BYBIT/OKX/BITMEX/DERIBIT) are intentionally
+# absent — the helper returns na<std::string>() for them, matching TV's na
+# for symbols without a listing country.
+PREFIX_TO_COUNTRY: dict[str, str] = {
+    "NASDAQ": "US",
+    "NYSE": "US",
+    "NYMEX": "US",
+    "AMEX": "US",
+    "ARCA": "US",
+    "CBOE": "US",
+    "CME": "US",
+    "CME_MINI": "US",
+    "CBOT": "US",
+    "COMEX": "US",
+    "OTC": "US",
+    "LSE": "GB",
+    "AQUIS": "GB",
+    "TSE": "JP",
+    "OSE": "JP",
+    "HKEX": "HK",
+    "SGX": "SG",
+    "ASX": "AU",
+    "XETRA": "DE",
+    "BSE": "IN",
+    "NSE": "IN",
+    "COINBASE": "US",
+    "UPBIT": "KR",
+    "KRX": "KR",
+    "KOSPI": "KR",
+    "SSE": "CN",
+    "SZSE": "CN",
+    "JSE": "ZA",
+    "BMF": "BR",
+    "BMFBOVESPA": "BR",
+    "B3": "BR",
+    "MOEX": "RU",
+    "TSX": "CA",
+    "VENTURE": "CA",
+    "SIX": "CH",
+}
+
+# ---------------------------------------------------------------------------
+# C++ code generation
+# ---------------------------------------------------------------------------
+
+# The futures-suffix regex: strips one or more digits at the end, optionally
+# followed by a ``!``.  Examples:
+#   CME_MINI:ES1!  → CME_MINI:ES
+#   NYMEX:CL2!     → NYMEX:CL
+#   NASDAQ:AAPL    → NASDAQ:AAPL  (no suffix, unchanged)
+_MAIN_TICKERID_CPP = r"""
+static inline std::string _pf_derive_prefix(const std::string& tickerid) {
+    std::size_t colon = tickerid.find(':');
+    return (colon == std::string::npos) ? tickerid : tickerid.substr(0, colon);
+}
+
+static inline std::string _pf_derive_main_tickerid(const std::string& tickerid) {
+    // Strip trailing digits (optionally followed by '!') from the symbol part.
+    // e.g. "CME_MINI:ES1!" -> "CME_MINI:ES", "NYMEX:CL2!" -> "NYMEX:CL"
+    std::string result = tickerid;
+    std::size_t colon = result.find(':');
+    std::size_t start = (colon == std::string::npos) ? 0 : colon + 1;
+    // Find end of base symbol (strip trailing digits + optional '!')
+    std::size_t end = result.size();
+    if (end > start && result[end - 1] == '!') {
+        --end;
+    }
+    while (end > start && std::isdigit((unsigned char)result[end - 1])) {
+        --end;
+    }
+    return result.substr(0, end);
+}
+""".strip()
+
+
+def _build_country_lookup_cpp() -> str:
+    """Build the C++ prefix-to-country lookup table from PREFIX_TO_COUNTRY."""
+    entries = []
+    for prefix, country in sorted(PREFIX_TO_COUNTRY.items()):
+        entries.append(f'        {{"{prefix}", "{country}"}}')
+    table = ",\n".join(entries)
+    return (
+        "static inline std::string _pf_derive_country(const std::string& tickerid) {\n"
+        "    // Lookup country by exchange prefix (text before ':').\n"
+        "    std::size_t colon = tickerid.find(':');\n"
+        "    std::string prefix = (colon == std::string::npos)\n"
+        "        ? tickerid : tickerid.substr(0, colon);\n"
+        "    static const std::unordered_map<std::string, std::string> _tbl = {\n"
+        f"{table}\n"
+        "    };\n"
+        "    auto it = _tbl.find(prefix);\n"
+        '    return (it != _tbl.end()) ? it->second : na<std::string>();\n'
+        "}\n"
+    )
+
+
+def emit_syminfo_helpers() -> list[str]:
+    """Return list of C++ lines for the syminfo derivation helper functions.
+
+    Call this from ``_emit_includes`` (after the ``using namespace pineforge;``
+    line) to inject the helpers before the ``GeneratedStrategy`` class.
+    """
+    lines: list[str] = []
+    lines.append("// --- syminfo derivation helpers (PineForge G2) ---")
+    for cpp_line in _MAIN_TICKERID_CPP.splitlines():
+        lines.append(cpp_line)
+    lines.append("")
+    for cpp_line in _build_country_lookup_cpp().splitlines():
+        lines.append(cpp_line)
+    lines.append("// --- end syminfo derivation helpers ---")
+    lines.append("")
+    return lines

package/pineforge_codegen/codegen/input.py

@@ -0,0 +1,189 @@
+"""Pine ``input.*`` call helpers for the codegen.
+
+Mixin holding the family of ``_is_input_*`` / ``_get_input_*`` /
+``_input_type_to_getter`` / ``_enforce_enum_declared_before_input_enum``
+methods. They share a small piece of state (``self._enum_defs``) and a
+common dependency on the analyzer's signature registry.
+
+Mixin contract — host class must provide:
+
+- ``self._enum_defs`` (``dict[str, list[str]]``).
+- ``self._resolve_callee`` (``NamingHelper``).
+- ``self._visit_expr`` (visitor mixin, currently on ``base.py``;
+  used to render the title-arg fallback expression).
+"""
+
+from __future__ import annotations
+
+from ..ast_nodes import FuncCall, Identifier, MemberAccess, StringLiteral
+from .. import signatures as sigs
+
+
+class InputHelper:
+    """``input.*`` call analysis helpers — defaults, titles, getter dispatch, enum guard."""
+
+    def _is_input_call(self, node: FuncCall) -> bool:
+        """True if ``node`` is an ``input(...)`` or ``input.<type>(...)`` call."""
+        func_name, namespace = self._resolve_callee(node.callee)
+        return self._is_input_call_by_name(func_name, namespace)
+
+    @staticmethod
+    def _is_input_call_by_name(func_name: str | None, namespace: str | None) -> bool:
+        """Stateless variant: classify a ``(func_name, namespace)`` pair as input call.
+
+        Used during prescan when only the resolved callee tuple is
+        available (no FuncCall node)."""
+        if func_name == "input" and namespace is None:
+            return True
+        if namespace == "input":
+            return True
+        return False
+
+    def _get_input_default(self, node: FuncCall):
+        """Pull the default-value AST node out of an ``input(...)`` / ``input.<t>(...)`` call.
+
+        Honors keyword arguments by merging them in declaration order via
+        the signatures registry; falls back to the first positional
+        argument or the ``defval=`` kwarg when the registry has no entry."""
+        func_name, namespace = self._resolve_callee(node.callee)
+        param_names = None
+        if namespace == "input" and func_name in sigs.INPUT_FUNCTIONS:
+            param_names = sigs.get_param_names("input", func_name)
+        elif func_name == "input" and namespace is None:
+            param_names = sigs.get_param_names(None, "input")
+        if param_names:
+            merged = list(node.args)
+            for i, pname in enumerate(param_names):
+                if pname in node.kwargs:
+                    while len(merged) <= i:
+                        merged.append(None)
+                    if i >= len(merged) or merged[i] is None:
+                        merged[i] = node.kwargs[pname]
+            while merged and merged[-1] is None:
+                merged.pop()
+            if merged and merged[0] is not None:
+                return merged[0]
+            return None
+        if node.args:
+            return node.args[0]
+        if "defval" in node.kwargs:
+            return node.kwargs["defval"]
+        return None
+
+    def _get_input_title(self, node: FuncCall, var_name: str | None = None) -> str:
+        """Pull the title string from an ``input(...)`` call.
+
+        Reads positional arg #2 or the ``title=`` kwarg via the
+        signatures registry. When the title isn't a ``StringLiteral``
+        (e.g. computed at runtime), the rendered C++ expression is
+        returned. Falls back to ``var_name`` when no title is provided
+        so generated UI labels still have a stable identity."""
+        func_name, namespace = self._resolve_callee(node.callee)
+        param_names = None
+        if namespace == "input" and func_name in sigs.INPUT_FUNCTIONS:
+            param_names = sigs.get_param_names("input", func_name)
+        elif func_name == "input" and namespace is None:
+            param_names = sigs.get_param_names(None, "input")
+        if param_names:
+            merged = list(node.args)
+            for i, pname in enumerate(param_names):
+                if pname in node.kwargs:
+                    while len(merged) <= i:
+                        merged.append(None)
+                    if i >= len(merged) or merged[i] is None:
+                        merged[i] = node.kwargs[pname]
+            if len(merged) > 1 and merged[1] is not None:
+                title_node = merged[1]
+                if isinstance(title_node, StringLiteral):
+                    return title_node.value
+                return self._visit_expr(title_node)
+        return var_name if var_name else ""
+
+    # Native price series accepted as an input.source defval. The analyzer
+    # hard-rejects anything else (see support_checker), so a defval reaching
+    # codegen is one of these or a user-series identifier.
+    _NATIVE_SOURCE_SERIES = frozenset(
+        {"open", "high", "low", "close", "volume",
+         "hl2", "hlc3", "ohlc4", "hlcc4"}
+    )
+
+    @staticmethod
+    def _input_type_to_getter(func_name: str | None, namespace: str | None) -> str:
+        """Map an ``input.<type>`` call to its C++ runtime getter name.
+
+        ``input.float`` / ``input.price`` collapse to ``get_input_double``;
+        ``input.int`` / ``input.enum`` map to ``get_input_int`` (C++ int32);
+        ``input.color`` maps to ``get_input_int64`` (a packed ARGB color
+        ``0xAARRGGBB`` overflows signed int32); ``input.time`` maps to
+        ``get_input_int64`` because Pine v6 ``input.time`` returns a series
+        int Unix timestamp in MILLISECONDS, which overflows int32 for any
+        modern date. ``input.source`` is rendered separately by
+        ``_render_input_value`` (it returns a Series<double>&, not a scalar)
+        and never routes through this table. Bare ``input(...)`` and any
+        unrecognised variant default to double."""
+        if func_name in ("int",):
+            return "get_input_int"
+        if func_name in ("float", "source", "price"):
+            return "get_input_double"
+        if func_name in ("bool",):
+            return "get_input_bool"
+        if func_name in ("string", "timeframe", "session", "symbol", "text_area"):
+            return "get_input_string"
+        if func_name == "color":
+            return "get_input_int64"
+        if func_name == "time":
+            return "get_input_int64"
+        if func_name == "enum":
+            return "get_input_int"
+        return "get_input_double"
+
+    def _source_defval_to_base_series(self, default) -> str:
+        """Map an input.source defval (close/high/hl2/…) to its engine base
+        source series member (``_src_close_`` …). Falls back to
+        ``_src_close_`` for a non-native defval — unreachable once the
+        analyzer guard is in place, but keeps codegen total."""
+        name = default.name if isinstance(default, Identifier) else None
+        if name in self._NATIVE_SOURCE_SERIES:
+            return f"_src_{name}_"
+        return "_src_close_"
+
+    def _render_input_value(self, node: FuncCall, func_name: str | None,
+                            namespace: str | None, title: str) -> str:
+        """Render the C++ value expression for an ``input.*`` call site.
+
+        ``input.source`` resolves to ``get_input_source("title", _src_<field>_)[0]``
+        — the engine returns the (optionally operator-overridden) native
+        series and we read its current value; a subscripted source var is
+        already tracked as a series var by the analyzer so ``src[1]`` lowers
+        to a Series subscript. Every other input type routes through the
+        scalar getter table."""
+        if namespace == "input" and func_name == "source":
+            default = self._get_input_default(node)
+            base = self._source_defval_to_base_series(default)
+            return f'get_input_source("{title}", {base})[0]'
+        default = self._get_input_default(node)
+        default_cpp = self._visit_expr(default) if default is not None else "0"
+        getter = self._input_type_to_getter(func_name, namespace)
+        return f'{getter}("{title}", {default_cpp})'
+
+    def _enforce_enum_declared_before_input_enum(self, node: FuncCall) -> None:
+        """Mirror the analyzer: ``input.enum(Enum.member)`` requires Enum to be defined above the call.
+
+        Codegen runs after the analyzer so the constraint should already
+        be enforced; we duplicate the check defensively because
+        violations would otherwise lead to a silent ``KeyError`` during
+        member resolution."""
+        dv = self._get_input_default(node)
+        if not isinstance(dv, MemberAccess) or not isinstance(dv.object, Identifier):
+            return
+        ename = dv.object.name
+        if ename not in self._enum_defs:
+            raise ValueError(
+                f"enum '{ename}' must be declared above input.enum() "
+                "(internal: Analyzer should reject this first)"
+            )
+        if dv.member not in self._enum_defs[ename]:
+            raise ValueError(
+                f"{ename}.{dv.member} is not a member of enum {ename} "
+                "(internal: Analyzer should reject this first)"
+            )