pine2pyne 0.2.4__py3-none-any.whl

pine2pyne/bool_builtins.py

@@ -0,0 +1,42 @@
+"""
+The pynecore.lib builtins whose value is of type bool, and the scalar type of
+each builtin series, as the runtime annotates them.
+
+GENERATED by tools/collect_bool_builtins.py from opencode-pyneruntime 6.9.4; do not
+edit by hand. In Pine v6 an untaken if/switch whose value is of type bool is
+false, not na; bool_value_typing reads these to type a builtin (card #56).
+"""
+from typing import Dict, FrozenSet
+
+BOOL_BUILTINS: FrozenSet[str] = frozenset({
+    'array.every', 'array.includes', 'array.some', 'barstate.isconfirmed',
+    'barstate.isfirst', 'barstate.ishistory', 'barstate.islast',
+    'barstate.islastconfirmedhistory', 'barstate.isnew', 'barstate.isrealtime',
+    'chart.is_heikinashi', 'chart.is_kagi', 'chart.is_linebreak', 'chart.is_pnf',
+    'chart.is_range', 'chart.is_renko', 'chart.is_standard', 'map.contains',
+    'matrix.is_antidiagonal', 'matrix.is_antisymmetric', 'matrix.is_binary',
+    'matrix.is_diagonal', 'matrix.is_identity', 'matrix.is_square', 'matrix.is_stochastic',
+    'matrix.is_symmetric', 'matrix.is_triangular', 'matrix.is_zero', 'na',
+    'session.isfirstbar', 'session.isfirstbar_regular', 'session.islastbar',
+    'session.islastbar_regular', 'session.ismarket', 'session.ispostmarket',
+    'session.ispremarket', 'str.contains', 'str.endswith', 'str.startswith', 'ta.cross',
+    'ta.crossover', 'ta.crossunder', 'ta.falling', 'ta.rising', 'timeframe.change',
+    'timeframe.isdaily', 'timeframe.isdwm', 'timeframe.isintraday', 'timeframe.isminutes',
+    'timeframe.ismonthly', 'timeframe.isseconds', 'timeframe.isticks', 'timeframe.isweekly',
+})
+
+BUILTIN_SERIES_TYPES: Dict[str, str] = {
+    'ask': 'float',
+    'bar_index': 'int',
+    'bid': 'float',
+    'close': 'float',
+    'high': 'float',
+    'hl2': 'float',
+    'hlc3': 'float',
+    'hlcc4': 'float',
+    'last_bar_index': 'int',
+    'low': 'float',
+    'ohlc4': 'float',
+    'open': 'float',
+    'volume': 'float',
+}

pine2pyne/bool_value_typing.py

