opencode-pine2pyne 0.2.0__tar.gz → 0.2.1__tar.gz

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-pine2pyne
-Version: 0.2.0
+Version: 0.2.1
 Summary: Pine Script v6 to PyneCore Python transpiler
 Author: rubycell
 License-Expression: Apache-2.0

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/opencode_pine2pyne.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-pine2pyne
-Version: 0.2.0
+Version: 0.2.1
 Summary: Pine Script v6 to PyneCore Python transpiler
 Author: rubycell
 License-Expression: Apache-2.0

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/opencode_pine2pyne.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ pine2pyne/bool_builtins.py
 pine2pyne/bool_value_typing.py
 pine2pyne/cli.py
 pine2pyne/codegen.py
+pine2pyne/conditional_history_calls.py
 pine2pyne/emitted_names.py
 pine2pyne/errors.py
 pine2pyne/for_loop_end_bound.py
@@ -40,14 +41,17 @@ pine2pyne/tokens.py
 pine2pyne/transformer.py
 pine2pyne/type_inference.py
 pine2pyne/udt_field_defaults.py
+tests/test_assignment_to_a_call_result_field.py
 tests/test_block_tail_value_runtime.py
 tests/test_block_value_runtime.py
+tests/test_builtin_named_function_and_enum_input.py
 tests/test_cli.py
 tests/test_codegen.py
 tests/test_codegen_operator_grouping.py
 tests/test_codegen_refusal.py
 tests/test_collect_namespace_members.py
 tests/test_compare_ground_truth_completeness.py
+tests/test_conditional_history_call_warning.py
 tests/test_corpus_regression.py
 tests/test_dotted_udt_default_runtime.py
 tests/test_drawing_receiver_runtime.py
@@ -73,9 +77,11 @@ tests/test_grouped_history_runtime.py
 tests/test_import_resolver.py
 tests/test_input_constant_and_enum_order_runtime.py
 tests/test_input_history_read_runtime.py
+tests/test_input_numeric_positional_binding.py
 tests/test_lexer.py
 tests/test_library_name_collision.py
 tests/test_library_name_collision_runtime.py
+tests/test_loop_and_array_edge_cases.py
 tests/test_method_namespaces.py
 tests/test_method_receiver_shape_runtime.py
 tests/test_method_routing_runtime.py

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/pine2pyne/__init__.py

