pine2pyne 0.2.4__py3-none-any.whl

pine2pyne/emit/pynecomp/unparser.py

@@ -0,0 +1,186 @@
+"""Expression printing: :func:`ast.unparse`, as PyneComp uses it.
+
+PyneComp builds a Python AST and prints every expression with the standard
+library unparser: minimal parentheses (``a and (not b)`` but ``not a and b``),
+``repr`` of numbers (``3.141592653589793``), single-quoted strings. Of 141 579
+one-line statements in ``assets/pyne`` all but the string literals print
+exactly as :func:`ast.unparse` prints them. Two string rules differ:
+
+* printable non-ASCII characters are written as they are (``' '`` is an
+  em space in the file, not an escape), only control characters are escaped;
+* some string literals of a Pine v6 script keep the quotes the source wrote
+  them with (which ones: :func:`source_quoted_strings`).
+"""
+from __future__ import annotations
+
+import ast
+import re
+import unicodedata
+from typing import Collection, Mapping, Sequence
+
+_ESCAPE = re.compile(r'\\\\|\\x[0-9a-f]{2}|\\u[0-9a-f]{4}|\\U[0-9a-f]{8}')
+
+
+def string_literal(value: str, single_quoted: bool = True, raw: bool = True) -> str:
+    """A single-quoted literal (``'it\\'s'``: PyneComp never switches to double
+    quotes) with ``repr``'s escapes. ``raw``: a string PyneComp writes as the source
+    has it (header, input and whole-assignment strings, :func:`source_quoted_strings`)
+    keeps its non-printable non-ASCII characters (``\\u200b``, no-break spaces)
+    unescaped; any other string keeps ``repr``'s escapes for them (probe
+    ``tmp/probes/esc5.pine``, ``esc6.pine``). Control characters are always escaped."""
+    def unescape(match: re.Match) -> str:
+        text = match.group(0)
+        if text == '\\\\':
+            return text
+        character = chr(int(text[2:], 16))
+        return text if unicodedata.category(character) == 'Cc' else character
+    text = repr(value)
+    if single_quoted and text.startswith('"'):  # repr chose double quotes: value has a ' and no "
+        text = "'" + text[1:-1].replace("'", "\\'") + "'"
+    return _ESCAPE.sub(unescape, text) if raw else text
+
+
+def header_strings(tree: ast.Module) -> set[int]:
+    """``id()`` of the strings a Pine v4/v5 module writes in single quotes whatever they hold
+    (``'it\\'s'``): the direct arguments of main()'s decorator and of its parameter defaults (an
+    element of a tuple argument too), and a module constant's whole value. A part of a
+    concatenation (``'a' + "b's"``) is spelled as ``repr`` spells it (the reference)."""
+    found: set[int] = set()
+
+    def is_string(node) -> bool:
+        return isinstance(node, ast.Constant) and isinstance(node.value, str)
+
+    def direct(call) -> None:
+        if not isinstance(call, ast.Call):
+            return
+        for argument in [*call.args, *(keyword.value for keyword in call.keywords)]:
+            if is_string(argument):
+                found.add(id(argument))
+            elif isinstance(argument, (ast.Tuple, ast.List)):
+                found.update(id(element) for element in argument.elts if is_string(element))
+
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef) and node.name == 'main':
+            for part in node.decorator_list + node.args.defaults + [d for d in node.args.kw_defaults if d is not None]:
+                direct(part)
+        elif isinstance(node, (ast.Assign, ast.AnnAssign)) and is_string(node.value):
+            found.add(id(node.value))
+    # and a declaration's whole string value anywhere (`ERR_TXT: str = '... \'{0}\' ...'`, PineCoders/lower_tf)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.AnnAssign) and is_string(node.value):
+            found.add(id(node.value))
+    return found
+
+
+def source_quoted_strings(tree: ast.Module) -> set[int]:
+    """``id()`` of the string literals PyneComp prints with their source quotes
+    in a Pine v6 script: decorator and ``main`` parameter (input) arguments, a
+    string that is the whole value of an assignment or an element of an
+    assigned tuple. A string elsewhere in the body (a call argument, a
+    comparison operand) is re-quoted (measured on ``assets/pyne``)."""
+    keep: set[int] = set()
+
+    def is_string(node: ast.AST) -> bool:
+        return isinstance(node, ast.Constant) and isinstance(node.value, str)
+
+    def mark_arguments(call: ast.AST) -> None:
+        """The direct arguments of a call, and the elements of a tuple or list passed to it."""
+        if not isinstance(call, ast.Call):
+            return
+        for argument in [*call.args, *(keyword.value for keyword in call.keywords)]:
+            if is_string(argument):
+                keep.add(id(argument))
+            elif isinstance(argument, (ast.Tuple, ast.List)):
+                keep.update(id(element) for element in argument.elts if is_string(element))
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef) and node.name == 'main':
+            for decorator in node.decorator_list:
+                mark_arguments(decorator)
+            for default in node.args.defaults + [d for d in node.args.kw_defaults if d is not None]:
+                mark_arguments(default)
+        elif isinstance(node, ast.FunctionDef):
+            # a user function's string default keeps its source quotes (and the protocol that shares it)
+            keep.update(id(default) for default in node.args.defaults if is_string(default))
+        elif (isinstance(node, ast.Compare) and isinstance(node.left, ast.Name)
+              and node.left.id.startswith('__switch')):
+            # a switch case keeps its source quotes: `__switch__ == "Top Right"`
+            keep.update(id(operand) for operand in node.comparators if is_string(operand))
+        elif isinstance(node, (ast.Assign, ast.AnnAssign, ast.AugAssign)) and node.value is not None:
+            if is_string(node.value):
+                keep.add(id(node.value))
+            elif isinstance(node.value, ast.Tuple):
+                keep.update(id(element) for element in node.value.elts if is_string(element))
+    return keep
+
+
+class SourceQuotingUnparser(ast._Unparser):  # the stdlib unparser, extended at one node type
+    """Unparses like :func:`ast.unparse`, with PyneComp's string rules."""
+
+    def __init__(self, source_lines: Sequence[bytes] = (), source_quoted: Collection[int] = frozenset(),
+                 spellings: Mapping[int, str] | None = None, single_quoted: Collection[int] = frozenset(),
+                 raw_strings: Collection[int] | None = None) -> None:
+        super().__init__()
+        self._source_lines = source_lines
+        self._source_quoted = source_quoted
+        self._spellings = spellings or {}
+        self._single_quoted = single_quoted
+        self._raw_strings = raw_strings
+
+    def _source_text(self, node: ast.AST) -> str | None:
+        lineno = getattr(node, 'lineno', None)
+        end_lineno = getattr(node, 'end_lineno', None)
+        if not lineno or not end_lineno or end_lineno > len(self._source_lines):
+            return None
+        col, end_col = node.col_offset, node.end_col_offset  # UTF-8 byte offsets
+        if lineno == end_lineno:
+            raw = self._source_lines[lineno - 1][col:end_col]
+        else:
+            parts = [self._source_lines[lineno - 1][col:]]
+            parts.extend(self._source_lines[lineno:end_lineno - 1])
+            parts.append(self._source_lines[end_lineno - 1][:end_col])
+            raw = b'\n'.join(parts)
+        try:
+            return raw.decode('utf-8')
+        except UnicodeDecodeError:
+            return None
+
+    def visit_Constant(self, node: ast.Constant) -> None:
+        spelled = self._spellings.get(id(node))
+        if spelled is not None:
+            self.write(spelled)
+            return
+        if not isinstance(node.value, str) or getattr(self, '_avoid_backslashes', False):
+            super().visit_Constant(node)
+            return
+        if id(node) in self._source_quoted:
+            text = self._source_text(node)
+            if text and text[0] in '\'"' and '\n' not in text:
+                try:
+                    same = ast.literal_eval(text) == node.value
+                except (ValueError, SyntaxError):
+                    same = False
+                if same:
+                    self.write(text)
+                    return
+        if node.kind == 'u':
+            self.write('u')
+        raw = self._raw_strings is None or id(node) in self._raw_strings
+        self.write(string_literal(node.value, id(node) in self._single_quoted, raw))
+
+
+class ExpressionPrinter:
+    """Prints one node (an expression or a simple statement) on one line."""
+
+    def __init__(self, python_source: str = '', source_quoted: Collection[int] = frozenset(),
+                 spellings: Mapping[int, str] | None = None, single_quoted: Collection[int] = frozenset(),
+                 raw_strings: Collection[int] | None = None) -> None:
+        self._source_lines = [line.encode('utf-8') for line in python_source.split('\n')]
+        self._source_quoted = source_quoted
+        self._spellings = spellings or {}
+        self._single_quoted = single_quoted
+        self._raw_strings = raw_strings
+
+    def __call__(self, node: ast.AST) -> str:
+        return SourceQuotingUnparser(self._source_lines, self._source_quoted, self._spellings,
+                                     self._single_quoted, self._raw_strings).visit(node)