@@ -0,0 +1,580 @@
+"""
+Pine v6 bool typing of the values an untaken arm can default (card #56).
+
+In Pine v6 an if/switch whose value is of TYPE bool gives false for an arm
+that does not run, not na (migration guide to v6). The type comes from the
+tail's syntax, a declared or inferred name, a builtin, a UDT field, the
+element of an `array<bool>`, or a user function's own tail. This pass decides
+it once, on the renamed script and before the block-value lowering rewrites it, and
+stamps `value_is_bool` on each if/switch expression, loop and function whose
+value is bool. Every later emit site (the block-value pre-pass, the ternary
+emitter, the function-tail return) reads the stamp. Unknown is not bool: it
+stays na.
+
+One walk records the scope of every value (Pine's scopes, as the overload
+resolution builds them: `rename_shadowing_locals` runs first). Each question
+("is this value, function or binding bool?") is then a formula over other
+questions, built once. The formulas are solved together as a least fixpoint,
+so a chain of untyped names of any length is followed without recursion and
+without a bound, and a cycle (recursion is not valid Pine) is not bool.
+An if/switch/loop in the tail of another value or of a function has the
+same type as it: Pine gives one if/switch one type.
+"""
+import dataclasses
+from typing import Dict, List, Optional, Tuple
+
+from .ast_nodes import (
+    Assignment, BinaryOp, ExpressionStatement, ForInLoop, ForLoop, FuncDecl, FunctionCall, Identifier,
+    IfExpression, IfStatement, IndexAccess, InputDecl, Literal, MemberAccess, NaLiteral, Reassignment,
+    Script, SwitchExpression, SwitchStatement, TernaryOp, TupleDestructure, TypeDecl, UnaryOp, VarDecl,
+    VaripDecl,
+)
+from .ast_walk import CONTAINER_TYPES, LEAF_TYPES, child_field_names, map_children
+from .block_value_lowering import BOOL_OPERATORS, LOOPS
+from .bool_builtins import BOOL_BUILTINS, BUILTIN_SERIES_TYPES
+from .namespace_members import NAMESPACE_MEMBERS
+from .overload_resolution import (
+    Binding, BlockScope, DeclaredTypeResolver, bind_declaration, nested_blocks, overloads_taking,
+)
+from .type_inference import receiver_path
+
+VALUE_NODES = (IfExpression, SwitchExpression) + LOOPS
+BLOCK_STATEMENTS = (FuncDecl, IfStatement, SwitchStatement) + LOOPS
+BINDINGS = (Assignment, VarDecl, VaripDecl, Reassignment)
+# A Pine cast and an input of type bool; pynecore does not annotate them
+BOOL_CONSTRUCTS = frozenset({'bool', 'input.bool'})
+# The Pine namespace of each builtin receiver kind: `a.includes(1)` is `array.includes`
+RECEIVER_NAMESPACES = {'array': 'array', 'map': 'map', 'matrix': 'matrix', 'string': 'str'}
+# The array methods that return an element: bool on an `array<bool>`
+ARRAY_ELEMENT_METHODS = frozenset({'get', 'first', 'last', 'pop'})
+
+# A formula is True, False, ('ref', key), ('any', items) or ('all', items); a key
+# is ('value' | 'function' | 'binding', id of the node or binding)
+Key = Tuple[str, int]
+
+
+def stamp_bool_values(script: Script) -> Script:
+    """A copy of `script` with `value_is_bool=True` on every bool-valued
+    if/switch expression, loop and function; `script` itself when none is."""
+    typing = _BoolTyping(script)
+    stamped = {node_id for kind, node_id in typing.bool_keys() if kind != 'binding'}
+    if not stamped:
+        return script
+    return _Restamp(stamped, typing.ancestors_of(stamped)).rebuilt(script)
+
+
+def reads_na_of_bool(script: Script) -> bool:
+    """Whether a named bool value is read where it may be na: with history (`b[1]`) or
+    through `na(b)`. Pine v5 marks only such a script `na_bool=True`; the history of an
+    expression (`(a > b)[1]`) or of an untyped parameter does not count. Measured with
+    probe scripts compiled by PyneComp v6.0.80; 82 of the 327 v5 scripts of the reference."""
+    typing = _BoolTyping(script)
+    for name, scope in typing.na_calls:
+        binding = scope.lookup(name)
+        if binding is not None and _is_bool_collection(binding.declared_type):
+            return True  # `na(a)` of an `array<bool>`, not its history: any Pine version (probes nb6_02, nb7_*)
+    if _reads_na_of_a_bool_collection_argument(script):
+        return True
+    if _declared_version(script) != 5:
+        return False
+    formulas = [typing._name(name, scope) for name, scope in typing.na_reads]
+    if any(formula is True for formula in formulas):
+        return True
+    references = [reference for formula in formulas for reference in _refs(formula)]
+    if not references:
+        return False
+    true_keys = typing.bool_keys(tuple(references))
+    return any(_holds(formula, true_keys) for formula in formulas)
+
+
+def _is_bool_collection(declared_type) -> bool:
+    """`array<bool>`, `matrix<bool>`, `map<K, bool>` (or `bool[]`)."""
+    if not isinstance(declared_type, str):
+        return False
+    compact = declared_type.replace(' ', '')
+    return compact in ('array<bool>', 'matrix<bool>', 'bool[]') or (compact.startswith('map<')
+                                                                    and compact.endswith(',bool>'))
+
+
+def _reads_na_of_a_bool_collection_argument(script: Script) -> bool:
+    """`is_empty(arr) => na(arr) or ...` called with an `array<bool>`: the untyped parameter is a bool
+    collection where it is called with one (probe bis_isEmpty, PyneComp v6.0.80)."""
+    from .ast_walk import walk
+    from .ast_nodes import MethodCall, Parameter
+    nodes = list(walk(script))
+    collections = {node.name for node in nodes if isinstance(node, Parameter) and _is_bool_collection(node.type_hint)}
+    collections |= {getattr(node, 'name', None) or node.target for node in nodes
+                    if isinstance(node, (VarDecl, VaripDecl, Assignment))
+                    and _is_bool_collection(getattr(node, 'type_hint', None))
+                    and isinstance(getattr(node, 'name', None) or node.target, str)}
+    if not collections:
+        return False
+    functions = {node.name: node for node in nodes if isinstance(node, FuncDecl)}
+    flagged = set()
+    for node in nodes:
+        if isinstance(node, FunctionCall) and isinstance(node.func, str) and node.func in functions:
+            for position, argument in enumerate(node.args):
+                parameters = functions[node.func].params
+                if isinstance(argument, Identifier) and argument.name in collections and position < len(parameters) \
+                        and not parameters[position].type_hint:
+                    flagged.add((node.func, parameters[position].name))
+    for function_name, parameter in flagged:
+        for node in walk(functions[function_name].body):
+            if isinstance(node, FunctionCall) and (isinstance(node.func, NaLiteral) or node.func == 'na') \
+                    and node.args and isinstance(node.args[0], Identifier) and node.args[0].name == parameter:
+                return True
+    return False
+
+
+def _declared_version(script: Script) -> int:
+    text = getattr(script.version, 'version', '') if script.version else ''
+    return int(text) if str(text).isdigit() else 6
+
+
+def has_untaken_bool_switch(script: Script) -> bool:
+    """Whether a `switch` without a default arm gives a bool: an untaken switch is na, so a Pine v5
+    script that has one is `na_bool=True` (probes nb3_02..04, PyneComp v6.0.80). A switch used as
+    a value or as a statement whose arms end with a bool (`x := true`) counts; an `if` does not."""
+    switches = [node for node in walk_nodes(script)
+                if isinstance(node, (SwitchStatement, SwitchExpression)) and node.default is None and node.cases]
+    if not switches:
+        return False
+    typing = _BoolTyping(script)
+    for switch in switches:
+        scope = typing.scope_of.get(id(switch))
+        for _, arm in switch.cases:
+            arm_scope = typing.block_scopes.get(id(arm), scope) if isinstance(arm, list) else scope
+            if arm_scope is None:
+                continue
+            tail = arm[-1] if isinstance(arm, list) and arm else arm
+            formula = typing._tail(tail, arm_scope, ('value', id(switch))) if isinstance(arm, list) \
+                else typing._expression(arm, arm_scope)
+            if formula is True or (formula and _holds(formula, typing.bool_keys(tuple(_refs(formula))))):
+                return True
+    return False
+
+
+def walk_nodes(tree):
+    from .ast_walk import walk
+    return walk(tree)
+
+
+def _any(items) -> object:
+    items = tuple(item for item in items if item is not False)
+    if True in items:
+        return True
+    return (items[0] if len(items) == 1 else ('any', items)) if items else False
+
+
+def _all(items) -> object:
+    items = tuple(item for item in items if item is not True)
+    if False in items:
+        return False
+    return (items[0] if len(items) == 1 else ('all', items)) if items else True
+
+
+def _refs(formula) -> list:
+    if formula is True or formula is False:
+        return []
+    if formula[0] == 'ref':
+        return [formula[1]]
+    return [key for item in formula[1] for key in _refs(item)]
+
+
+def _holds(formula, true_keys: set) -> bool:
+    if formula is True or formula is False:
+        return formula
+    kind, content = formula
+    if kind == 'ref':
+        return content in true_keys
+    combine = any if kind == 'any' else all
+    return combine(_holds(item, true_keys) for item in content)
+
+
+def _statement_arms(statement) -> list:
+    """The bodies whose tails give a tail if/switch statement its value."""
+    if isinstance(statement, IfStatement):
+        return [statement.body] + [body for _, body in statement.elseifs] + [statement.else_body]
+    return [body for _, body in statement.cases] + [statement.default]
+
+
+def _value_arms(value) -> list:
+    if isinstance(value, IfExpression):
+        return [value.true_expr, value.false_expr]
+    if isinstance(value, SwitchExpression):
+        return [body for _, body in value.cases] + [value.default]
+    return [value.body]
+
+
+def _statement_headers(statement) -> list:
+    """The expressions of a block statement that run in the enclosing scope."""
+    if isinstance(statement, FuncDecl):
+        return list(statement.params)
+    if isinstance(statement, IfStatement):
+        return [statement.condition] + [condition for condition, _ in statement.elseifs]
+    if isinstance(statement, SwitchStatement):
+        return [statement.expr] + [case for case, _ in statement.cases]
+    if isinstance(statement, ForLoop):
+        return [statement.from_val, statement.to_val, statement.step]
+    if isinstance(statement, ForInLoop):
+        return [statement.iterable]
+    return [statement.condition]
+
+
+def _declared_container(type_name: Optional[str]):
+    """(kind, element is bool) for a declared builtin container or string type."""
+    if type_name == 'string':
+        return 'string', False
+    kind, bracket, element = (type_name or '').partition('<')
+    if bracket and kind in ('array', 'map', 'matrix'):
+        return kind, kind == 'array' and element.rstrip('>').strip() == 'bool'
+    return None
+
+
+class _BoolTyping:
+    """The scopes of one script and the bool answer of each of its values."""
+
+    def __init__(self, script: Script):
+        self.functions: Dict[str, List[FuncDecl]] = {}
+        self.nodes: Dict[int, object] = {}               # id -> value node, function or binding
+        self.scope_of: Dict[int, BlockScope] = {}         # id(value node) -> the scope it is in
+        self.block_scopes: Dict[int, BlockScope] = {}     # id(block list) -> its scope
+        self.function_scopes: Dict[int, BlockScope] = {}  # id(function) -> its body's scope
+        self.contexts: Dict[int, list] = {}               # id(value node) -> what its target says
+        self.tuple_elements: Dict[int, tuple] = {}        # id(binding) -> (binding, destructured value, position)
+        self.implied_by: Dict[Key, List[Key]] = {}        # a tail value -> the values it is the tail of
+        self.parents: Dict[int, list] = {}
+        self.na_reads: List[tuple] = []                   # (name, scope): `x[n]` and `na(x)` of a named value
+        self.na_calls: List[tuple] = []                   # (name, scope): `na(x)` only
+        udt_field_types = {declaration.name: {name: field_type for name, field_type, *_ in declaration.fields}
+                           for declaration in script.declarations if isinstance(declaration, TypeDecl)}
+        self.resolver = DeclaredTypeResolver(lambda node: None, udt_field_types)
+        self._walk(script)
+
+    # ------------------------------------------------------------ the walk
+    def _walk(self, script: Script) -> None:
+        """Visit every node once, giving each the scope it is in. Every file is
+        walked, so the loop makes no call per plain node (card #56 cost gate)."""
+        pending = [(script, BlockScope(), None)]
+        fields_by_type: Dict[type, tuple] = {}
+        while pending:
+            value, scope, parent = pending.pop()
+            value_type = type(value)
+            if value_type in CONTAINER_TYPES or value_type is dict:
+                items = value.values() if value_type is dict else value
+                pending.extend([(item, scope, parent) for item in items if type(item) not in LEAF_TYPES])
+                continue
+            fields = fields_by_type.get(value_type)
+            if fields is None:
+                is_node_type = hasattr(value_type, '__dataclass_fields__')
+                fields = fields_by_type[value_type] = child_field_names(value_type) if is_node_type else False
+            if fields is False:
+                continue
+            self.parents.setdefault(id(value), []).append(parent)
+            if isinstance(value, BLOCK_STATEMENTS + (IfExpression, SwitchExpression)):
+                self._enter_block(value, scope, pending)
+                continue
+            if isinstance(value, BINDINGS + (InputDecl,)):
+                self._bind(value, scope)
+            elif value_type is IndexAccess or value_type is FunctionCall:
+                self._record_na_read(value, scope)
+            pending.extend([(child, scope, value) for child in [getattr(value, name) for name in fields]
+                            if type(child) not in LEAF_TYPES])
+
+    def _enter_block(self, value, scope: BlockScope, pending: list) -> None:
+        """A function, if, switch or loop: its value and the scopes of its blocks."""
+        if not isinstance(value, (IfStatement, SwitchStatement)):
+            self.nodes[id(value)] = value
+            self.scope_of[id(value)] = scope
+        if isinstance(value, BLOCK_STATEMENTS):
+            self._enter_block_statement(value, scope, pending)
+        else:
+            self._enter_value_expression(value, scope, pending)
+
+    def _enter_block_statement(self, statement, scope: BlockScope, pending: list) -> None:
+        blocks = nested_blocks(statement, scope)
+        for body, block_scope in blocks:
+            self.block_scopes[id(body)] = block_scope
+            pending.append((body, block_scope, statement))
+        if isinstance(statement, FuncDecl):
+            self.functions.setdefault(statement.name, []).append(statement)
+            self.function_scopes[id(statement)] = blocks[0][1]
+        pending.extend((header, scope, statement) for header in _statement_headers(statement) if header is not None)
+
+    def _enter_value_expression(self, value, scope: BlockScope, pending: list) -> None:
+        """An arm that is a block is a Pine local scope; any other child is in `scope`."""
+        headers = [value.condition] if isinstance(value, IfExpression) else (
+            [value.expr] + [case for case, _ in value.cases])
+        pending.extend((header, scope, value) for header in headers if header is not None)
+        for arm in _value_arms(value):
+            arm_scope = scope
+            if isinstance(arm, list):
+                arm_scope = self.block_scopes[id(arm)] = BlockScope(scope)
+            if arm is not None:
+                pending.append((arm, arm_scope, value))
+
+    def _bind(self, statement, scope: BlockScope) -> None:
+        if isinstance(statement, Reassignment):
+            if isinstance(statement.value, VALUE_NODES):
+                self.contexts.setdefault(id(statement.value), []).append((statement.target, scope))
+            return
+        if isinstance(statement, Assignment) and isinstance(statement.target, TupleDestructure):
+            for position, name in enumerate(statement.target.names):
+                element = Binding(None, None, scope)
+                self.tuple_elements[id(element)] = (element, statement.value, position)
+                scope.bind(name, element)
+            return
+        if isinstance(statement, InputDecl) and statement.func == 'input.bool':
+            scope.bind(statement.name, Binding('bool', None, scope))
+            return
+        bind_declaration(statement, scope)
+        if getattr(statement, 'type_hint', None) == 'bool' and isinstance(statement.value, VALUE_NODES):
+            self.contexts.setdefault(id(statement.value), []).append(True)
+
+    def _record_na_read(self, value, scope: BlockScope) -> None:
+        """`x[n]` or `na(x)` of a name: where a v5 bool may be na."""
+        if isinstance(value, IndexAccess):
+            target = value.object
+        elif (isinstance(value.func, NaLiteral) or value.func == 'na') and len(value.args) == 1:
+            target = value.args[0]
+        else:
+            return
+        if isinstance(target, Identifier) and '.' not in target.name:
+            self.na_reads.append((target.name, scope))
+            if not isinstance(value, IndexAccess):
+                self.na_calls.append((target.name, scope))  # `na(x)` itself
+
+    # ------------------------------------------------------------ solving
+    def bool_keys(self, extra_roots: tuple = ()) -> set:
+        """The keys whose answer is bool: the least fixpoint of their formulas."""
+        roots = [('function' if isinstance(node, FuncDecl) else 'value', node_id)
+                 for node_id, node in list(self.nodes.items()) if not isinstance(node, Binding)]
+        formulas, dependents = self._formulas(roots + list(extra_roots))
+        for key, owners in self.implied_by.items():
+            for owner in owners:
+                dependents.setdefault(owner, []).append(key)
+        true_keys: set = set()
+        queue = list(formulas)
+        while queue:
+            key = queue.pop()
+            if key in true_keys:
+                continue
+            if any(owner in true_keys for owner in self.implied_by.get(key, ())) or _holds(formulas[key], true_keys):
+                true_keys.add(key)
+                queue.extend(dependents.get(key, ()))
+        return true_keys
+
+    def _formulas(self, roots: list) -> tuple:
+        formulas: Dict[Key, object] = {}
+        dependents: Dict[Key, List[Key]] = {}
+        pending = list(roots)
+        while pending:
+            key = pending.pop()
+            if key in formulas:
+                continue
+            formula = formulas[key] = self._formula_of(key)
+            for reference in _refs(formula):
+                dependents.setdefault(reference, []).append(key)
+                if reference not in formulas:
+                    pending.append(reference)
+        return formulas, dependents
+
+    def _formula_of(self, key: Key):
+        kind, node_id = key
+        node = self.nodes[node_id]
+        if kind == 'binding':
+            return self._binding_formula(node)
+        if kind == 'function':
+            scope = self.function_scopes[node_id]
+            if isinstance(node.body, list):
+                return self._tail(node.body[-1], scope, key) if node.body else False
+            return self._tail_value(node.body, scope, key)
+        scope = self.scope_of[node_id]
+        contexts = [context if context is True else self._name(*context)
+                    for context in self.contexts.get(node_id, ())]
+        return _any(contexts + [self._arm(arm, scope, key) for arm in _value_arms(node)])
+
+    # ------------------------------------------------------------ formulas
+    def _arm(self, arm, scope: BlockScope, owner: Key):
+        if not arm:
+            return False
+        if isinstance(arm, list):
+            return self._tail(arm[-1], self.block_scopes.get(id(arm), scope), owner)
+        return self._tail_value(arm, scope, owner)
+
+    def _tail(self, tail, scope: BlockScope, owner: Key):
+        """The formula of the last statement of a block, whose value is the block's."""
+        if isinstance(tail, ExpressionStatement):
+            return self._tail_value(tail.expr, scope, owner)
+        if isinstance(tail, (IfStatement, SwitchStatement)):
+            return _any(self._arm(arm, scope, owner) for arm in _statement_arms(tail))
+        if isinstance(tail, BINDINGS):
+            target = tail.name if isinstance(tail, (VarDecl, VaripDecl)) else tail.target
+            return self._name(target, scope) if isinstance(target, str) else False
+        return self._tail_value(tail, scope, owner)
+
+    def _tail_value(self, value, scope: BlockScope, owner: Key):
+        """A value in the tail of `owner` has its type: one if/switch has one type."""
+        if isinstance(value, VALUE_NODES):
+            key = ('value', id(value))
+            self.implied_by.setdefault(key, []).append(owner)
+            return ('ref', key)
+        return self._expression(value, scope)
+
+    def _expression(self, value, scope: BlockScope):
+        if isinstance(value, Literal):
+            return value.literal_type == 'bool'
+        if isinstance(value, BinaryOp):
+            return value.op in BOOL_OPERATORS
+        if isinstance(value, UnaryOp):
+            return value.op == 'not'
+        if isinstance(value, TernaryOp):
+            return _all((self._expression(value.true_expr, scope), self._expression(value.false_expr, scope)))
+        if isinstance(value, VALUE_NODES):
+            return ('ref', ('value', id(value)))
+        if isinstance(value, IndexAccess):
+            return self._expression(value.object, scope)
+        if isinstance(value, FunctionCall):
+            return self._call(value, scope)
+        if isinstance(value, Identifier) and '.' not in value.name:
+            return self._name(value.name, scope)
+        if isinstance(value, (Identifier, MemberAccess)):
+            path = receiver_path(value)
+            return ((path is not None and '.'.join(path) in BOOL_BUILTINS)
+                    or self.resolver.field_type_in_scope(value, scope) == 'bool')
+        return False
+
+    def _name(self, name: str, scope: BlockScope):
+        if name in ('true', 'false'):
+            return True
+        binding = scope.lookup(name)
+        if binding is None:
+            return False
+        if binding.initialiser is None and id(binding) not in self.tuple_elements:
+            return binding.declared_type == 'bool'
+        self.nodes[id(binding)] = binding
+        return ('ref', ('binding', id(binding)))
+
+    def _binding_formula(self, binding: Binding):
+        if id(binding) in self.tuple_elements:
+            _, value, position = self.tuple_elements[id(binding)]
+            return self._tuple_element(value, position)
+        return self._expression(binding.initialiser, binding.scope)
+
+    def _tuple_element(self, value, position: int):
+        """`[p, q] = f()`: p is bool when every f's tail tuple has a bool at p."""
+        if not (isinstance(value, FunctionCall) and isinstance(value.func, str) and value.func in self.functions):
+            return False
+        return _all(self._tail_element(function, position) for function in self.functions[value.func])
+
+    def _tail_element(self, function: FuncDecl, position: int):
+        body = function.body
+        tail = body[-1].expr if isinstance(body, list) and body and isinstance(body[-1], ExpressionStatement) else body
+        elements = getattr(tail, 'elements', None)
+        if not elements or position >= len(elements):
+            return False
+        return self._expression(elements[position], self.function_scopes[id(function)])
+
+    # ------------------------------------------------------------ calls
+    def _call(self, call: FunctionCall, scope: BlockScope):
+        name = 'na' if isinstance(call.func, NaLiteral) else call.func
+        if not isinstance(name, str):
+            return False
+        if name in self.functions:
+            return self._user_call(self.functions[name], call.args, scope)
+        if name in BOOL_BUILTINS or name in BOOL_CONSTRUCTS:
+            return True
+        receiver, dot, method = name.rpartition('.')
+        if not dot:
+            return False
+        if receiver in NAMESPACE_MEMBERS or receiver in RECEIVER_NAMESPACES.values():
+            # `array.get(a, 0)`: the function form of a method on its first argument
+            is_element_access = receiver == 'array' and method in ARRAY_ELEMENT_METHODS and call.args
+            return self._method_on(self._container(call.args[0], scope), method) if is_element_access else False
+        methods = [function for function in self.functions.get(method, ()) if function.is_method]
+        if methods:
+            return self._user_call(methods, [Identifier(name=receiver)] + list(call.args), scope)
+        return self._method_on(self._container(Identifier(name=receiver), scope), method)
+
+    def _user_call(self, declarations: list, arguments: list, scope: BlockScope):
+        if len(declarations) > 1:
+            declarations = overloads_taking(declarations, [self._argument_type(argument, scope)
+                                                           for argument in arguments])
+        return _all(('ref', ('function', id(function))) for function in declarations) if declarations else False
+
+    def _argument_type(self, argument, scope: BlockScope) -> Optional[str]:
+        if isinstance(argument, Identifier) and scope.lookup(argument.name) is None:
+            return BUILTIN_SERIES_TYPES.get(argument.name)
+        return self.resolver.scalar_type(argument, scope)
+
+    @staticmethod
+    def _method_on(container, method: str):
+        """A method of a known builtin receiver: bool by its builtin, or an `array<bool>` element."""
+        if container is None:
+            return False
+        kind, element_is_bool = container
+        if f'{RECEIVER_NAMESPACES[kind]}.{method}' in BOOL_BUILTINS:
+            return True
+        return element_is_bool if kind == 'array' and method in ARRAY_ELEMENT_METHODS else False
+
+    def _container(self, expression, scope: BlockScope):
+        """(kind, element formula) when `expression` is a builtin array, map,
+        matrix or string: declared, constructed, or bound to one; else None."""
+        followed = set()
+        while True:
+            if isinstance(expression, Literal):
+                return ('string', False) if expression.literal_type == 'string' else None
+            if isinstance(expression, FunctionCall):
+                return self._constructed_container(expression, scope)
+            if isinstance(expression, Identifier) and '.' not in expression.name:
+                binding = scope.lookup(expression.name)
+                if binding is None or id(binding) in followed:
+                    return None
+                if binding.initialiser is None:
+                    return _declared_container(binding.declared_type)
+                followed.add(id(binding))
+                expression, scope = binding.initialiser, binding.scope
+                continue
+            if isinstance(expression, (Identifier, MemberAccess)):
+                return _declared_container(self.resolver.field_type_in_scope(expression, scope))
+            return None
+
+    def _constructed_container(self, call: FunctionCall, scope: BlockScope):
+        func = call.func if isinstance(call.func, str) else ''
+        if func == 'array.from':
+            return 'array', (_all(self._expression(argument, scope) for argument in call.args)
+                             if call.args else False)
+        if func.startswith('array.new'):
+            return 'array', func in ('array.new_bool', 'array.new<bool>')
+        kind = func.partition('.new')[0] if '.new' in func else None
+        return (kind, False) if kind in ('map', 'matrix') else None
+
+    # ------------------------------------------------------------ restamping
+    def ancestors_of(self, node_ids: set) -> set:
+        """The ids of every node above one of `node_ids`."""
+        ancestors: set = set()
+        pending = list(node_ids)
+        while pending:
+            for parent in self.parents.get(pending.pop(), ()):
+                if parent is not None and id(parent) not in ancestors:
+                    ancestors.add(id(parent))
+                    pending.append(id(parent))
+        return ancestors
+
+
+@dataclasses.dataclass(frozen=True)
+class _Restamp:
+    """Copies only the nodes on the way to a stamped one; the rest is shared."""
+    stamped: set
+    ancestors: set
+
+    def rebuilt(self, node):
+        node_id = id(node)
+        if node_id not in self.ancestors and node_id not in self.stamped:
+            return node
+        changes = {}
+        if node_id in self.ancestors:
+            changes = {name: map_children(getattr(node, name), self.rebuilt) for name in child_field_names(type(node))}
+        if node_id in self.stamped:
+            changes['value_is_bool'] = True
+        return dataclasses.replace(node, **changes)