@@ -5,7 +5,7 @@ A tool to convert TradingView Pine Script indicators and strategies
 to PyneCore Python code for local backtesting and analysis.
 """
 
-__version__ = '0.2.0'
+__version__ = '0.2.1'
 __author__ = 'Pine2Pyne Transpiler'
 
 from .lexer import Lexer, tokenize

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/pine2pyne/ast_nodes.py

@@ -302,6 +302,7 @@ class ForLoop(Statement):
     # counter (`pine_loop`) that re-reads it; empty for a fixed `pine_range` (card #82)
     counter_name: str = ""
     counter_helper: str = ""  # the name `pine_loop` is imported under (an alias when the script uses the name)
+    range_helper: str = ""  # the name `pine_range` is imported under for a fixed loop; empty is `pine_range` (card #94)
 
 
 @dataclass

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/pine2pyne/codegen.py

@@ -542,11 +542,12 @@ class CodeGenerator:
                 self.generate_statement(s)
             self.indent_level -= 1
             return
+        range_helper = stmt.range_helper or 'pine_range'
         if stmt.step:
             step = self.generate_expression(stmt.step)
-            self.emit(f'for {var} in pine_range({from_val}, {to_val}, {step}):')
+            self.emit(f'for {var} in {range_helper}({from_val}, {to_val}, {step}):')
         else:
-            self.emit(f'for {var} in pine_range({from_val}, {to_val}):')
+            self.emit(f'for {var} in {range_helper}({from_val}, {to_val}):')
 
         self.indent_level += 1
         for s in stmt.body:

opencode_pine2pyne-0.2.1/pine2pyne/conditional_history_calls.py

@@ -0,0 +1,96 @@
+"""A `ta.*` call that runs on only some bars (card #96).
+
+Pine keeps a call site's series history by running the call on every bar. A `ta.*` call
+reached only when a condition holds keeps a history that skips the other bars, so its value
+differs from the same call made on every bar (card #60 measured this: the transpiled output
+matches Pine's call-site semantics in every construct, and a hoisted call gives another value).
+The Pine User Manual (Execution model) says to run such functions in the global scope for
+consistent results. The transpiler never hoists: it keeps the call where the script has it and
+reports the site, as TradingView does, so the author decides.
+
+A call is conditional when it sits in:
+- the body of an `if`, `else if` or `else`, or an `else if` condition (it is read only when the
+  earlier ones failed), as a statement or as a value;
+- a branch of `?:`;
+- a `switch` arm or its default, or a case after the first (the first case is always read);
+- the right operand of `and` / `or` in Pine v6, which evaluates them lazily. Pine v5 and earlier
+  evaluate both operands (card #65), so the right operand there is not conditional.
+
+A function body starts unconditional again: whether the function is called conditionally is not
+decided here. A loop body is not conditional. `ta.vwap` and the other argument-free `ta.`
+variables are not calls and are hoisted by the transpiler already.
+"""
+from typing import List
+
+from .ast_nodes import (
+    BinaryOp, FuncDecl, FunctionCall, IfExpression, IfStatement, Script, SwitchExpression, SwitchStatement,
+    TernaryOp,
+)
+from .ast_walk import child_field_names, is_node
+from .strict_boolean import BOOLEAN_OPERATORS, evaluates_and_or_strictly
+
+HISTORY_CALL_PREFIX = 'ta.'
+
+
+def conditional_history_calls(script: Script) -> List[FunctionCall]:
+    """Every `ta.*` call of `script` that runs on only some bars, in source order."""
+    finder = _ConditionalCallFinder(evaluates_and_or_strictly(script))
+    finder.visit(script, False)
+    return sorted(finder.calls, key=lambda call: (call.line, call.column))
+
+
+class _ConditionalCallFinder:
+    def __init__(self, right_operand_always_runs: bool):
+        self.right_operand_always_runs = right_operand_always_runs
+        self.calls: List[FunctionCall] = []
+
+    def visit(self, value, conditional: bool) -> None:
+        if isinstance(value, (list, tuple)):
+            for item in value:
+                self.visit(item, conditional)
+        elif isinstance(value, dict):
+            for item in value.values():
+                self.visit(item, conditional)
+        elif is_node(value):
+            self.visit_node(value, conditional)
+
+    def visit_node(self, node, conditional: bool) -> None:
+        if isinstance(node, (IfStatement, IfExpression, TernaryOp)):
+            self.visit_branches(node, conditional)
+        elif isinstance(node, (SwitchStatement, SwitchExpression)):
+            self.visit_switch(node, conditional)
+        elif isinstance(node, BinaryOp) and node.op in BOOLEAN_OPERATORS:
+            self.visit(node.left, conditional)
+            self.visit(node.right, conditional or not self.right_operand_always_runs)
+        elif isinstance(node, FuncDecl):
+            self.visit(node.params, False)
+            self.visit(node.body, False)
+        else:
+            if conditional and isinstance(node, FunctionCall) and _is_history_call(node):
+                self.calls.append(node)
+            for name in child_field_names(type(node)):
+                self.visit(getattr(node, name), conditional)
+
+    def visit_branches(self, node, conditional: bool) -> None:
+        """The condition always runs; each branch and every `else if` condition only after it."""
+        self.visit(node.condition, conditional)
+        if isinstance(node, IfStatement):
+            self.visit(node.body, True)
+            for condition, body in node.elseifs:
+                self.visit(condition, True)
+                self.visit(body, True)
+            self.visit(node.else_body, True)
+        else:
+            self.visit(node.true_expr, True)
+            self.visit(node.false_expr, True)
+
+    def visit_switch(self, node, conditional: bool) -> None:
+        self.visit(node.expr, conditional)
+        for index, (case, body) in enumerate(node.cases):
+            self.visit(case, conditional if index == 0 else True)
+            self.visit(body, True)
+        self.visit(node.default, True)
+
+
+def _is_history_call(call: FunctionCall) -> bool:
+    return isinstance(call.func, str) and call.func.startswith(HISTORY_CALL_PREFIX)

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/pine2pyne/errors.py

@@ -53,7 +53,8 @@ class SemanticError(Pine2PyneError):
 class SemanticWarning(UserWarning):
     """A program TradingView refuses that is still transpiled, output unchanged
     (operator decision 2026-09-24, card #28): a same-scope redeclaration, a read
-    before the declaration. Carries the rule's `code` and the Pine position;
+    before the declaration; and, though TradingView compiles it, a `ta.*` call
+    that runs on only some bars (card #96). Carries the rule's `code` and the Pine position;
     under `-W error` it propagates as an exception like a refusal."""
     def __init__(self, code: str, message: str, line: int = 0, column: int = 0):
         super().__init__(f'{line}:{column}: {message} [{code}]')

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/pine2pyne/import_resolver.py

@@ -31,6 +31,7 @@ class ImportResolver:
         self.uses_method_call = False  # method_call for explicit method calling
         self.uses_overload = False  # pynecore @overload for same-name declarations
         self.uses_pine_range = False  # pine_range for loops
+        self.pine_range_name = 'pine_range'  # the name pine_range is imported under; the transformer sets an alias when the script uses the name (card #94)
         self.pine_loop_name = ''  # the name pine_loop is imported under: a v6 for loop re-reads its end (card #82)
         self.uses_cast_int = False  # cast_int for type casting
         self.uses_cast_float = False  # cast_float for type casting
@@ -308,8 +309,10 @@ class ImportResolver:
             imports.append("from pynecore import pine_loop")
         elif self.pine_loop_name:
             imports.append(f"from pynecore import pine_loop as {self.pine_loop_name}")
-        if self.uses_pine_range:
+        if self.uses_pine_range and self.pine_range_name == 'pine_range':
             imports.append("from pynecore import pine_range")
+        elif self.uses_pine_range:
+            imports.append(f"from pynecore import pine_range as {self.pine_range_name}")
 
         # 2. Pine cast (if used)
         if self.uses_cast_int or self.uses_cast_float or self.uses_cast_bool:

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/pine2pyne/parser.py

@@ -8,8 +8,9 @@ import warnings
 from typing import List, Optional, Union
 from .tokens import Token, TokenType
 from .ast_nodes import *
-from .errors import ParserError, SemanticError
+from .errors import ParserError, SemanticError, UnsupportedFeatureError
 from .once_lowering import lower_once_structures
+from .scope_renamer import fresh_name
 
 
 def _pine_version(version: Optional[VersionAnnotation]) -> int:
@@ -18,6 +19,26 @@ def _pine_version(version: Optional[VersionAnnotation]) -> int:
     return int(text) if str(text).isdigit() else 0
 
 
+# `x += 5` is read as `x := x + 5`: the operator each compound assignment token stands for
+COMPOUND_ASSIGNMENT_OPERATORS = {
+    TokenType.PLUS_ASSIGN: '+',
+    TokenType.MINUS_ASSIGN: '-',
+    TokenType.MULT_ASSIGN: '*',
+    TokenType.DIV_ASSIGN: '/',
+    TokenType.MOD_ASSIGN: '%',
+}
+# The variable that holds the receiver of `arr.get(0).v += 1` (card #98)
+RECEIVER_NAME_STEM = 'assigned_field_receiver'
+
+
+def _as_statement_list(statement) -> list:
+    """What parse_statement returned as a list: one statement, several (a source statement
+    lowered to more than one, card #98), or none."""
+    if isinstance(statement, list):
+        return statement
+    return [statement] if statement else []
+
+
 class Parser:
     """Recursive descent parser for Pine Script v6."""
 
@@ -29,6 +50,7 @@ class Parser:
         # instead; the meaningful VERSION_ANNOTATION is preserved.
         self.tokens = [t for t in tokens if t.type is not TokenType.COMPILER_ANNOTATION]
         self.pos = 0
+        self._token_names: Optional[set] = None  # every name the tokens hold, read on first use (card #98)
 
     def current_token(self) -> Token:
         """Get current token without advancing."""
@@ -221,14 +243,12 @@ class Parser:
                     # Not a simple input declaration (e.g., input.string(...) == "On")
                     # Fall back to parsing as a regular statement
                     self.pos = saved_pos
-                    stmt = self.parse_statement()
-                    if stmt:
+                    for stmt in _as_statement_list(self.parse_statement()):
                         self._stamp_top_level(stmt, start_token)
                         script.body.append(stmt)
             # Otherwise, parse as statement
             else:
-                stmt = self.parse_statement()
-                if stmt:
+                for stmt in _as_statement_list(self.parse_statement()):
                     self._stamp_top_level(stmt, start_token)
                     script.body.append(stmt)
 
@@ -803,8 +823,9 @@ class Parser:
     # Statement parsing
     # ========================================================================
 
-    def parse_statement(self) -> Optional[Statement]:
-        """Parse a single statement."""
+    def parse_statement(self) -> Union[Statement, List[Statement], None]:
+        """Parse one source statement: a statement, a list of statements when the source statement is
+        lowered to several (an assignment to a field of a call result, card #98), or None."""
         self.skip_newlines()
 
         # If statement
@@ -903,13 +924,20 @@ class Parser:
             return self.parse_function_declaration()
 
         # Assignment or expression statement
+        start_token = self.current_token()
         expr = self.parse_expression()
 
         # Check for assignment/reassignment
         if self.match(TokenType.ASSIGN):
-            self._refuse_history_target(expr, self.advance())
+            operator_token = self.advance()
+            self._refuse_history_target(expr, operator_token)
+            call_result_field = self._is_call_result_field(expr)
+            if not call_result_field:
+                self._refuse_unassignable_target(expr, operator_token, tuple_allowed=True)
             value = self.parse_expression()
 
+            if call_result_field:
+                return self._lower_call_result_field_assignment(expr, operator_token, value, start_token)
             if isinstance(expr, Identifier):
                 return Assignment(target=expr.name, value=value)
             elif isinstance(expr, ArrayLiteral):
@@ -918,9 +946,15 @@ class Parser:
                 return Assignment(target=TupleDestructure(names=names, value=value), value=value)
 
         elif self.match(TokenType.REASSIGN):
-            self._refuse_history_target(expr, self.advance())
+            operator_token = self.advance()
+            self._refuse_history_target(expr, operator_token)
+            call_result_field = self._is_call_result_field(expr)
+            if not call_result_field:
+                self._refuse_unassignable_target(expr, operator_token)
             value = self.parse_expression()
 
+            if call_result_field:
+                return self._lower_call_result_field_assignment(expr, operator_token, value, start_token)
             if isinstance(expr, Identifier):
                 return Reassignment(target=expr.name, value=value)
 
@@ -929,19 +963,16 @@ class Parser:
                         TokenType.DIV_ASSIGN, TokenType.MOD_ASSIGN):
             op_token = self.advance()
             self._refuse_history_target(expr, op_token)
+            call_result_field = self._is_call_result_field(expr)
+            if not call_result_field:
+                self._refuse_unassignable_target(expr, op_token)
             right_value = self.parse_expression()
 
+            if call_result_field:
+                return self._lower_call_result_field_assignment(expr, op_token, right_value, start_token)
             if isinstance(expr, Identifier):
                 # Convert x += 5 to x := x + 5
-                # Determine the operator symbol
-                op_map = {
-                    TokenType.PLUS_ASSIGN: '+',
-                    TokenType.MINUS_ASSIGN: '-',
-                    TokenType.MULT_ASSIGN: '*',
-                    TokenType.DIV_ASSIGN: '/',
-                    TokenType.MOD_ASSIGN: '%',
-                }
-                op_symbol = op_map[op_token.type]
+                op_symbol = COMPOUND_ASSIGNMENT_OPERATORS[op_token.type]
 
                 # Create binary expression: x + 5
                 from .ast_nodes import BinaryOp
@@ -964,6 +995,56 @@ class Parser:
                                 f'cannot assign with {operator_token.value!r} to a history reference (x[n])',
                                 operator_token.line, operator_token.column)
 
+    @staticmethod
+    def _is_call_result_field(target: Expression) -> bool:
+        """`arr.get(0).v`: a field of the value an expression returns (card #98)."""
+        return isinstance(target, MemberAccess) and not isinstance(target.object, str)
+
+    def _lower_call_result_field_assignment(self, target: MemberAccess, operator_token: Token, value: Expression,
+                                            start_token: Token) -> List[Statement]:
+        """`arr.get(0).v += 1` -> `assigned_field_receiver1 = arr.get(0)` then
+        `assigned_field_receiver1.v := assigned_field_receiver1.v + 1` (card #98).
+
+        The receiver is the object a call returns, so the field changes in that object; binding it
+        to a variable first evaluates the call once, as Pine does, and uses the dotted-name
+        assignment every later stage already handles. The variable is fresh against every
+        identifier of the script."""
+        receiver = self._fresh_receiver_name()
+        field = f'{receiver}.{target.member}'
+        position = self._position_of(start_token)
+        if operator_token.type is TokenType.ASSIGN:
+            assigned = Assignment(target=field, value=value)
+        elif operator_token.type is TokenType.REASSIGN:
+            assigned = Reassignment(target=field, value=value)
+        else:
+            current = Identifier(name=field, **position)
+            assigned = Reassignment(target=field, value=BinaryOp(
+                left=current, op=COMPOUND_ASSIGNMENT_OPERATORS[operator_token.type], right=value, **position))
+        statements = [Assignment(target=receiver, value=target.object), assigned]
+        for statement in statements:
+            statement.line, statement.column = position.get('line', 0), position.get('column', 0)
+        return statements
+
+    def _fresh_receiver_name(self) -> str:
+        """`assigned_field_receiver<N>`, the lowest N no identifier of the script holds."""
+        if self._token_names is None:
+            self._token_names = {part for token in self.tokens if isinstance(token.value, str)
+                                 for part in token.value.split('.')}
+        return fresh_name(RECEIVER_NAME_STEM, self._token_names)
+
+    @staticmethod
+    def _refuse_unassignable_target(target: Expression, operator_token: Token, tuple_allowed: bool = False) -> None:
+        """`arr.get(0).v += 1` is valid Pine, but the tree keeps an assignment only to a name (a
+        dotted field path included) or, for `=`, a tuple. Any other target used to be dropped
+        without a word, leaving a bare expression statement, so it is refused at the operator
+        (card #94)."""
+        if isinstance(target, Identifier) or (tuple_allowed and isinstance(target, ArrayLiteral)):
+            return
+        raise UnsupportedFeatureError(
+            f'assignment with {operator_token.value!r} to the result of an expression; '
+            f'assign the receiver to a variable first and assign its field',
+            operator_token.line, operator_token.column)
+
     def parse_block(self) -> List[Statement]:
         """Parse a block of statements (indented)."""
         statements = []
@@ -973,17 +1054,13 @@ class Parser:
             if self.match(TokenType.DEDENT, TokenType.EOF):
                 break
 
-            stmt = self._parse_positioned_statement()
-            if stmt:
-                statements.append(stmt)
+            statements.extend(_as_statement_list(self._parse_positioned_statement()))
 
             # Handle comma-separated statements on the same line
             # e.g., colNum = 8, rowNum = 8
             while self.match(TokenType.COMMA):
                 self.advance()  # consume comma
-                stmt = self._parse_positioned_statement()
-                if stmt:
-                    statements.append(stmt)
+                statements.extend(_as_statement_list(self._parse_positioned_statement()))
 
         return statements
 
@@ -1011,7 +1088,10 @@ class Parser:
 
     def _parse_positioned_statement(self):
         start_token = self.current_token()
-        return self._stamp_nested(self.parse_statement(), start_token)
+        statement = self.parse_statement()
+        if isinstance(statement, list):  # one source statement lowered to several (card #98)
+            return [self._stamp_nested(item, start_token) for item in statement]
+        return self._stamp_nested(statement, start_token)
 
     def _parse_positioned_single_line_item(self):
         start_token = self.current_token()
@@ -1207,8 +1287,7 @@ class Parser:
                     default = self.parse_block()
                     self.expect(TokenType.DEDENT)
                 else:
-                    case_stmt = self._parse_positioned_statement()
-                    default = [case_stmt] if case_stmt else []
+                    default = _as_statement_list(self._parse_positioned_statement())
                 self.skip_newlines()
                 continue
 
@@ -1225,8 +1304,7 @@ class Parser:
                 self.expect(TokenType.DEDENT)
             else:
                 # Single line
-                case_stmt = self._parse_positioned_statement()
-                case_body = [case_stmt] if case_stmt else []
+                case_body = _as_statement_list(self._parse_positioned_statement())
 
             cases.append((case_expr, case_body))
 

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/pine2pyne/pine_builtins.py

@@ -233,6 +233,7 @@ INPUT_FUNCTIONS: Set[str] = {
     'input.symbol',
     'input.price',
     'input.time',
+    'input.enum',
 }
 
 
@@ -244,8 +245,8 @@ def is_input_function(func_name: str) -> bool:
 # Pine Script input.* positional parameter names (after defval, title).
 # Pine Script allows these as positional; PyneCore requires keyword-only.
 INPUT_POSITIONAL_PARAMS: Dict[str, list[str]] = {
-    'input.int':       ['minval', 'maxval', 'step', 'tooltip', 'inline', 'group', 'confirm', 'display', 'options'],
-    'input.float':     ['minval', 'maxval', 'step', 'tooltip', 'inline', 'group', 'confirm', 'display', 'options'],
+    'input.int':       ['minval', 'maxval', 'step', 'tooltip', 'inline', 'group', 'confirm', 'display', 'active'],
+    'input.float':     ['minval', 'maxval', 'step', 'tooltip', 'inline', 'group', 'confirm', 'display', 'active'],
     'input.bool':      ['tooltip', 'inline', 'group', 'confirm', 'display'],
     'input.string':    ['options', 'tooltip', 'inline', 'group', 'confirm', 'display'],
     'input.color':     ['tooltip', 'inline', 'group', 'confirm', 'display'],
@@ -256,8 +257,36 @@ INPUT_POSITIONAL_PARAMS: Dict[str, list[str]] = {
     'input.source':    ['tooltip', 'inline', 'group', 'display', 'active', 'confirm'],
     'input.price':     ['tooltip', 'inline', 'group', 'confirm', 'display'],
     'input.time':      ['tooltip', 'inline', 'group', 'confirm', 'display'],
+    'input.enum':      ['options', 'tooltip', 'inline', 'group', 'confirm', 'display', 'active'],  # card #97
 }
 
+# input.int/input.float have a second positional form after `title` (v6 reference): the options form,
+# selected by a list third argument (pynecore's _bind_numeric_tail, _NUMERIC_OPTIONS_TAIL; card #95).
+NUMERIC_INPUT_FUNCTIONS: FrozenSet[str] = frozenset({'input.int', 'input.float'})
+NUMERIC_INPUT_OPTIONS_POSITIONAL_PARAMS: list[str] = ['options', 'tooltip', 'inline', 'group', 'confirm',
+                                                      'display', 'active']
+
+
+def input_positional_param_names(func_name: str, positional_args: list) -> list[str]:
+    """The names Pine gives the positional arguments of an input.* call after `defval` and `title`
+    (empty for a function this table does not list). The one place that decides which positional
+    form a call uses, for the transformer and the semantic pass alike."""
+    from .ast_nodes import ArrayLiteral
+    if func_name in NUMERIC_INPUT_FUNCTIONS and len(positional_args) > 2 \
+            and isinstance(positional_args[2], ArrayLiteral):
+        return NUMERIC_INPUT_OPTIONS_POSITIONAL_PARAMS
+    return INPUT_POSITIONAL_PARAMS.get(func_name, [])
+
+
+def bind_input_positional_args(func_name: str, positional_args: list) -> Tuple[list, dict]:
+    """Split an input.* call's positional arguments into `defval, title` and the rest bound by
+    name: PyneCore takes everything after `title` as a keyword. A positional past the last name
+    is dropped, as before card #95."""
+    names = input_positional_param_names(func_name, positional_args)
+    if not names or len(positional_args) <= 2:
+        return list(positional_args), {}
+    return list(positional_args[:2]), dict(zip(names, positional_args[2:]))
+
 
 # Pine's positional parameter order of the script declarations (Pine v6 reference; card #55).
 # The parser binds positionals to these names and codegen emits keywords, so pynecore's own

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/pine2pyne/pine_semantics.py

@@ -16,7 +16,9 @@ statement.
   declaration (from a function or block too) or in its own declaration.
   enforce() reports each once per (line, column, name, code) as a
   SemanticWarning, at its statement, when the script has no refusal; the
-  output is unchanged.
+  output is unchanged. Also a warning, though TradingView compiles it: a
+  `ta.*` call that runs on only some bars, whose history differs from the
+  every-bar call (conditional_history_calls.py, card #96). Never hoisted.
 
 The pass never rewrites the tree, so a script it accepts transpiles exactly as
 before. An assignment to a history reference (`x[1] := v`) is refused by the
@@ -33,18 +35,19 @@ import warnings
 from typing import Dict, List, NamedTuple, Optional, Tuple
 
 from .ast_nodes import (
-    ArrayLiteral, Assignment, EnumDecl, Expression, ExpressionStatement, ForInLoop, ForLoop, FuncDecl,
+    Assignment, EnumDecl, Expression, ExpressionStatement, ForInLoop, ForLoop, FuncDecl,
     FunctionCall, Identifier, IfExpression, IfStatement, IndexAccess, InputDecl, Literal, MemberAccess,
     MethodCall, Reassignment, ReturnStatement, Script, Statement, SwitchExpression,
     SwitchStatement, TupleDestructure, TypeDecl, VarDecl, VaripDecl, WhileLoop,
 )
 from .ast_walk import walk
+from .conditional_history_calls import conditional_history_calls
 from .errors import SemanticError, SemanticWarning
 from .library_collision import (
     FieldReadRule, HeadBinding, declared_type, global_binding_types, script_type_evidence,
 )
 from .namespace_members import NAMESPACE_MEMBERS
-from .pine_builtins import INPUT_POSITIONAL_PARAMS, PYNECORE_LIB_MODULES, SERIES_VARIABLES
+from .pine_builtins import PYNECORE_LIB_MODULES, SERIES_VARIABLES, input_positional_param_names
 from .symbol_table import SymbolTable
 from .udt_field_defaults import constant_heads, default_message, invalid_defaults, positioned_part
 
@@ -99,10 +102,6 @@ PARAMETER, LOOP_VARIABLE, INPUT, VARIABLE = 'parameter', 'loop variable', 'input
 STATEMENT_TYPES = typing.get_args(Statement)
 SCOPE_KIND_TEXT = {'if': 'an if block', 'for': 'a for loop', 'while': 'a while loop',
                    'switch': 'a switch', 'function': 'a function'}
-# input.int/input.float have two positional forms after `title` (v6 reference): the minval form
-# (INPUT_POSITIONAL_PARAMS) and the options form, selected by a list third argument
-NUMERIC_INPUTS = frozenset({'input.int', 'input.float'})
-NUMERIC_INPUT_OPTIONS_TAIL = ['options', 'tooltip', 'inline', 'group', 'confirm', 'display']
 UNDECLARED_MESSAGE = ("'{}' is declared only inside a block or function that has ended here; "
                       "TradingView reports it as undeclared")
 
@@ -182,6 +181,7 @@ def _pine_version(script: Script) -> int:
 
 class _SemanticCheck:
     def __init__(self, script: Script):
+        self.script = script
         self.version = _pine_version(script)
         self.constant_heads = constant_heads(script)
         self.builtin_names = BUILTIN_NAMES | (LEGACY_BUILTIN_VARIABLES if self.version <= LAST_LEGACY_VERSION
@@ -311,8 +311,18 @@ class _SemanticCheck:
         stack = [self.new_scope('global')]
         for item in self.top_items:
             self.statement(item, stack)
+        self.conditional_history_calls()
         return sorted(self.diagnostics, key=lambda diagnostic: (diagnostic.line, diagnostic.column))
 
+    def conditional_history_calls(self) -> None:
+        """A `ta.*` call that runs on only some bars keeps a history that differs from the
+        every-bar call (card #96). A warning only: the call stays where the script has it."""
+        for call in conditional_history_calls(self.script):
+            self.report(WARN, 'conditional-history-call', call.func,
+                        f"'{call.func}' is called only when its condition holds: its series history "
+                        f'differs from an unconditional call (the output keeps the call where it is, as TradingView '
+                        f'does; TradingView advises calling it on every bar, in the global scope)', call)
+
     def block(self, statements, stack: List[_Scope], kind: str, names=(), how=LOOP_VARIABLE,
               types: Optional[Dict[str, Optional[str]]] = None) -> None:
         inner = stack + [self.new_scope(kind, statements if statements is not None else ())]
@@ -367,10 +377,7 @@ class _SemanticCheck:
         """An input's arguments must be const, so they cannot read another input (manual,
         Inputs: "results from other input*() calls"); `active` takes an input bool, and
         input.source's `defval` a series float (card #89)."""
-        parameters = ['defval', 'title'] + INPUT_POSITIONAL_PARAMS.get(node.func, [])
-        if node.func in NUMERIC_INPUTS and len(node.args) > 2 and isinstance(node.args[2], ArrayLiteral):
-            # the options form of input.int/input.float (pynecore's _bind_numeric_tail)
-            parameters = ['defval', 'title'] + NUMERIC_INPUT_OPTIONS_TAIL
+        parameters = ['defval', 'title'] + input_positional_param_names(node.func, node.args)
         # a row that does not name `active` ends at `display`: a positional argument after it is `active`
         positional = (parameters[:parameters.index('display') + 1]
                       if 'display' in parameters and 'active' not in parameters else parameters)

{opencode_pine2pyne-0.2.0 → opencode_pine2pyne-0.2.1}/pine2pyne/scope_renamer.py

@@ -15,7 +15,9 @@ declaration keep the outer name, as in Pine.
 A binding named like a pynecore.lib name that the script also uses as that
 name (`f(color = color.red) => color.r(color)`) is renamed too, together with
 its uses and the keyword arguments that name it; a declared function shadows
-every bare call of its name (card #9). `N.m` keeps the namespace when `m` is
+every bare call of its name (card #9). A function named like a builtin series
+(`hour(x) => x * 3`, `close(x) => ...`) is renamed too whether or not the script reads
+the series: its calls go to the new name and a bare read of the name stays the series (card #97). `N.m` keeps the namespace when `m` is
 not the binding's own member (see library_collision.MemberRule). Two kinds of
 binding keep their name: an input (its name is the key of the script's input
 settings) and an `export` declaration (its name is the library's API); a
@@ -181,7 +183,7 @@ class _ScopeRenamer:
         # type of `x = mk()` (card #87), `x = array.get(a, 0)` or `x = c ? T.new() : na` (card #91)
         self.type_evidence = script_type_evidence(script)
         self.namespace_aliases: Dict[str, str] = {}
-        # library-named user function -> its emitted name (shared by its overloads)
+        # user function named like a library name or a builtin series -> its emitted name (shared by its overloads)
         self.function_names: Dict[str, str] = {}
         # function or method name -> {renamed parameter: its emitted name}
         self.parameter_names: Dict[str, Dict[str, str]] = {}
@@ -437,8 +439,8 @@ class _ScopeRenamer:
                                    return_type=self.type_hint(node.return_type))
 
     def plan_functions(self, script: Script) -> None:
-        """Fresh names for library-named user functions (every overload shares
-        one) and their parameters named like a library name or a script global
+        """Fresh names for user functions named like a library name or a builtin
+        series (every overload shares one) and their parameters named like a library name or a script global
         (one per function name, so a keyword argument maps the same way to every
         overload). An `export` declaration keeps its names."""
         global_names = script_global_names(script)
@@ -452,7 +454,11 @@ class _ScopeRenamer:
                 self.plan_export_parameters(declaration)
                 continue
             name = declaration.name
-            if name in self.library_names and not declaration.is_method and name not in self.function_names:
+            # a function named like a pynecore.lib name the script uses, or like a builtin series (card
+            # #97): the module imports the builtin wherever its name is read, and pynecore reads the
+            # library object for every use of an imported name, the function's calls included
+            if ((name in self.library_names or name in SERIES_VARIABLES)
+                    and not declaration.is_method and name not in self.function_names):
                 self.function_names[name] = self.fresh_name(name)
             elif name not in self.function_names and (
                     name in PYTHON_RESERVED_WORDS or name in self.external_spellings):
@@ -715,6 +721,6 @@ class _ScopeRenamer:
                         for declaration in script.declarations]
         body = [self.in_source_order(self.global_statement, statement) for statement in script.body]
         if not (self.shadowed_names or self.library_names or any(self.parameter_names.values())
-                or self.spellings.changed or self.moved_bindings or self.moved_inputs):
+                or self.spellings.changed or self.moved_bindings or self.moved_inputs or self.function_names):
             return script
         return dataclasses.replace(script, declarations=declarations, body=body)