pine2pyne/emitted_names.py

@@ -0,0 +1,152 @@
+"""Emitted spellings that must not collide with the names a script already uses
+(card #77, review FIX-7).
+
+Pine names that are Python reserved words (`lambda`, `from`, `pass`) cannot be
+emitted as they are. They used to be spelled by `sanitize_identifier` (`lambda_`)
+independently at each place, so `lambda` and a user's `lambda_` became one name,
+and a reference that the escaping missed (a call keyword, a field read) stayed
+invalid Python. Here a spelling is chosen ONCE per name against the complete set
+of names the script holds: the preferred spelling is taken only when it is free,
+else the lowest free numeric suffix (`lambda_1`).
+
+Two spelling domains, because Python keeps them apart:
+- variables, parameters, functions, methods and type names share one scope, so
+  `variable()` avoids every identifier of the script;
+- fields and enum members are attributes, so `attribute()` avoids only attribute
+  names (declared fields, enum members, and the tail of dotted names). A field
+  `lambda` therefore still becomes `lambda_` next to a variable `lambda_`.
+
+Both maps are uniform: one Pine name has one spelling in a domain whatever the
+receiver's type, which is what lets an untyped `p.lambda` read the right field.
+
+What never occupies a spelling: a string literal or a script title (`"lambda_"`).
+"""
+import dataclasses
+import re
+from typing import Dict, Set
+
+from .pine_builtins import PYNECORE_LIB_MODULES, PYTHON_RESERVED_WORDS, sanitize_identifier
+
+# Names the generated module imports or defines itself; no generated spelling may equal one
+MODULE_HELPER_NAMES = frozenset({
+    'Series', 'Persistent', 'udt', 'method', 'pine_range', 'pine_loop', 'method_call', 'na', 'main', 'script',
+})
+EMITTED_HELPER_NAMES = MODULE_HELPER_NAMES | frozenset(PYNECORE_LIB_MODULES)
+
+# A library alias spelled like one of these is renamed (scope_renamer): `lib` is the pynecore library object pynecore's
+# own transformers read in a compiled module, the rest are the helpers the module imports. A namespace or series name
+# is not here: `import x as ta` is pynecore's shadowed_namespace, which a rename would drop (import_resolver refuses it)
+LIBRARY_ALIAS_RENAMED_NAMES = MODULE_HELPER_NAMES | {'lib'}
+
+# Fields that hold text, not names: a title or a literal is not an identifier
+_TEXT_FIELDS = {('IndicatorDecl', 'title'), ('StrategyDecl', 'title'), ('LibraryDecl', 'title'),
+                ('RawCode', 'code')}
+_TEXT_NODES = {'Literal', 'ImportDecl'}
+
+
+def identifier_names(tree) -> Set[str]:
+    """Every identifier-bearing string of the tree (first and later segments of a
+    dotted name, targets, fields, parameters, type-hint tokens, keyword names). A
+    string literal, a title or an import is not one."""
+    names: Set[str] = set()
+    _identifiers_in(tree, names)
+    return names
+
+
+def _identifiers_in(value, names: Set[str]) -> None:
+    if isinstance(value, str):
+        names.update(re.findall(r'[A-Za-z_][A-Za-z0-9_]*', value))
+    elif isinstance(value, (list, tuple, set, frozenset)):
+        for item in value:
+            _identifiers_in(item, names)
+    elif isinstance(value, dict):
+        for key, item in value.items():
+            _identifiers_in(key, names)
+            _identifiers_in(item, names)
+    elif dataclasses.is_dataclass(value) and type(value).__name__ not in _TEXT_NODES:
+        kind = type(value).__name__
+        for field in dataclasses.fields(value):
+            if field.name in ('line', 'column', 'literal_type') or (kind, field.name) in _TEXT_FIELDS:
+                continue
+            _identifiers_in(getattr(value, field.name), names)
+
+
+def attribute_names(tree) -> Set[str]:
+    """Names that are attributes: the declared fields and enum members, and every
+    segment after the head of a dotted name."""
+    names: Set[str] = set()
+    _attributes_in(tree, names)
+    return names
+
+
+def _attributes_in(value, names: Set[str]) -> None:
+    kind = type(value).__name__
+    if isinstance(value, str):
+        names.update(re.findall(r'[A-Za-z_][A-Za-z0-9_]*', value.partition('.')[2]))
+    elif isinstance(value, (list, tuple, set, frozenset)):
+        for item in value:
+            _attributes_in(item, names)
+    elif isinstance(value, dict):
+        for item in value.values():
+            _attributes_in(item, names)
+    elif dataclasses.is_dataclass(value) and kind not in _TEXT_NODES:
+        if kind == 'TypeDecl':
+            names.update(field[0] for field in value.fields)
+        elif kind == 'EnumDecl':
+            names.update(member[0] if isinstance(member, tuple) else member for member in value.members)
+        elif kind == 'MemberAccess':
+            names.add(value.member)
+        for field in dataclasses.fields(value):
+            if field.name in ('line', 'column', 'literal_type') or (kind, field.name) in _TEXT_FIELDS:
+                continue
+            _attributes_in(getattr(value, field.name), names)
+
+
+def free_spelling(preferred: str, occupied: Set[str]) -> str:
+    """`preferred` when no name in `occupied` holds it, else the lowest free
+    numeric suffix of it; the result is recorded as occupied."""
+    spelling, index = preferred, 0
+    while spelling in occupied:
+        index += 1
+        spelling = f'{preferred}{index}'
+    occupied.add(spelling)
+    return spelling
+
+
+class KeywordSpellings:
+    """The spelling of every Pine name that is a Python reserved word, in the two domains."""
+
+    def __init__(self, tree, occupied: Set[str]):
+        # shared with the renamer: identifiers of the script, helper names, names planned so far
+        self.occupied = occupied
+        self.attribute_occupied = attribute_names(tree)
+        self.variables: Dict[str, str] = {}
+        self.attributes: Dict[str, str] = {}
+        # a UDT field named like a pynecore name is `name__ren__` wherever it is read (PyneComp:
+        # `this.map__ren__`, `table__ren__`); a builtin series keeps its name (`bar.close`)
+        from .ast_nodes import TypeDecl
+        from .pine_builtins import PYNECOMP_RESERVED_NAMES, SERIES_VARIABLES
+        self.reserved_fields = {field[0] for node in getattr(tree, 'declarations', ()) if isinstance(node, TypeDecl)
+                                for field in node.fields} & (PYNECOMP_RESERVED_NAMES - SERIES_VARIABLES)
+
+    def variable(self, name: str) -> str:
+        """The spelling of a variable, parameter, function, method or type named `name`."""
+        if name not in PYTHON_RESERVED_WORDS:
+            return name
+        if name not in self.variables:
+            self.variables[name] = free_spelling(sanitize_identifier(name), self.occupied)
+        return self.variables[name]
+
+    def attribute(self, name: str) -> str:
+        """The spelling of a field or enum member named `name`, whatever its type."""
+        if name in self.reserved_fields:
+            return f'{name}__ren__'
+        if name not in PYTHON_RESERVED_WORDS:
+            return name
+        if name not in self.attributes:
+            self.attributes[name] = free_spelling(sanitize_identifier(name), self.attribute_occupied)
+        return self.attributes[name]
+
+    @property
+    def changed(self) -> bool:
+        return bool(self.variables or self.attributes)

