pineforge-codegen 0.6.5__py3-none-any.whl

pineforge_codegen/analyzer/types.py

@@ -0,0 +1,250 @@
+"""Pine type-hint and expression -> TypeSpec / PineType inference for the analyzer.
+
+The historic ``analyzer.py`` had a small cluster of helpers that
+answered one question: "given this Pine type hint string or AST
+expression, what TypeSpec / PineType should we record on the
+symbol?" This mixin collects them in one place. ``Analyzer`` mixes
+``TypeHelper`` in alongside the future visitor mixins.
+
+Mixin contract -- host class must provide the following attributes:
+
+- ``self._symbols`` (``SymbolTable``): symbol-table source for
+  ``Identifier`` lookups in ``_type_spec_from_expr``.
+- ``self._udt_fields`` (``dict[str, dict[str, PineType]]``): UDT
+  type name -> field schema. Read by ``_type_spec_from_hint`` (to
+  fall back to ``TypeSpec.udt(name)``) and by
+  ``_type_spec_from_expr`` (to recognise ``TypeName.new(...)``).
+- ``self._udt_field_type_specs``
+  (``dict[str, dict[str, TypeSpec]]``): structured UDT field
+  metadata, used to resolve ``a.field`` member access.
+- ``self._enum_defs`` (``dict[str, list[str]]``): enum name ->
+  member list, used by ``_extract_literal_value`` when constant-
+  folding ``EnumName.MEMBER`` to its ordinal.
+
+And the following sibling methods (expected to come from
+``Analyzer.base`` in the current step; future steps may move them
+into their own mixins):
+
+- ``self._visit`` -- visitor entry; used by ``_type_spec_from_expr``
+  to type-check ``array.from(...)``'s first arg.
+
+Consumed by visitor methods to convert Pine type hints / expression
+nodes into ``TypeSpec`` and ``PineType`` values, and by
+``_handle_*_call`` paths in the upcoming ``CallHandlers`` mixin.
+The mixin avoids importing from ``base.py`` to stay free of import
+cycles.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..ast_nodes import (
+    ASTNode, BoolLiteral, FuncCall, Identifier, MemberAccess,
+    NaLiteral, NumberLiteral, StringLiteral, UnaryOp,
+)
+from ..symbols import PineType, TypeSpec
+
+
+class TypeHelper:
+    """Pine type-hint / expression inference.
+
+    Mixed into ``Analyzer``; not meant to be instantiated standalone.
+    Methods that need shared state (``self._symbols``,
+    ``self._udt_fields``, ``self._udt_field_type_specs``,
+    ``self._enum_defs``) document the contract in the module
+    docstring above.
+    """
+
+    def _split_top_level_type_args(self, text: str) -> list[str]:
+        args: list[str] = []
+        cur: list[str] = []
+        depth = 0
+        for ch in text:
+            if ch == "<":
+                depth += 1
+                cur.append(ch)
+            elif ch == ">":
+                depth -= 1
+                cur.append(ch)
+            elif ch == "," and depth == 0:
+                args.append("".join(cur).strip())
+                cur = []
+            else:
+                cur.append(ch)
+        tail = "".join(cur).strip()
+        if tail:
+            args.append(tail)
+        return args
+
+    def _type_spec_from_hint(self, hint: str | None) -> TypeSpec | None:
+        if not hint:
+            return None
+        hint = hint.strip().replace(" ", "")
+        primitive = {"int", "float", "bool", "string", "color"}
+        if hint in primitive:
+            return TypeSpec.primitive(hint)
+        if hint.startswith("array<") and hint.endswith(">"):
+            inner = hint[len("array<"):-1]
+            elem = self._type_spec_from_hint(inner) or TypeSpec.udt(inner)
+            return TypeSpec.array(elem)
+        if hint.startswith("matrix<") and hint.endswith(">"):
+            inner = hint[len("matrix<"):-1]
+            return TypeSpec.matrix(self._type_spec_from_hint(inner) or TypeSpec.udt(inner))
+        if hint.startswith("map<") and hint.endswith(">"):
+            inner = hint[len("map<"):-1]
+            parts = self._split_top_level_type_args(inner)
+            if len(parts) == 2:
+                key = self._type_spec_from_hint(parts[0]) or TypeSpec.udt(parts[0])
+                val = self._type_spec_from_hint(parts[1]) or TypeSpec.udt(parts[1])
+                return TypeSpec.map(key, val)
+        if hint in self._udt_fields:
+            return TypeSpec.udt(hint)
+        return None
+
+    def _template_args_from_call(self, node: FuncCall) -> list[str]:
+        callee = node.callee
+        ann = getattr(callee, "annotations", None) or {}
+        raw = ann.get("template_args") or []
+        return [str(x).replace(" ", "") for x in raw]
+
+    def _type_spec_from_expr(self, value: ASTNode | None) -> TypeSpec | None:
+        if value is None:
+            return None
+        if isinstance(value, FuncCall):
+            cal = value.callee
+            func = cal.member if isinstance(cal, MemberAccess) else None
+            ns = cal.object.name if isinstance(cal, MemberAccess) and isinstance(cal.object, Identifier) else None
+            targs = self._template_args_from_call(value)
+            if ns == "array" and func in ("new", "new_float", "new_int", "new_bool", "new_string", "from"):
+                if func == "new_float":
+                    return TypeSpec.array(TypeSpec.primitive("float"))
+                if func == "new_int":
+                    return TypeSpec.array(TypeSpec.primitive("int"))
+                if func == "new_bool":
+                    return TypeSpec.array(TypeSpec.primitive("bool"))
+                if func == "new_string":
+                    return TypeSpec.array(TypeSpec.primitive("string"))
+                if targs:
+                    elem = self._type_spec_from_hint(targs[0]) or TypeSpec.udt(targs[0])
+                    return TypeSpec.array(elem)
+                if func == "from" and value.args:
+                    first = self._visit(value.args[0])
+                    return TypeSpec.array(self._pine_type_to_spec(first))
+                return TypeSpec.array(TypeSpec.primitive("float"))
+            if ns == "matrix" and func == "new":
+                if targs:
+                    elem = self._type_spec_from_hint(targs[0]) or TypeSpec.udt(targs[0])
+                else:
+                    elem = TypeSpec.primitive("float")
+                return TypeSpec.matrix(elem)
+            if ns == "map" and func == "new":
+                key = self._type_spec_from_hint(targs[0]) if len(targs) > 0 else TypeSpec.primitive("string")
+                val = self._type_spec_from_hint(targs[1]) if len(targs) > 1 else TypeSpec.primitive("float")
+                return TypeSpec.map(key or TypeSpec.primitive("string"), val or TypeSpec.primitive("float"))
+            if ns == "str" and func == "split":
+                return TypeSpec.array(TypeSpec.primitive("string"))
+            if ns == "ta" and func == "pivot_point_levels":
+                return TypeSpec.array(TypeSpec.primitive("float"))
+            if ns == "request" and func == "security_lower_tf":
+                # ``request.security_lower_tf`` returns array<T> where T
+                # is the Pine type of the expression argument. We use the
+                # PineType cached on the FuncCall by the analyzer's
+                # ``_handle_request_security_lower_tf`` to avoid a second
+                # ``_visit`` (which would double-allocate TA call sites
+                # for TA-bearing expressions).
+                anns = getattr(value, "annotations", None) or {}
+                inner = anns.get("lower_tf_element_pine_type")
+                if inner is None:
+                    return TypeSpec.array(TypeSpec.primitive("float"))
+                return TypeSpec.array(self._pine_type_to_spec(inner))
+            if ns in self._udt_fields and func == "new":
+                return TypeSpec.udt(ns)
+            if isinstance(cal, MemberAccess):
+                recv_spec = self._type_spec_from_expr(cal.object)
+                if recv_spec is not None and recv_spec.kind == "array":
+                    if func in ("get", "first", "last", "pop", "shift", "remove"):
+                        return recv_spec.element
+                    if func in ("copy", "slice"):
+                        return recv_spec
+                if recv_spec is not None and recv_spec.kind == "map":
+                    if func in ("get", "remove"):
+                        return recv_spec.value
+                    if func == "keys":
+                        return TypeSpec.array(recv_spec.key or TypeSpec.primitive("string"))
+                    if func == "values":
+                        return TypeSpec.array(recv_spec.value or TypeSpec.primitive("float"))
+                if recv_spec is not None and recv_spec.kind == "matrix":
+                    if func in ("copy", "submatrix", "transpose", "concat"):
+                        return recv_spec
+                    if func in ("row", "col"):
+                        return TypeSpec.array(recv_spec.element)
+                    if func == "get":
+                        return recv_spec.element
+                    if func == "eigenvalues":
+                        return TypeSpec.array(TypeSpec.primitive("float"))
+        if isinstance(value, Identifier):
+            sym = self._symbols.resolve(value.name)
+            if sym is not None and sym.type_spec is not None:
+                return sym.type_spec
+        if isinstance(value, MemberAccess):
+            owner = self._type_spec_from_expr(value.object)
+            if owner is not None and owner.kind == "udt" and owner.name:
+                return (self._udt_field_type_specs.get(owner.name) or {}).get(value.member)
+        return None
+
+    @staticmethod
+    def _pine_type_to_spec(pine_type: PineType) -> TypeSpec:
+        mapping = {
+            PineType.INT: "int",
+            PineType.FLOAT: "float",
+            PineType.BOOL: "bool",
+            PineType.STRING: "string",
+            PineType.COLOR: "color",
+        }
+        return TypeSpec.primitive(mapping.get(pine_type, "float"))
+
+    def _type_hint_to_pine(self, hint: str) -> PineType:
+        """Convert a type hint string to PineType."""
+        if "<" in hint:
+            return PineType.UNKNOWN
+        mapping = {
+            "int": PineType.INT,
+            "float": PineType.FLOAT,
+            "bool": PineType.BOOL,
+            "string": PineType.STRING,
+            "color": PineType.COLOR,
+        }
+        return mapping.get(hint, PineType.UNKNOWN)
+
+    def _extract_literal_value(self, node: ASTNode) -> Any:
+        """Extract a Python literal value from an AST node."""
+        if isinstance(node, NumberLiteral):
+            return node.value
+        if isinstance(node, StringLiteral):
+            return node.value
+        if isinstance(node, BoolLiteral):
+            return node.value
+        if isinstance(node, NaLiteral):
+            return None
+        if isinstance(node, Identifier):
+            return node.name
+        if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
+            ename = node.object.name
+            if ename in self._enum_defs:
+                members = self._enum_defs[ename]
+                if node.member in members:
+                    return members.index(node.member)
+                return None
+        if isinstance(node, MemberAccess):
+            # strategy.fixed, strategy.percent_of_equity, strategy.cash,
+            # strategy.commission.percent, currency.USD, etc.
+            obj = self._extract_literal_value(node.object)
+            if obj is not None:
+                return f"{obj}.{node.member}"
+            return node.member
+        if isinstance(node, UnaryOp) and node.op == "-":
+            val = self._extract_literal_value(node.operand)
+            if isinstance(val, (int, float)):
+                return -val
+        return None

pineforge_codegen/ast_nodes.py

@@ -0,0 +1,293 @@
+"""AST node definitions for PineScript v6."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from pineforge_codegen.errors import SourceLocation
+
+
+# ---------------------------------------------------------------------------
+# Base class
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ASTNode:
+    """Base class for all AST nodes.
+
+    *loc* carries the source span that produced this node; it is always set by
+    the new parser but defaults to None so that old code (Tasks 4-6 are still
+    pending) does not immediately break.
+
+    *annotations* is an open-ended dict used by later compiler phases (type
+    inference, optimiser, etc.) to attach arbitrary metadata without touching
+    the node definition.
+    """
+    loc: SourceLocation | None = field(default=None, compare=False)
+    annotations: dict | None = field(default=None, compare=False)
+
+
+# ---------------------------------------------------------------------------
+# Top-level / structural nodes
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Program(ASTNode):
+    body: list = field(default_factory=list)
+    version: int | None = None
+
+
+@dataclass
+class StrategyDecl(ASTNode):
+    args: list = field(default_factory=list)
+    kwargs: dict = field(default_factory=dict)
+
+
+@dataclass
+class ImportStmt(ASTNode):
+    """import <path> — parsed for error reporting."""
+    path: str = ""
+
+
+# ---------------------------------------------------------------------------
+# Declaration / assignment nodes
+# ---------------------------------------------------------------------------
+
+@dataclass
+class VarDecl(ASTNode):
+    """Variable declaration: [var|varip] [type] name = value"""
+    name: str = ""
+    value: Any = None
+    is_var: bool = False
+    is_varip: bool = False
+    type_hint: str | None = None
+
+
+@dataclass
+class Assignment(ASTNode):
+    """Reassignment / compound assignment: target <op> value.
+
+    *op* is one of:  ``:=``  ``+=``  ``-=``  ``*=``  ``/=``  ``%=``
+    *target* is an expression (Identifier, Subscript, MemberAccess, …).
+    """
+    target: Any = None
+    op: str = ":="
+    value: Any = None
+
+
+@dataclass
+class TupleAssign(ASTNode):
+    """[a, b, c] = expr"""
+    names: list[str] = field(default_factory=list)
+    value: Any = None
+
+
+# ---------------------------------------------------------------------------
+# Control-flow nodes
+# ---------------------------------------------------------------------------
+
+@dataclass
+class IfStmt(ASTNode):
+    condition: Any = None
+    body: list = field(default_factory=list)
+    else_body: list = field(default_factory=list)
+
+
+@dataclass
+class ForStmt(ASTNode):
+    """for var = start to end [by step]"""
+    var: str = ""
+    start: Any = None
+    end: Any = None
+    step: Any | None = None
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class ForInStmt(ASTNode):
+    """for x in iterable  /  for [a, b] in iterable"""
+    var: str | None = None          # single variable name, or None if destructured
+    vars: list[str] | None = None   # destructured variable names [a, b]
+    iterable: ASTNode | None = None
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class WhileStmt(ASTNode):
+    condition: Any = None
+    body: list = field(default_factory=list)
+
+
+@dataclass
+class SwitchStmt(ASTNode):
+    expr: Any | None = None
+    cases: list = field(default_factory=list)   # list of (expr|None, body_stmts)
+    default_body: list = field(default_factory=list)
+
+
+@dataclass
+class BreakStmt(ASTNode):
+    pass
+
+
+@dataclass
+class ContinueStmt(ASTNode):
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Function definition
+# ---------------------------------------------------------------------------
+
+@dataclass
+class FuncDef(ASTNode):
+    name: str = ""
+    params: list[str] = field(default_factory=list)
+    body: list = field(default_factory=list)
+    is_single_expr: bool = False
+
+
+# ---------------------------------------------------------------------------
+# Expression wrapper (statement context)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ExprStmt(ASTNode):
+    expr: Any = None
+
+
+# ---------------------------------------------------------------------------
+# Expression nodes
+# ---------------------------------------------------------------------------
+
+@dataclass
+class BinOp(ASTNode):
+    """Binary operation.  Field order: left, op, right."""
+    left: Any = None
+    op: str = ""
+    right: Any = None
+
+
+@dataclass
+class UnaryOp(ASTNode):
+    op: str = ""
+    operand: Any = None
+
+
+@dataclass
+class Ternary(ASTNode):
+    condition: Any = None
+    true_val: Any = None
+    false_val: Any = None
+
+
+@dataclass
+class FuncCall(ASTNode):
+    """Function / method call.
+
+    *callee* is an expression node — typically an Identifier (``foo``) or a
+    MemberAccess (``strategy.entry``).  The old ``name`` + ``namespace`` split
+    is replaced by a single expression so that arbitrary call targets are
+    representable.
+    """
+    callee: Any = None
+    args: list = field(default_factory=list)
+    kwargs: dict = field(default_factory=dict)
+
+
+@dataclass
+class Subscript(ASTNode):
+    """History referencing / index access: expr[offset]"""
+    object: Any = None
+    index: Any = None
+
+
+@dataclass
+class Identifier(ASTNode):
+    name: str = ""
+
+
+@dataclass
+class MemberAccess(ASTNode):
+    object: Any = None
+    member: str = ""
+
+
+@dataclass
+class TypeAnnotation(ASTNode):
+    """Type name used as an expression node (e.g. in cast syntax)."""
+    type_name: str = ""
+
+
+# ---------------------------------------------------------------------------
+# Literal nodes
+# ---------------------------------------------------------------------------
+
+@dataclass
+class NumberLiteral(ASTNode):
+    value: int | float = 0
+
+
+@dataclass
+class StringLiteral(ASTNode):
+    value: str = ""
+
+
+@dataclass
+class BoolLiteral(ASTNode):
+    value: bool = False
+
+
+@dataclass
+class NaLiteral(ASTNode):
+    pass
+
+
+@dataclass
+class ColorLiteral(ASTNode):
+    """Hex colour literal: ``#rrggbb`` or ``#rrggbbaa``."""
+    value: str = ""
+
+
+@dataclass
+class TupleLiteral(ASTNode):
+    """[a, b, c] tuple literal used in function returns."""
+    elements: list = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# User-Defined Type (UDT) nodes
+# ---------------------------------------------------------------------------
+
+@dataclass
+class TypeField:
+    """One field in a type declaration."""
+    type_name: str = ""
+    name: str = ""
+    default: ASTNode | None = None
+
+@dataclass
+class TypeDecl(ASTNode):
+    """type MyType\n    float field = default"""
+    name: str = ""
+    fields: list = field(default_factory=list)  # list of TypeField
+
+@dataclass
+class EnumDecl(ASTNode):
+    """User-defined enum (derived type). Members are ordered; optional RHS per field.
+
+    TradingView allows `member = <expr>` so field “payload” (titles, IANA strings, …)
+    is separate from the member’s ordinal — the language type is still the enum, not
+    the RHS type.
+    """
+    name: str = ""
+    members: list = field(default_factory=list)  # list of str (declaration order)
+    member_values: dict[str, ASTNode] = field(default_factory=dict)
+
+@dataclass
+class MethodDef(ASTNode):
+    """method myMethod(self, param) => body"""
+    name: str = ""
+    type_name: str = ""       # the type this method belongs to
+    params: list = field(default_factory=list)  # list of str (first is self)
+    body: list = field(default_factory=list)
+    is_single_expr: bool = False

