@pineforge/codegen-pyodide 0.10.4 → 1.0.0

package/pineforge_codegen/analyzer/tables.py

@@ -47,7 +47,7 @@ TA_CLASS_MAP = {
     "dmi": "ta::DMI",
     "sar": "ta::SAR",
     "bb": "ta::BB",
-    "kc": "ta::KC",
+    "kc": "_PFKC",
     "wma": "ta::WMA",
     "hma": "ta::HMA",
     "stdev": "ta::StdDev",
@@ -72,7 +72,7 @@ TA_CLASS_MAP = {
     "highestbars": "ta::HighestBars",
     "lowestbars": "ta::LowestBars",
     # Batch 4 — remaining TA functions
-    "alma": "ta::ALMA",
+    "alma": "_PFALMA",
     "swma": "ta::SWMA",
     "mfi": "ta::MFI",
     "cmo": "ta::CMO",
@@ -80,7 +80,7 @@ TA_CLASS_MAP = {
     "wpr": "ta::WPR",
     "cog": "ta::COG",
     "bbw": "ta::BBW",
-    "kcw": "ta::KCW",
+    "kcw": "_PFKCW",
     "barssince": "ta::BarsSince",
     "valuewhen": "ta::ValueWhen",
     "correlation": "ta::Correlation",
@@ -90,6 +90,8 @@ TA_CLASS_MAP = {
     "vwap": "ta::VWAP",
     # 3-arg form: ta.vwap(source, anchor, stdev_mult) → tuple [vwap, upper, lower]
     "vwap_bands": "ta::VWAPBands",
+    "vwap_anchored": "_PFAnchoredVWAP",
+    "vwap_anchored_bands": "_PFAnchoredVWAPBands",
     "obv": "ta::OBV",
     "accdist": "ta::AccDist",
     "nvi": "ta::NVI",
@@ -126,10 +128,14 @@ TA_PERIOD_ARG = {
     # Task 5
     "mode": 1, "range": 1, "dev": 1,
     "rci": 1,
+    # ta::ValueWhen keeps max(1, max_occurrence + 1) values, its constructor's
+    # bound; compute() reads values_[occurrence]. See TA_COMPUTE_ARGS.
+    "valuewhen": 2,
 }
 
 # Functions that return tuples
-TA_TUPLE_RETURNS = {"macd", "supertrend", "dmi", "bb", "kc", "vwap_bands"}
+TA_TUPLE_RETURNS = {"macd", "supertrend", "dmi", "bb", "kc", "vwap_bands",
+                    "vwap_anchored_bands"}
 TA_TUPLE_ELEMENT_COUNTS = {
     "macd": 3,
     "supertrend": 2,
@@ -137,6 +143,7 @@ TA_TUPLE_ELEMENT_COUNTS = {
     "bb": 3,
     "kc": 3,
     "vwap_bands": 3,
+    "vwap_anchored_bands": 3,
 }
 
 # Functions with multiple constructor args
@@ -146,12 +153,12 @@ TA_MULTI_CTOR = {
     "supertrend": [0, 1],    # factor, atr_period
     "dmi": [0, 1],           # di_length, adx_smoothing
     "bb": [1, 2],            # length, mult
-    "kc": [1, 2],            # length, mult
+    "kc": [1, 2, 3],         # length, mult, useTrueRange
     "sar": [0, 1, 2],        # start, increment, maximum
     "pivothigh": [0, 1],     # left_bars, right_bars
     "pivotlow": [0, 1],      # left_bars, right_bars
     # Batch 4
-    "alma": [1, 2, 3],      # length, offset, sigma
+    "alma": [1, 2, 3, 4],   # length, offset, sigma, floor
     "mfi": [1],              # length (src is compute arg, vol implicit)
     # Pine signature: ta.tsi(source, short_length, long_length) — positions
     # 1 and 2 carry the lengths that initialize the four nested EMAs;
@@ -162,7 +169,8 @@ TA_MULTI_CTOR = {
     "tsi": [1, 2],           # short_length, long_length
     "wpr": [0],              # length
     "bbw": [1, 2],           # length, mult
-    "kcw": [1, 2],           # length, mult
+    "kcw": [1, 2, 3],        # length, mult, useTrueRange
+    "vwap_anchored_bands": [2],  # source, anchor, stdev_mult
     "tr":  [0],              # handle_na (compile-time bool)
     "stdev": [1, 2],         # length, biased
     "variance": [1, 2],      # length, biased
@@ -174,10 +182,43 @@ TA_MULTI_CTOR = {
 TA_COMPUTE_ARGS = {
     "stdev": [0],
     "variance": [0],
+    # ta::Change's constructor only bounds the kept history; compute() reads
+    # the lookback from its own ``length`` argument (default 1), so the length
+    # goes to both. Without it ``ta.change(src, 14)`` was a one-bar change.
+    "change": [0, 1],
+    # The mirror image: compute(condition, source, occurrence) always had the
+    # occurrence, but the history bound is the constructor's max_occurrence
+    # (default 1, two values kept), so every occurrence >= 2 read na.
+    "valuewhen": [0, 1, 2],
+    # ``ta.vwap(source, anchor)`` is split into a dedicated anchored site in
+    # call_handlers; this entry remains for the omitted-anchor scalar form.
+    "vwap": [0],
+    # ``ta.alma(series, length, offset, sigma, floor)``: ta::ALMA takes no
+    # floor (m = offset * (length - 1), unfloored), the value the support
+    # checker admits (false); ``floor`` used to reach ALMA::compute(src).
+    "alma": [0],
+    # ``ta.kc`` / ``ta.kcw(series, length, mult, useTrueRange)``: ta::KC
+    # always averages the true range, the value the support checker admits
+    # (true); ``useTrueRange`` used to reach a compute() overload that does
+    # not exist. high / low / close are appended implicitly.
+    "kc": [0],
+    "kcw": [0],
+    "vwap_anchored": [0, 1],
+    "vwap_anchored_bands": [0, 1],
+}
+
+# The one-argument forms ``ta.highest(length)`` / ``ta.lowest(length)`` /
+# ``ta.highestbars(length)`` / ``ta.lowestbars(length)`` (positional or
+# ``length=``) read this bar field as their source (TradingView: "One arg
+# version: length is the number of bars back. Algorithm uses high as a source
+# series.").
+TA_LENGTH_ONLY_DEFAULT_SOURCE = {
+    "highest": "high", "lowest": "low",
+    "highestbars": "high", "lowestbars": "low",
 }
 
 # No-state functions (no constructor args, stateless or self-contained)
-TA_NO_CTOR = {"crossover", "crossunder", "cross", "cum", "swma", "barssince", "valuewhen",
+TA_NO_CTOR = {"crossover", "crossunder", "cross", "cum", "swma", "barssince",
               "max", "min",
               "obv", "accdist", "nvi", "pvi", "pvt", "wad", "wvad", "iii", "vwap"}
 

package/pineforge_codegen/analyzer/types.py

@@ -40,10 +40,11 @@ from __future__ import annotations
 from typing import Any
 
 from ..ast_nodes import (
-    ASTNode, BinOp, BoolLiteral, ExprStmt, FuncCall, Identifier, IfStmt,
+    ASTNode, BinOp, BoolLiteral, ColorLiteral, ExprStmt, FuncCall, Identifier, IfStmt,
     MemberAccess, NaLiteral, NumberLiteral, StringLiteral, Subscript, Ternary,
     SwitchStmt, TupleLiteral, UnaryOp,
 )
+from ..errors import Phase
 from ..symbols import PineType, TypeSpec, method_receiver_type_name
 
 # Drawing-objects-as-data type names (spec §4.1). Defined locally — the
@@ -185,6 +186,10 @@ class TypeHelper:
                 if left.name == "int" and right.name == "int":
                     return TypeSpec.primitive("int")
             return None
+        if self._is_color_constructor(value):
+            # A packed-ARGB color, as codegen's ``_is_color_value`` reads it:
+            # the declaration and the constructor agree on ``int64_t``.
+            return TypeSpec.primitive("color")
         spec = self._type_spec_from_expr(value)
         if spec is not None:
             return spec
@@ -197,6 +202,26 @@ class TypeHelper:
                 return self._pine_type_to_spec(sym.pine_type)
         return None
 
+    @classmethod
+    def _is_color_constructor(cls, value: ASTNode | None) -> bool:
+        """A color literal, ``color.<name>``, a ``color.new`` / ``rgb`` /
+        ``from_gradient`` call, or a conditional selecting one."""
+        if isinstance(value, ColorLiteral):
+            return True
+        if isinstance(value, MemberAccess):
+            return (isinstance(value.object, Identifier)
+                    and value.object.name == "color")
+        if isinstance(value, FuncCall):
+            callee = value.callee
+            return (isinstance(callee, MemberAccess)
+                    and isinstance(callee.object, Identifier)
+                    and callee.object.name == "color"
+                    and callee.member in ("new", "rgb", "from_gradient"))
+        if isinstance(value, Ternary):
+            return (cls._is_color_constructor(value.true_val)
+                    or cls._is_color_constructor(value.false_val))
+        return False
+
     @staticmethod
     def _selection_terminal_expr(
         body: list[ASTNode] | None,
@@ -241,6 +266,13 @@ class TypeHelper:
     def _type_spec_from_expr(self, value: ASTNode | None) -> TypeSpec | None:
         if value is None:
             return None
+        budget = getattr(self, "_budget", None)
+        if budget is not None:
+            # A method chain re-infers each receiver more than once, so this
+            # recursion can outgrow the visitor checkpoints.
+            self._budget_visit_count += 1
+            if self._budget_visit_count % 128 == 0:
+                budget.check(value.loc, Phase.ANALYZER)
         if isinstance(value, NumberLiteral):
             return TypeSpec.primitive(
                 "float" if isinstance(value.value, float) else "int"

package/pineforge_codegen/ast_nodes.py

@@ -26,6 +26,28 @@ class ASTNode:
     annotations: dict | None = field(default=None, compare=False)
 
 
+class ArgOrder:
+    """The written order of a call's positional and keyword arguments.
+
+    It holds the same nodes as the call's ``args`` and ``kwargs``.  It is not a
+    list, tuple or dict and has no ``__dict__``, so the generic AST walkers,
+    which descend into those, do not visit every argument a second time: the
+    second visit doubled the work at each nested call, and ``f(f(f(...)))``
+    cost 2**depth.
+    """
+
+    __slots__ = ("nodes",)
+
+    def __init__(self, nodes) -> None:
+        self.nodes = tuple(nodes)
+
+    def __iter__(self):
+        return iter(self.nodes)
+
+    def __len__(self) -> int:
+        return len(self.nodes)
+
+
 # ---------------------------------------------------------------------------
 # Top-level / structural nodes
 # ---------------------------------------------------------------------------
@@ -44,8 +66,17 @@ class StrategyDecl(ASTNode):
 
 @dataclass
 class ImportStmt(ASTNode):
-    """import <path> — parsed for error reporting."""
+    """``import <user>/<name>/<version> [as <alias>]``.
+
+    ``path`` is ``user/name/version``; ``user``, ``name``, ``version`` and
+    ``alias`` stay None when the line does not have that form, and ``path``
+    is then the line's tokens as written.
+    """
     path: str = ""
+    user: str | None = None
+    name: str | None = None
+    version: int | None = None
+    alias: str | None = None
 
 
 # ---------------------------------------------------------------------------

package/pineforge_codegen/block_locals.py

@@ -0,0 +1,185 @@
+"""Declarations in the script's top-level blocks that cannot share a member.
+
+The codegen holds every declaration of the script's top level -- a direct one
+and one inside a top-level ``if`` / loop / ``switch`` block -- in one class
+member per name. Pine scopes a block's declaration to its block, so two blocks
+may declare one name with types one member cannot hold: a counter ``k = 0`` in
+one block and ``k = array.get(names, i)`` (a string) in another, a script of
+the fruit-fly probes' shape, did not compile. The codegen names each
+declaration whose type cannot share the member of the name
+(``CodeGen.block_locals_needing_names``, by ``decl_key``); ``transpile()``
+gives each of them, and every read of it in its block, a name of its own
+(``k__pfblk1``) and runs again (``pineforge_codegen._generate``). Scripts
+whose declarations share their members keep their C++ byte for byte.
+"""
+
+from __future__ import annotations
+
+from .ast_nodes import (
+    ASTNode, ArgOrder, Assignment, ExprStmt, ForInStmt, ForStmt, FuncCall,
+    Identifier, IfStmt, Program, SwitchStmt, TupleAssign, VarDecl, WhileStmt,
+)
+
+_BLOCKS = (IfStmt, ForStmt, ForInStmt, WhileStmt, SwitchStmt)
+
+
+def decl_key(node: VarDecl) -> tuple | None:
+    """A declaration's identity across the passes of one transpile: where
+    it is written."""
+    loc = node.loc
+    return None if loc is None else (loc.file, loc.line, loc.col)
+
+
+def block_declarations(body: list):
+    """(declaration, in a block) for every declaration the codegen holds in a
+    class member of the script's top level, in source order: the direct ones
+    and those in its statement blocks (``if`` / loop / ``switch``, nested
+    too), as ``CodeGen`` hoists them. An ``if`` or ``switch`` value's block
+    keeps its declarations to itself."""
+    for stmt in body:
+        yield from _declarations(stmt, False)
+
+
+def _declarations(node, nested: bool):
+    if isinstance(node, VarDecl):
+        yield node, nested
+    elif isinstance(node, IfStmt):
+        for stmt in (*node.body, *node.else_body):
+            yield from _declarations(stmt, True)
+    elif isinstance(node, (ForStmt, ForInStmt, WhileStmt)):
+        for stmt in node.body:
+            yield from _declarations(stmt, True)
+    elif isinstance(node, SwitchStmt):
+        for _value, body in node.cases:
+            for stmt in body:
+                yield from _declarations(stmt, True)
+        for stmt in node.default_body:
+            yield from _declarations(stmt, True)
+
+
+def rename_block_locals(program: Program, keys: frozenset) -> None:
+    """Give each top-level block declaration ``keys`` names a name of its own,
+    and every read of it in its block (a nested block's declaration of the
+    same name, or a loop variable of it, shadows it there)."""
+    if not keys:
+        return
+    renamer = _Renamer(program, keys)
+    renamer.block(program.body, {})
+
+
+class _Renamer:
+    def __init__(self, program: Program, keys: frozenset) -> None:
+        self._keys = keys
+        self._taken = _names(program)
+        self._next = 0
+
+    def _alloc(self, name: str) -> str:
+        while True:
+            self._next += 1
+            new = f"{name}__pfblk{self._next}"
+            if new not in self._taken:
+                self._taken.add(new)
+                return new
+
+    def block(self, stmts: list, visible: dict) -> None:
+        names = dict(visible)
+        for stmt in stmts:
+            self.stmt(stmt, names)
+
+    def stmt(self, stmt, names: dict) -> None:
+        if isinstance(stmt, VarDecl):
+            self.expr(stmt.value, names)
+            if decl_key(stmt) in self._keys:
+                new = self._alloc(stmt.name)
+                names[stmt.name] = new
+                stmt.name = new
+            else:
+                names.pop(stmt.name, None)
+        elif isinstance(stmt, TupleAssign):
+            self.expr(stmt.value, names)
+            for bound in stmt.names:
+                names.pop(bound, None)
+        elif isinstance(stmt, Assignment):
+            self.expr(stmt.target, names)
+            self.expr(stmt.value, names)
+        elif isinstance(stmt, ExprStmt):
+            self.expr(stmt.expr, names)
+        elif isinstance(stmt, _BLOCKS):
+            self.block_node(stmt, names)
+
+    def block_node(self, node, names: dict) -> None:
+        if isinstance(node, IfStmt):
+            self.expr(node.condition, names)
+            self.block(node.body, names)
+            self.block(node.else_body, names)
+        elif isinstance(node, ForStmt):
+            for part in (node.start, node.end, node.step):
+                self.expr(part, names)
+            inner = dict(names)
+            inner.pop(node.var, None)
+            self.block(node.body, inner)
+        elif isinstance(node, ForInStmt):
+            self.expr(node.iterable, names)
+            inner = dict(names)
+            for bound in [node.var, *(node.vars or ())]:
+                inner.pop(bound, None)
+            self.block(node.body, inner)
+        elif isinstance(node, WhileStmt):
+            self.expr(node.condition, names)
+            self.block(node.body, names)
+        elif isinstance(node, SwitchStmt):
+            self.expr(node.expr, names)
+            for value, body in node.cases:
+                self.expr(value, names)
+                self.block(body, names)
+            self.block(node.default_body, names)
+
+    def expr(self, node, names: dict) -> None:
+        if not names or node is None:
+            return
+        if isinstance(node, list):
+            for item in node:
+                self.expr(item, names)
+            return
+        if not isinstance(node, ASTNode):
+            return
+        if isinstance(node, Identifier):
+            node.name = names.get(node.name, node.name)
+            return
+        if isinstance(node, _BLOCKS):
+            self.block_node(node, names)
+            return
+        for key, value in vars(node).items():
+            if key in ("loc", "annotations"):
+                continue
+            if key == "callee" and isinstance(node, FuncCall) and isinstance(value, Identifier):
+                continue  # a function's name, not a variable's
+            if isinstance(value, dict):
+                self.expr(list(value.values()), names)
+            elif isinstance(value, (ASTNode, list)):
+                self.expr(value, names)
+
+
+def _names(root) -> set[str]:
+    """Every identifier and declared name ``root`` spells."""
+    found: set[str] = set()
+    stack = [root]
+    while stack:
+        node = stack.pop()
+        if isinstance(node, (list, tuple)):
+            stack.extend(node)
+        elif isinstance(node, dict):
+            stack.extend(node.values())
+        elif isinstance(node, ArgOrder):
+            continue
+        elif isinstance(node, ASTNode):
+            for key, value in vars(node).items():
+                if key in ("loc", "annotations"):
+                    continue
+                if isinstance(value, str) and key in ("name", "var"):
+                    found.add(value)
+                elif key in ("params", "names", "vars") and isinstance(value, list):
+                    found.update(v for v in value if isinstance(v, str))
+                else:
+                    stack.append(value)
+    return found

package/pineforge_codegen/builtin_keywords.py

@@ -0,0 +1,42 @@
+"""Bind the keyword arguments of ``nz`` and ``fixnan`` to their positions.
+
+TradingView names the parameters ``nz(source, replacement)`` and
+``fixnan(source)``, and evaluates a call's arguments in parameter order
+whatever order they are written in (lab tv probes pf-oi-kw-names and
+pf-oi-kw-order: ``nz(replacement = r(), source = s())`` runs ``s`` first).
+The analyzer and the codegen read these calls by position, so a keyword
+form reached them as a call without its source (``nz(source = x)`` and
+``fixnan(source = x)`` raised IndexError) or with its replacement dropped
+(``nz(x, replacement = y)`` read 0). The support checker refuses a call
+whose arguments bind to none of TradingView's signatures; this pass then
+rewrites every call that binds with its arguments in parameter order.
+"""
+
+from __future__ import annotations
+
+from .ast_nodes import FuncCall, Identifier, Program
+from .limits import iter_ast_nodes
+from . import signatures as sigs
+
+POSITIONAL_BUILTINS = ("nz", "fixnan")
+
+
+def bind_builtin_keywords(program: Program) -> Program:
+    for node, _depth in iter_ast_nodes(program):
+        if (not isinstance(node, FuncCall) or not node.kwargs
+                or not isinstance(node.callee, Identifier)
+                or node.callee.name not in POSITIONAL_BUILTINS):
+            continue
+        names = sigs.BUILTIN_FUNCTIONS[node.callee.name].param_names
+        if not set(node.kwargs) <= set(names[len(node.args):]):
+            continue  # unbound: the support checker refused it
+        bound = list(node.args)
+        for name in names[len(node.args):]:
+            if name not in node.kwargs:
+                break
+            bound.append(node.kwargs[name])
+        if len(bound) != len(node.args) + len(node.kwargs):
+            continue  # a hole before a later keyword: left as written
+        node.args = bound
+        node.kwargs = {}
+    return program