pine2pyne/errors.py

@@ -0,0 +1,69 @@
+"""
+Custom error types for the Pine Script transpiler with source location tracking.
+"""
+
+
+class Pine2PyneError(Exception):
+    """Base exception for all transpiler errors."""
+    def __init__(self, message: str, line: int = 0, column: int = 0, source_file: str = None):
+        self.message = message
+        self.line = line
+        self.column = column
+        self.source_file = source_file
+        super().__init__(self.format_message())
+
+    def format_message(self) -> str:
+        """Format error message with location information."""
+        location = f"{self.line}:{self.column}"
+        if self.source_file:
+            location = f"{self.source_file}:{location}"
+        return f"Error at {location}: {self.message}"
+
+
+class LexerError(Pine2PyneError):
+    """Error during lexical analysis (tokenization)."""
+    pass
+
+
+class ParserError(Pine2PyneError):
+    """Error during parsing (syntax error)."""
+    pass
+
+
+class TransformerError(Pine2PyneError):
+    """Error during AST transformation."""
+    pass
+
+
+class CodeGenError(Pine2PyneError):
+    """Error during code generation."""
+    pass
+
+
+class SemanticError(Pine2PyneError):
+    """A program TradingView's compiler refuses, refused at its Pine line and
+    column (card #28). `code` names the rule, e.g. 'history-target'; `more`
+    counts the further refusals in the same script."""
+    def __init__(self, code: str, message: str, line: int = 0, column: int = 0, more: int = 0):
+        suffix = f' (and {more} more refusal{"s" if more != 1 else ""})' if more else ''
+        super().__init__(f'Pine refuses: {message} [{code}]{suffix}', line, column)
+        self.code = code
+
+
+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; 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}]')
+        self.code, self.text, self.line, self.column = code, message, line, column
+
+
+class UnsupportedFeatureError(Pine2PyneError):
+    """Feature not yet supported by the transpiler."""
+    def __init__(self, feature: str, line: int = 0, column: int = 0):
+        message = f"Unsupported feature: {feature}"
+        super().__init__(message, line, column)
+        self.feature = feature