pineforge_codegen/codegen/__init__.py

@@ -0,0 +1,78 @@
+"""Codegen package facade.
+
+Historically the codegen lived in a single ``codegen.py`` module that hit
+~5,700 lines and ~115 methods on a single ``CodeGen`` class. We are
+incrementally splitting it into focused submodules without changing the
+public API:
+
+    from pineforge_codegen.codegen import CodeGen          # primary
+    from pineforge_codegen.codegen import BAR_FIELDS, ...  # constants
+
+Re-exports preserved for ``support_checker.py`` and any external consumers
+that imported module-level rule tables. Add new helper modules under
+``compiler/transpiler/codegen/`` and re-export their public surface here.
+"""
+
+from .base import CodeGen
+from .helpers import CPP_RESERVED
+from .tables import (
+    # Bar-data tables (consumed by helpers + support_checker).
+    BAR_FIELDS,
+    BAR_BUILTINS,
+    BAR_SERIES_PUSH,
+    SECURITY_OHLC_BAR_FIELDS,
+    # Runtime function-name constants emitted as C++ string literals.
+    RUNTIME_REGISTER_SECURITY_EVAL_FN,
+    RUNTIME_REGISTER_SECURITY_LOWER_TF_EVAL_FN,
+    # TA dispatch / arg tables.
+    TA_RETURNS_BOOL,
+    TA_IMPLICIT_COMPUTE,
+    TA_COMPUTE_ARGS,
+    TA_IMPLICIT_COMPUTE_FULL,
+    TA_IMPLICIT_APPEND,
+    TA_TUPLE_FIELDS,
+    # Type and reserved-name tables.
+    PINE_TYPE_TO_CPP,
+    # Skip / passthrough catalogs (used by support_checker).
+    SKIP_FUNC_NAMES,
+    SKIP_NAMESPACES,
+    SKIP_VAR_TYPES,
+    # Built-in dispatch tables (consumed by visitors + support_checker).
+    SYMINFO_MEMBER_MAP,
+    COLOR_CONST_MAP,
+    ARRAY_METHODS,
+    MAP_METHODS,
+    MATRIX_METHODS,
+    MATRIX_METHOD_KWARGS,
+    MATRIX_RETURNING_METHODS,
+    MATH_FUNC_MAP,
+    STR_FUNC_MAP,
+)
+
+__all__ = [
+    "CodeGen",
+    "BAR_FIELDS",
+    "BAR_BUILTINS",
+    "BAR_SERIES_PUSH",
+    "SECURITY_OHLC_BAR_FIELDS",
+    "TA_RETURNS_BOOL",
+    "TA_IMPLICIT_COMPUTE",
+    "TA_COMPUTE_ARGS",
+    "TA_IMPLICIT_COMPUTE_FULL",
+    "TA_IMPLICIT_APPEND",
+    "TA_TUPLE_FIELDS",
+    "PINE_TYPE_TO_CPP",
+    "CPP_RESERVED",
+    "SKIP_FUNC_NAMES",
+    "SKIP_NAMESPACES",
+    "SKIP_VAR_TYPES",
+    "SYMINFO_MEMBER_MAP",
+    "COLOR_CONST_MAP",
+    "ARRAY_METHODS",
+    "MAP_METHODS",
+    "MATRIX_METHODS",
+    "MATRIX_METHOD_KWARGS",
+    "MATRIX_RETURNING_METHODS",
+    "MATH_FUNC_MAP",
+    "STR_FUNC_MAP",
+]