pine2pyne/for_loop_end_bound.py

@@ -0,0 +1,172 @@
+"""A `for` loop whose end may change in its body reads it again before every pass.
+
+MEASURED on TradingView (2026-10-05, `//@version=6`): `n = 10; for i = 0 to n:
+count += 1; n -= 1` runs 6 times and leaves n at 4. The Pine docs (Loops) say the
+direction is fixed when the loop starts and the end is checked on each pass;
+`from` and `by` are evaluated once.
+
+`for i in pine_range(from, to)` reads the end once. PyneComp (v6.0.80, probe
+scripts `tmp/probes/loop5..9`) emits the runtime's `pine_loop` for a loop of any
+Pine version whose end is not provably the same on every pass; its counter is
+named by the loop's block depth in its function, `__loop_<depth>__`:
+
+    __loop_0__ = pine_loop(from, by)      # `by` written out where pine_range writes it
+    while __loop_0__.step(to):
+        i = __loop_0__.value
+
+An end is invariant when it is built from literals, operators, casts, names the
+body does not assign (dotted names excepted: `timeframe.multiplier` is not), history
+reads of those and `array.size(x)` / `matrix.rows(x)` / `matrix.columns(x)` /
+`map.size(x)` of a container whose size the body does not change. Any other call
+(`math.max`, `nz`, `na`, `str.length`, `ta.*`, a user function) makes it dynamic.
+The body changes the size of `x` when it calls a resizing function on it (`push`,
+`pop`, `insert`, `remove`, `shift`, `unshift`, `clear`, `concat`, `slice`, ...) or
+passes it to a user function; `set`, `get`, `sort`, `reverse`, `fill` and `copy`
+do not. Runs after the scope renamer, so a body local that shadows an outer name
+has its own name and does not count as an assignment of the outer one.
+"""
+import dataclasses
+from typing import AbstractSet, Set
+
+from .ast_nodes import (
+    Assignment, BinaryOp, ForInLoop, ForLoop, FuncDecl, FunctionCall, Identifier, IfStatement, IndexAccess, Literal,
+    MethodCall, NaLiteral, Reassignment, Script, SwitchStatement, TernaryOp, TupleDestructure, UnaryOp, VarDecl,
+    VaripDecl, WhileLoop,
+)
+from .ast_walk import walk
+from .scope_renamer import collect_names, fresh_name
+
+COUNTER_STEM = '__loop_{depth}__'
+HELPER_NAME = 'pine_loop'
+#: size functions an invariant end may call on a container the body does not resize
+SIZE_FUNCTIONS = frozenset({'array.size', 'matrix.rows', 'matrix.columns', 'map.size'})
+#: functions and methods that change the size of their first argument (or receiver)
+RESIZING_FUNCTIONS = frozenset({
+    'push', 'pop', 'insert', 'remove', 'shift', 'unshift', 'clear', 'concat', 'slice', 'put',
+    'add_row', 'add_col', 'remove_row', 'remove_col', 'put_all',
+    'row'})  # PyneComp counts `m.row(r)` among them (probes loop10, loop11)
+_BLOCK_STATEMENTS = (ForLoop, ForInLoop, WhileLoop, IfStatement, SwitchStatement)
+
+
+def mark_dynamic_end_bounds(script: Script) -> Script:
+    """A copy of `script` in which every `for` loop whose end may change between
+    passes carries its counter name; `script` itself when it has no such loop."""
+    if not any(isinstance(node, ForLoop) for node in walk(script)):
+        return script
+    used_names = collect_names(script)
+    function_names = {node.name for node in walk(script) if isinstance(node, FuncDecl)}
+    marker = _EndBoundMarker(used_names, function_names)
+    return dataclasses.replace(script, declarations=[marker.mark(item, 0) for item in script.declarations],
+                               body=[marker.mark(item, 0) for item in script.body])
+
+
+class _EndBoundMarker:
+    def __init__(self, used_names: Set[str], function_names: AbstractSet[str]):
+        self.function_names = function_names
+        # a script name `pine_loop` keeps its spelling; the import takes an alias
+        self.helper_name = fresh_name(HELPER_NAME, used_names) if HELPER_NAME in used_names else HELPER_NAME
+
+    def mark(self, node, depth: int):
+        """`node` rebuilt with every dynamic loop in it marked; `depth` is the block depth of
+        `node` in its function (a function's body is depth 0 again)."""
+        if isinstance(node, list):
+            return [self.mark(item, depth) for item in node]
+        if isinstance(node, FuncDecl):
+            body = self.mark(node.body, 0) if isinstance(node.body, list) else node.body
+            return dataclasses.replace(node, body=body)
+        if isinstance(node, IfStatement):
+            return dataclasses.replace(
+                node, body=self.mark(node.body, depth + 1),
+                elseifs=[(condition, self.mark(body, depth + 1)) for condition, body in node.elseifs],
+                else_body=self.mark(node.else_body, depth + 1) if node.else_body is not None else None)
+        if isinstance(node, SwitchStatement):
+            return dataclasses.replace(
+                node, cases=[(case, self.mark(body, depth + 1) if isinstance(body, list) else body)
+                             for case, body in node.cases],
+                default=self.mark(node.default, depth + 1) if isinstance(node.default, list) else node.default)
+        if isinstance(node, (ForInLoop, WhileLoop)):
+            return dataclasses.replace(node, body=self.mark(node.body, depth + 1))
+        if isinstance(node, ForLoop):
+            marks = {}
+            if not self.is_invariant(node.to_val, node.body, _assigned_in(node.body) | {node.var}):
+                marks = {'counter_name': COUNTER_STEM.format(depth=depth), 'counter_helper': self.helper_name}
+            return dataclasses.replace(node, body=self.mark(node.body, depth + 1), **marks)
+        return node
+
+    def is_invariant(self, expression, body, assigned: AbstractSet[str]) -> bool:
+        def invariant(part) -> bool:
+            if part is None or isinstance(part, (Literal, NaLiteral)):
+                return True
+            if isinstance(part, Identifier):
+                return '.' not in part.name and part.name not in assigned
+            if isinstance(part, BinaryOp):
+                return invariant(part.left) and invariant(part.right)
+            if isinstance(part, UnaryOp):
+                return invariant(part.operand)
+            if isinstance(part, TernaryOp):
+                return invariant(part.condition) and invariant(part.true_expr) and invariant(part.false_expr)
+            if isinstance(part, IndexAccess):
+                return invariant(part.object) and invariant(part.index)
+            if isinstance(part, FunctionCall) and isinstance(part.func, str):
+                if part.func in CASTS:
+                    return all(invariant(argument) for argument in part.args)
+                if part.func in SIZE_FUNCTIONS and len(part.args) == 1 and isinstance(part.args[0], Identifier):
+                    return part.args[0].name not in assigned and not self.resizes(body, part.args[0].name)
+                receiver, _, method = part.func.rpartition('.')
+                if (not part.args and method in SIZE_METHODS and receiver and '.' not in receiver
+                        and receiver not in BUILTIN_HEADS):  # `x.size()`
+                    return receiver not in assigned and not self.resizes(body, receiver)
+                return False
+            if isinstance(part, MethodCall) and isinstance(part.object, Identifier) and not part.args \
+                    and part.method in SIZE_METHODS:
+                return part.object.name not in assigned and not self.resizes(body, part.object.name)
+            return False
+        return invariant(expression)
+
+    def resizes(self, body, name: str) -> bool:
+        """Whether `body` may change the size of the container `name`."""
+        def names(arguments) -> bool:
+            return any(isinstance(argument, Identifier) and argument.name == name for argument in arguments)
+        for node in walk(body):
+            if isinstance(node, FunctionCall) and isinstance(node.func, str):
+                head, _, function = node.func.rpartition('.')
+                if function in RESIZING_FUNCTIONS and head in ('array', 'matrix', 'map') and names(node.args[:1]):
+                    return True
+                if function in RESIZING_FUNCTIONS and head == name:  # `x.push(...)`
+                    return True
+                if function in self.function_names and (head == name or names(node.args)):
+                    return True
+                if node.func in self.function_names and names(node.args):
+                    return True
+            elif isinstance(node, MethodCall):
+                if node.method in RESIZING_FUNCTIONS and isinstance(node.object, Identifier) \
+                        and node.object.name == name:
+                    return True
+                if node.method in self.function_names and (names(node.args) or (
+                        isinstance(node.object, Identifier) and node.object.name == name)):
+                    return True
+        return False
+
+
+CASTS = frozenset({'int', 'float', 'bool', 'string', 'color'})
+SIZE_METHODS = frozenset({'size', 'rows', 'columns'})
+BUILTIN_HEADS = frozenset({'array', 'matrix', 'map', 'str', 'math', 'ta', 'request', 'timeframe', 'syminfo',
+                           'strategy', 'line', 'label', 'box', 'table', 'polyline', 'linefill', 'color', 'chart'})
+
+
+def _assigned_in(body) -> Set[str]:
+    """The head of every name a statement in `body` assigns or declares."""
+    names: Set[str] = set()
+    for node in walk(body):
+        if isinstance(node, Assignment):
+            target = node.target
+            names.update(target.names if isinstance(target, TupleDestructure) else [target])
+        elif isinstance(node, Reassignment):
+            names.add(node.target)
+        elif isinstance(node, (VarDecl, VaripDecl)):
+            names.add(node.name)
+        elif isinstance(node, ForLoop):
+            names.add(node.var)
+        elif isinstance(node, ForInLoop):
+            names.update(node.vars)
+    return {name.partition('.')[0] for name in names if isinstance(name, str)}