avrae-ls 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

draconic/interpreter.py

@@ -0,0 +1,1091 @@
+import abc
+import ast
+import contextlib
+from collections.abc import Mapping, Sequence
+from functools import cached_property
+
+from .exceptions import *
+from .helpers import DraconicConfig, OperatorMixin, zip_star
+from .string import check_format_spec
+from .versions import PY_310
+from .types import approx_len_of
+
+__all__ = ("SimpleInterpreter", "DraconicInterpreter")
+
+
+# ===== single-line evaluator, noncompound types, etc =====
+class SimpleInterpreter(OperatorMixin):
+    """A simple interpreter capable of evaluating expressions. No compound types or assignments."""
+
+    def __init__(self, builtins=None, config=None):
+        if config is None:
+            config = DraconicConfig()
+        if builtins is None:
+            builtins = {}
+
+        super().__init__(config)
+
+        if config.builtins_extend_default:
+            builtins = {**config.default_names, **builtins}
+
+        self.builtins = builtins
+
+        self.nodes = {
+            ast.Expr: self._eval_expr,
+            # literals:
+            ast.Num: self._eval_num,
+            ast.Str: self._eval_str,
+            ast.Constant: self._eval_constant,
+            ast.FormattedValue: self._eval_formattedvalue,  # formatted value in f-string
+            ast.JoinedStr: self._eval_joinedstr,  # f-string
+            ast.NameConstant: self._eval_constant,  # True/False/None up to py3.7
+            # names:
+            ast.Name: self._eval_name,
+            # ops:
+            ast.UnaryOp: self._eval_unaryop,
+            ast.BinOp: self._eval_binop,
+            ast.BoolOp: self._eval_boolop,
+            ast.Compare: self._eval_compare,
+            ast.IfExp: self._eval_ifexp,
+            # function call:
+            ast.Call: self._eval_call,
+            ast.keyword: self._eval_keyword,  # foo(x=y), kwargs (not supported)
+            # container[key]:
+            ast.Subscript: self._eval_subscript,
+            ast.Index: self._eval_index,  # deprecated in py3.9 (bpo-34822)
+            ast.Slice: self._eval_slice,  # deprecated in py3.9 (bpo-34822)
+            # container.key:
+            ast.Attribute: self._eval_attribute,
+        }
+
+        self._str = self._config.str
+        self._expr = None  # save the expression for error handling
+
+    def parse(self, expr: str):
+        """
+        Parses an expression.
+
+        :type expr: str
+        :rtype: list[ast.AST]
+        """
+        self._expr = expr
+        try:
+            return ast.parse(expr).body
+        except SyntaxError as e:
+            raise DraconicSyntaxError(e, expr) from e
+
+    def eval(self, expr: str):
+        """
+        Evaluates an expression.
+
+        :type expr: list[ast.AST] or str
+        """
+        expr = self.parse(expr)
+
+        self._preflight()
+        try:
+            expression = expr[0]
+        except IndexError:  # if there is no expression, evaluate to None
+            return None
+        return self._eval(expression)
+
+    def _eval(self, node):
+        """The internal evaluator used on each node in the parsed tree."""
+        try:
+            handler = self.nodes[type(node)]
+        except KeyError:
+            raise FeatureNotAvailable(
+                "Sorry, {0} is not available in this evaluator".format(type(node).__name__), node, self._expr
+            )
+
+        try:
+            return handler(node)
+        except _PostponedRaise as pr:
+            raise pr.cls(*pr.args, **pr.kwargs, node=node, expr=self._expr)
+        except DraconicException:
+            raise
+        except Exception as e:
+            raise AnnotatedException(e, node, self._expr) from e
+
+    def _preflight(self):
+        """Called before starting evaluation."""
+        pass
+
+    @property
+    def names(self):
+        return self.builtins
+
+    @names.setter
+    def names(self, new_names):
+        self.builtins = new_names
+
+    # ===== nodes =====
+    def _eval_expr(self, node):
+        return self._eval(node.value)
+
+    @staticmethod
+    def _eval_num(node):
+        return node.n
+
+    def _eval_str(self, node):
+        if len(node.s) > self._config.max_const_len:
+            raise IterableTooLong(
+                f"String literal in statement is too long ({len(node.s)} > {self._config.max_const_len})",
+                node,
+                self._expr,
+            )
+        return self._str(node.s)
+
+    def _eval_constant(self, node):
+        if hasattr(node.value, "__len__") and len(node.value) > self._config.max_const_len:
+            raise IterableTooLong(
+                f"Literal in statement is too long ({len(node.value)} > {self._config.max_const_len})", node, self._expr
+            )
+        if isinstance(node.value, bytes):
+            raise FeatureNotAvailable("Creation of bytes literals is not allowed", node, self._expr)
+        return node.value
+
+    def _eval_unaryop(self, node):
+        return self.operators[type(node.op)](self._eval(node.operand))
+
+    def _eval_binop(self, node):
+        return self.operators[type(node.op)](self._eval(node.left), self._eval(node.right))
+
+    def _eval_boolop(self, node):
+        vout = False
+        if isinstance(node.op, ast.And):
+            for value in node.values:
+                vout = self._eval(value)
+                if not vout:
+                    return vout
+        elif isinstance(node.op, ast.Or):
+            for value in node.values:
+                vout = self._eval(value)
+                if vout:
+                    return vout
+        return vout
+
+    def _eval_compare(self, node):
+        right = self._eval(node.left)
+        to_return = True
+        for operation, comp in zip(node.ops, node.comparators):
+            if not to_return:
+                break
+            left = right
+            right = self._eval(comp)
+            to_return = self.operators[type(operation)](left, right)
+        return to_return
+
+    def _eval_ifexp(self, node):
+        return self._eval(node.body) if self._eval(node.test) else self._eval(node.orelse)
+
+    def _eval_call(self, node):
+        func = self._eval(node.func)
+        return func(*(self._eval(a) for a in node.args), **dict(self._eval(k) for k in node.keywords))
+
+    def _eval_keyword(self, node):
+        return node.arg, self._eval(node.value)
+
+    def _eval_name(self, node):
+        try:
+            return self.names[node.id]
+        except KeyError:
+            raise NotDefined(f"{node.id} is not defined", node, self._expr)
+
+    def _eval_subscript(self, node):
+        container = self._eval(node.value)
+        key = self._eval(node.slice)
+        try:
+            return container[key]
+        except KeyError:
+            raise
+
+    def _eval_attribute(self, node):
+        for prefix in self._config.disallow_prefixes:
+            if node.attr.startswith(prefix):
+                raise FeatureNotAvailable(f"Access to the {node.attr} attribute is not allowed", node, self._expr)
+        if node.attr in self._config.disallow_methods:
+            raise FeatureNotAvailable(f"Access to the {node.attr} attribute is not allowed", node, self._expr)
+        # eval node
+        node_evaluated = self._eval(node.value)
+
+        # Maybe the base object is an actual object, not just a dict
+        try:
+            return getattr(node_evaluated, node.attr)
+        except (AttributeError, TypeError):
+            # If it is not present, raise an exception
+            raise NotDefined(f"'{type(node_evaluated).__name__}' object has no attribute {node.attr}", node, self._expr)
+
+    def _eval_index(self, node):
+        return self._eval(node.value)
+
+    def _eval_slice(self, node):
+        lower = upper = step = None
+        if node.lower is not None:
+            lower = self._eval(node.lower)
+        if node.upper is not None:
+            upper = self._eval(node.upper)
+        if node.step is not None:
+            step = self._eval(node.step)
+        return slice(lower, upper, step)
+
+    def _eval_joinedstr(self, node):
+        length = 0
+        evaluated_values = []
+        for n in node.values:
+            val = str(self._eval(n))
+            length += len(val)
+            if length > self._config.max_const_len:
+                raise IterableTooLong(
+                    f"f-string in statement is too long ({length} > {self._config.max_const_len})", node, self._expr
+                )
+            evaluated_values.append(val)
+        return "".join(evaluated_values)
+
+    def _eval_formattedvalue(self, node):
+        if node.format_spec:
+            format_spec = str(self._eval(node.format_spec))
+            check_format_spec(self._config, format_spec)
+            return self._str(format(self._eval(node.value), format_spec))
+        return self._eval(node.value)
+
+
+# ===== multiple-line execution, assignment, compound types =====
+class _Break:
+    __slots__ = ("node",)
+
+    def __init__(self, node: ast.Break):
+        self.node = node
+
+
+class _Continue:
+    __slots__ = ("node",)
+
+    def __init__(self, node: ast.Continue):
+        self.node = node
+
+
+class _Return:
+    __slots__ = ("value", "node")
+
+    def __init__(self, retval, node: ast.Return):
+        self.value = retval
+        self.node = node
+
+
+class _Callable(abc.ABC):
+    """ABC for functions and lambdas"""
+
+    def __init__(self, interpreter, node, names_at_def, defining_expr):
+        self._interpreter = interpreter
+        self._node = node
+        self._outer_scope_names = names_at_def
+        self._defining_expr = defining_expr
+
+    # faux introspection props since __dunders__ aren't accessible
+    @property
+    def name(self):
+        return self.__name__
+
+    @cached_property
+    def doc(self):
+        return ast.get_docstring(self._node)
+
+    def __call__(self, *args, **kwargs):
+        raise NotImplementedError
+
+
+class _Function(_Callable):
+    """A wrapper class around an ast.FunctionDef."""
+
+    def __init__(self, interpreter, functiondef, names_at_def, defining_expr):
+        super().__init__(interpreter, functiondef, names_at_def, defining_expr)
+        self.__name__ = self._name = functiondef.name
+
+    def __repr__(self):
+        return f"<Function {self._name}>"
+
+    def __call__(self, *args, **kwargs):
+        try:
+            # noinspection PyProtectedMember
+            return self._interpreter._exec_function(self, *args, **kwargs)
+        except DraconicException as e:
+            e.__drac_context__ = self._name
+            raise
+
+
+class _Lambda(_Callable):
+    """A wrapper class around an ast.Lambda."""
+
+    def __init__(self, interpreter, lambdadef, names_at_def, defining_expr):
+        super().__init__(interpreter, lambdadef, names_at_def, defining_expr)
+        self.__name__ = self._name = "<lambda>"
+
+    def __repr__(self):
+        return f"<Function <lambda>>"
+
+    @property
+    def doc(self):
+        return None
+
+    def __call__(self, *args, **kwargs):
+        try:
+            # noinspection PyProtectedMember
+            return self._interpreter._exec_lambda(self, *args, **kwargs)
+        except DraconicException as e:
+            e.__drac_context__ = self._name
+            raise
+
+
+class DraconicInterpreter(SimpleInterpreter):
+    """The Draconic interpreter. Capable of running Draconic code."""
+
+    def __init__(self, builtins=None, config=None, initial_names=None):
+        super().__init__(builtins, config)
+
+        if initial_names is None:
+            initial_names = {}
+
+        self.nodes.update(
+            {
+                # compound types:
+                ast.Dict: self._eval_dict,
+                ast.Tuple: self._eval_tuple,
+                ast.List: self._eval_list,
+                ast.Set: self._eval_set,
+                # comprehensions:
+                ast.ListComp: self._eval_listcomp,
+                ast.SetComp: self._eval_setcomp,
+                ast.DictComp: self._eval_dictcomp,
+                ast.GeneratorExp: self._eval_generatorexp,
+                ast.Starred: self._eval_starred,  # foo(*iterable), [*iterable], etc.
+                # assignments:
+                ast.Assign: self._eval_assign,
+                ast.AugAssign: self._eval_augassign,
+                ast.NamedExpr: self._eval_namedexpr,
+                # control:
+                ast.Return: self._exec_return,
+                ast.If: self._exec_if,
+                ast.For: self._exec_for,
+                ast.While: self._exec_while,
+                ast.Break: lambda node: _Break(node),
+                ast.Continue: lambda node: _Continue(node),
+                ast.Pass: lambda node: None,
+                # functions:
+                ast.FunctionDef: self._eval_functiondef,
+                ast.Lambda: self._eval_lambda,
+                # try/except:
+                ast.Try: self._exec_try,
+            }
+        )
+
+        self.assign_nodes = {
+            ast.Name: self._assign_name,
+            ast.Tuple: self._assign_unpack,
+            ast.List: self._assign_unpack,
+            ast.Subscript: self._assign_subscript,
+            # no assigning to attributes
+            ast.Starred: self._assign_starred,  # a, *b = [x, y, z]
+        }
+
+        self.patma_nodes = {}
+
+        if PY_310:
+            self.nodes.update(
+                {
+                    ast.Match: self._exec_match,
+                }
+            )
+
+            self.patma_nodes.update(
+                {
+                    ast.MatchValue: self._patma_match_value,
+                    ast.MatchSingleton: self._patma_match_singleton,
+                    ast.MatchSequence: self._patma_match_sequence,
+                    ast.MatchMapping: self._patma_match_mapping,
+                    ast.MatchStar: self._patma_match_star,
+                    # no MatchClass
+                    ast.MatchAs: self._patma_match_as,
+                    ast.MatchOr: self._patma_match_or,
+                }
+            )
+
+        # compound type helpers
+        self._list = self._config.list
+        self._set = self._config.set
+        self._dict = self._config.dict
+
+        self._num_stmts = 0
+        self._loops = 0
+        self._depth = 1
+        self._names = initial_names
+
+    def eval(self, expr: str):
+        retval = super().eval(expr)
+        if isinstance(retval, _Return):
+            return retval.value
+        elif isinstance(retval, (_Break, _Continue)):
+            raise DraconicSyntaxError.from_node(retval.node, msg="Loop control outside loop", expr=self._expr)
+        return retval
+
+    def execute(self, expr: str):
+        """Executes an AST body."""
+        expr = self.parse(expr)
+
+        self._preflight()
+        retval = self._exec(expr)
+        if isinstance(retval, (_Break, _Continue)):
+            raise DraconicSyntaxError.from_node(retval.node, msg="Loop control outside loop", expr=self._expr)
+        if isinstance(retval, _Return):
+            return retval.value
+
+    def execute_module(self, expr: str, module_name="<module>"):
+        """
+        Executes the expression as if it was a module.
+        This is similar to *execute* except:
+        - it doesn't allow bare returns
+        - it doesn't call preflight
+        - it saves the previously running expression
+        - it sets the exception context
+        """
+        old_expr = self._expr
+        try:
+            expr = self.parse(expr)
+            retval = self._exec(expr)
+            if isinstance(retval, (_Break, _Continue)):
+                raise DraconicSyntaxError.from_node(retval.node, msg="Loop control outside loop", expr=self._expr)
+            if isinstance(retval, _Return):
+                raise DraconicSyntaxError.from_node(retval.node, msg="'return' outside function", expr=self._expr)
+        except DraconicException as e:
+            e.__drac_context__ = module_name
+            raise
+        finally:
+            self._expr = old_expr
+
+    def _preflight(self):
+        self._num_stmts = 0
+        self._loops = 0
+        super()._preflight()
+
+    def _eval(self, node):
+        self._num_stmts += 1
+        if self._num_stmts > self._config.max_statements:
+            raise TooManyStatements("You are trying to execute too many statements.", node, self._expr)
+
+        val = super()._eval(node)
+        # ensure that it's always an instance of our safe compound types being returned
+        # note: makes a copy, so the original copy won't be updated
+        # we don't use isinstance because we're looking for very specific classes
+        if type(val) is str:
+            return self._str(val)
+        elif type(val) is list:
+            return self._list(val)
+        elif type(val) is dict:
+            return self._dict(val)
+        elif type(val) is set:
+            return self._set(val)
+        return val
+
+    def _exec(self, body):
+        for expression in body:
+            retval = self._eval(expression)
+            if isinstance(retval, (_Return, _Break, _Continue)):
+                return retval
+
+    @property
+    def names(self):
+        return {**self.builtins, **self._names}
+
+    @names.setter
+    def names(self, new_names):
+        self._names = new_names
+
+    # ===== compound types =====
+    def _eval_dict(self, node):
+        return self._dict(self._starred_keyword_unwrap(zip(node.keys, node.values)))
+
+    def _eval_tuple(self, node):
+        return tuple(self._starred_unwrap(node.elts))
+
+    def _eval_list(self, node):
+        return self._list(self._starred_unwrap(node.elts))
+
+    def _eval_set(self, node):
+        return self._set(self._starred_unwrap(node.elts))
+
+    def _eval_listcomp(self, node):
+        return self._list(self._do_comprehension(node))
+
+    def _eval_setcomp(self, node):
+        return self._set(self._do_comprehension(node))
+
+    def _eval_dictcomp(self, node):
+        return self._dict(self._do_comprehension(node, is_dictcomp=True))
+
+    def _eval_generatorexp(self, node):
+        for item in self._do_comprehension(node):
+            yield item
+
+    def _do_comprehension(self, comprehension_node, is_dictcomp=False):
+        if is_dictcomp:
+
+            def do_value(node):
+                return self._eval(node.key), self._eval(node.value)
+
+        else:
+
+            def do_value(node):
+                return self._eval(node.elt)
+
+        extra_names = {}
+        previous_name_evaller = self.nodes[ast.Name]
+
+        def eval_names_extra(node):
+            """
+            Here we hide our extra scope for within this comprehension
+            """
+            if node.id in extra_names:
+                return extra_names[node.id]
+            return previous_name_evaller(node)
+
+        self.nodes.update({ast.Name: eval_names_extra})
+
+        def recurse_targets(target, value):
+            """
+                Recursively (enter, (into, (nested, name), unpacking)) = \
+                             and, (assign, (values, to), each
+            """
+            if isinstance(target, ast.Name):
+                extra_names[target.id] = value
+            else:
+                for t, v in zip(target.elts, value):
+                    recurse_targets(t, v)
+
+        def do_generator(gi=0, total_len=0):
+            """
+            For each generator, set the names used in the final emitted value/the next generator.
+            Only the final generator (gi = len(comprehension_node.generator)-1) should emit the final values,
+            since only then are all possible necessary values set in extra_names.
+            """
+            generator_node = comprehension_node.generators[gi]
+            for i in self._eval(generator_node.iter):
+                self._loops += 1
+                if self._loops > self._config.max_loops:
+                    raise IterableTooLong("Comprehension generates too many elements", comprehension_node, self._expr)
+
+                # set names
+                recurse_targets(generator_node.target, i)
+
+                if all(self._eval(iff) for iff in generator_node.ifs):
+                    if len(comprehension_node.generators) > gi + 1:
+                        # next generator
+                        yield from do_generator(gi + 1, total_len)  # bubble up emitted values
+                    else:
+                        # emit values
+                        value = do_value(comprehension_node)
+                        total_len += sum(approx_len_of(val) for val in value) if is_dictcomp else approx_len_of(value)
+                        total_len += 1
+                        if total_len > self._config.max_const_len:
+                            raise IterableTooLong("Comprehension generates too much", comprehension_node, self._expr)
+                        yield value
+
+        try:
+            yield from do_generator()
+        finally:
+            self.nodes.update({ast.Name: previous_name_evaller})
+
+    def _eval_starred(self, node):
+        raise DraconicSyntaxError.from_node(node, "can't use starred expression here", self._expr)
+
+    def _starred_unwrap(self, nodes, *, check_len=True):
+        total_len = 0
+
+        for node in nodes:
+            if type(node) is ast.Starred:
+                evalue = self._eval(node.value)
+                try:
+                    for retval in evalue:
+                        self._loops += 1
+                        if self._loops > self._config.max_loops:
+                            raise IterableTooLong("Unwrapping generates too many elements", node, self._expr)
+                        if check_len:
+                            total_len += approx_len_of(retval) + 1
+                            if total_len > self._config.max_const_len:
+                                raise IterableTooLong("Unwrapping generates too much", node, self._expr)
+                        yield retval
+                except TypeError:
+                    raise TypeError(f"Value after * must be iterable, got {type(evalue).__name__}")
+            else:
+                retval = self._eval(node)
+                if check_len:
+                    total_len += approx_len_of(retval) + 1
+                    if total_len > self._config.max_const_len:
+                        raise IterableTooLong("Unwrapping generates too much", node, self._expr)
+                yield retval
+
+    def _starred_keyword_unwrap(self, items, *, check_len=True):
+        total_len = 0
+
+        for key, value in items:
+            evalue = self._eval(value)
+            if key is None:
+                if isinstance(evalue, Mapping):
+                    for retval in evalue.items():
+                        self._loops += 1
+                        if self._loops > self._config.max_loops:
+                            raise IterableTooLong("Unwrapping generates too many elements", value, self._expr)
+                        if check_len:
+                            total_len += sum(approx_len_of(val) for val in retval) + 1
+                            if total_len > self._config.max_const_len:
+                                raise IterableTooLong("Unwrapping generates too much", value, self._expr)
+                        yield retval
+                else:
+                    raise TypeError(f"argument after ** must be a mapping, got {type(value).__name__}")
+            else:
+                retval = self._eval(key) if isinstance(key, ast.AST) else key, evalue
+                if check_len:
+                    total_len += sum(approx_len_of(val) for val in retval) + 1
+                    if total_len > self._config.max_const_len:
+                        raise IterableTooLong("Unwrapping generates too much", value, self._expr)
+                yield retval
+
+    # ===== assignments =====
+    def _eval_assign(self, node):
+        value = self._eval(node.value)
+        for target in node.targets:  # a = b = 1
+            self._assign(target, value)
+
+    def _eval_augassign(self, node):
+        target = node.target
+        # transform a += 1 to a = a + 1, then we can use assign and eval
+        new_value = ast.BinOp(left=target, op=node.op, right=node.value)
+        ast.copy_location(new_value, target)
+        self._assign(target, self._eval_binop(new_value))
+
+    def _eval_namedexpr(self, node):
+        value = self._eval(node.value)
+        self._assign(node.target, value)
+        return value
+
+    # ---- primary assign branch ----
+    def _assign(self, names, values):
+        try:
+            handler = self.assign_nodes[type(names)]
+        except KeyError:
+            raise FeatureNotAvailable(f"Assignment to {type(names).__name__} is not allowed", names, self._expr)
+        # noinspection PyArgumentList
+        return handler(names, values)
+
+    def _assign_name(self, name, value):
+        if name.id in self.builtins:
+            raise DraconicValueError(f"{name.id} is already builtin (no shadow assignments).", name, self._expr)
+        self._names[name.id] = value
+
+    def _assign_subscript(self, name, value):
+        container = self._eval(name.value)
+        key = self._eval(name.slice)
+        container[key] = value  # no further evaluation needed, if container is in names it will update
+
+    def _assign_unpack(self, names, values):
+        if not isinstance(names, (ast.Tuple, ast.List)):
+            self._assign(names, values)
+        else:
+            try:
+                values = list(iter(values))
+            except TypeError:
+                raise DraconicValueError(
+                    f"Cannot unpack non-iterable {type(values).__name__} object", names, self._expr
+                )
+
+            stars = (i for i in names.elts if type(i) is ast.Starred)
+            starred = next(stars, None)
+
+            if starred is None:
+                if len(names.elts) > len(values):
+                    raise DraconicValueError(
+                        f"not enough values to unpack (expected {len(names.elts)}, got {len(values)})",
+                        names,
+                        self._expr,
+                    )
+                elif len(names.elts) < len(values):
+                    raise DraconicValueError(
+                        f"too many values to unpack (expected {len(names.elts)}, got {len(values)})",
+                        names,
+                        self._expr,
+                    )
+                for t, v in zip(names.elts, values):
+                    self._assign_unpack(t, v)
+            elif (extra := next(stars, None)) is not None:
+                raise DraconicSyntaxError.from_node(extra, "multiple starred expressions in assignment", self._expr)
+            else:
+                if len(values) < (len(names.elts) - 1):
+                    raise DraconicValueError(
+                        f"not enough values to unpack (expected at least {len(names.elts) - 1}, got {len(values)})",
+                        names,
+                        self._expr,
+                    )
+
+                for t, v in zip_star(names.elts, values, star_index=names.elts.index(starred)):
+                    self._assign_unpack(t, v)
+
+    def _assign_starred(self, name, value):
+        self._assign_name(name.value, value)
+
+    # ===== execution =====
+    def _exec_return(self, node):
+        retval = self._eval(node.value) if node.value is not None else None
+        return _Return(retval, node)
+
+    def _exec_if(self, node):
+        test = self._eval(node.test)
+        if test:
+            return self._exec(node.body)
+        else:
+            return self._exec(node.orelse)
+
+    def _exec_for(self, node):
+        for item in self._eval(node.iter):
+            self._loops += 1
+            if self._loops > self._config.max_loops:
+                raise TooManyStatements("Too many loops (in for block)", node, self._expr)
+
+            self._assign(node.target, item)
+            retval = self._exec(node.body)
+            if isinstance(retval, _Return):
+                return retval
+            elif isinstance(retval, _Break):
+                break
+            elif isinstance(retval, _Continue):
+                continue
+        else:
+            return self._exec(node.orelse)
+
+    def _exec_while(self, node):
+        while self._eval(node.test):
+            self._loops += 1
+            if self._loops > self._config.max_loops:
+                raise TooManyStatements("Too many loops (in while block)", node, self._expr)
+
+            retval = self._exec(node.body)
+            if isinstance(retval, _Return):
+                return retval
+            elif isinstance(retval, _Break):
+                break
+            elif isinstance(retval, _Continue):
+                continue
+        else:
+            return self._exec(node.orelse)
+
+    # ===== patma =====
+    # impl inspired by GVR's impl at https://github.com/gvanrossum/patma/blob/master/patma.py
+    # note: we do duplicate binding checks at runtime instead of preflight, which means that
+    # some code could run before the duplicate binding is detected, and certain exprs illegal in Python are legal here
+    # this is OK for our use case but differs from Python's impl
+    def _exec_match(self, node):
+        subject = self._eval(node.subject)
+        for match_case in node.cases:
+            if (bindings := self._patma(match_case.pattern, subject)) is not None:
+                self._names.update(bindings)  # In python patma, values are bound before the guard executes
+                if match_case.guard is not None and not self._eval(match_case.guard):
+                    continue
+                return self._exec(match_case.body)
+
+    def _patma(self, pattern, subject):
+        """
+        Execute matching logic for a given match_case and subject.
+        If the subject matches the case, return the dict of bindings for this case.
+        Otherwise, return None.
+        """
+        try:
+            handler = self.patma_nodes[type(pattern)]
+        except KeyError:
+            raise FeatureNotAvailable(f"Matching on {type(pattern).__name__} is not allowed", pattern, self._expr)
+        self._num_stmts += 1
+        return handler(pattern, subject)
+
+    def _patma_match_value(self, node, subject):
+        if subject == self._eval(node.value):
+            return {}
+        return None
+
+    @staticmethod
+    def _patma_match_singleton(node, subject):
+        if subject is node.value:
+            return {}
+        return None
+
+    def _patma_match_sequence(self, node, subject):
+        if not isinstance(subject, Sequence) or isinstance(subject, (str, bytes)):
+            return None
+
+        match_star_idxs = [idx for idx, pattern in enumerate(node.patterns) if isinstance(pattern, ast.MatchStar)]
+        if len(match_star_idxs) > 1:
+            # multiple starred names
+            raise DraconicValueError(f"multiple starred names in sequence pattern", node, self._expr)
+        elif match_star_idxs:
+            # one starred name
+            if not len(node.patterns) <= len(subject) + 1:
+                return None
+            pattern_iterator = zip_star(node.patterns, subject, star_index=match_star_idxs[0])
+        else:
+            # no starred names
+            if len(node.patterns) != len(subject):
+                return None
+            pattern_iterator = zip(node.patterns, subject)
+
+        # do iteration over patterns and values
+        bindings = {}
+        bound_names = set()
+        for pattern, item in pattern_iterator:
+            # recursive check
+            # noinspection DuplicatedCode
+            match = self._patma(pattern, item)
+            if match is None:
+                return None
+
+            # duplicate bindings check
+            if bound_names.intersection(match):
+                raise DraconicValueError(
+                    f"multiple assignment to names {sorted(bound_names.intersection(match))} in sequence pattern",
+                    node,
+                    self._expr,
+                )
+            bindings.update(match)
+            bound_names.update(match)
+
+        return bindings
+
+    def _patma_match_mapping(self, node, subject):
+        if not isinstance(subject, Mapping):
+            return None
+
+        bindings = {}
+        bound_names = set()
+        bound_keys = set()
+        for key, pattern in zip(node.keys, node.patterns):
+            # recursive check
+            key = self._eval(key)
+            try:
+                value = subject[key]
+            except KeyError:
+                return None
+            # noinspection DuplicatedCode
+            match = self._patma(pattern, value)
+            if match is None:
+                return None
+
+            # duplicate bindings check
+            if bound_names.intersection(match):
+                raise DraconicValueError(
+                    f"multiple assignment to names {sorted(bound_names.intersection(match))} in mapping pattern",
+                    node,
+                    self._expr,
+                )
+            bindings.update(match)
+            bound_names.update(match)
+            bound_keys.add(key)
+
+        if node.rest is not None:
+            if node.rest in bound_names:
+                raise DraconicValueError(
+                    f"multiple assignment to name {node.rest!r} in mapping pattern", node, self._expr
+                )
+            bindings[node.rest] = {k: v for k, v in subject.items() if k not in bound_keys}
+
+        return bindings
+
+    @staticmethod
+    def _patma_match_star(node, subject):
+        if node.name is None:
+            return {}
+        return {node.name: subject}
+
+    def _patma_match_as(self, node, subject):
+        if node.name is None:  # this is the wildcard pattern, always matches
+            return {}
+        if node.pattern is None:  # bare name capture pattern, always matches
+            return {node.name: subject}
+        # otherwise if the inner match matches, we just add an additional binding to it
+        inner_match = self._patma(node.pattern, subject)
+        if inner_match is None:
+            return None
+        return {**inner_match, node.name: subject}
+
+    def _patma_match_or(self, node, subject):
+        # since we don't know the subpattern's bindings until it executes, we can't enforce both sides having the
+        # same bindings like in Python
+        for pattern in node.patterns:
+            match = self._patma(pattern, subject)
+            if match is not None:
+                return match
+        return None
+
+    # ===== functions =====
+    # definitions
+    def _eval_functiondef(self, node):
+        if node.name in self.builtins:
+            raise DraconicValueError(f"{node.name} is already builtin (no shadow assignments).", node, self._expr)
+        self._names[node.name] = _Function(self, node, self._names, self._expr)
+
+    def _eval_lambda(self, node):
+        return _Lambda(self, node, self._names, self._expr)
+
+    # executions
+    def _eval_call(self, node):
+        func = self._eval(node.func)
+        args = tuple(self._starred_unwrap(node.args, check_len=False))
+        kwargs = dict(self._starred_keyword_unwrap(((k.arg, k.value) for k in node.keywords), check_len=False))
+        try:
+            return func(*args, **kwargs)
+        except DraconicException as e:
+            raise NestedException(e.msg, node, self._expr, last_exc=e) from e
+
+    # noinspection PyProtectedMember
+    @contextlib.contextmanager
+    def _function_call_context(self, __functiondef, /, *args, **kwargs):
+        # check limits
+        self._depth += 1
+        if self._depth > self._config.max_recursion_depth:
+            _raise_in_context(TooMuchRecursion, "Maximum recursion depth exceeded")
+        # store current names and expression
+        old_names = self._names
+        old_expr = self._expr
+        # bind closure names and contextual expression
+        self._names = __functiondef._outer_scope_names.copy()
+        self._expr = __functiondef._defining_expr
+
+        # yield control to the call
+        try:
+            self._bind_function_args(__functiondef, *args, **kwargs)
+            yield
+        finally:
+            # restore old names and expr
+            self._names = old_names
+            self._expr = old_expr
+            # reduce recursion depth
+            self._depth -= 1
+
+    # noinspection PyProtectedMember
+    def _bind_function_args(self, __functiondef, /, *args, **kwargs):
+        # check and bind args
+        arguments = __functiondef._node.args
+        # check valid pos num
+        if len(args) > (numpos := len(arguments.posonlyargs) + len(arguments.args)) and arguments.vararg is None:
+            raise TypeError(f"{__functiondef._name}() takes {numpos} positional arguments but {len(args)} were given")
+        args_i = 0
+        default_i = len(arguments.defaults) - numpos
+        # posonly
+        for posonly in arguments.posonlyargs:
+            if args_i + 1 > len(args):
+                if default_i < 0:
+                    raise TypeError(f"{__functiondef._name}() missing required positional argument: {posonly.arg!r}")
+                self._names[posonly.arg] = self._eval(arguments.defaults[default_i])
+            else:
+                self._names[posonly.arg] = args[args_i]
+            args_i += 1
+            default_i += 1
+        # normal
+        for posarg in arguments.args:
+            # at least 1
+            if args_i + 1 > len(args) and posarg.arg not in kwargs:
+                if default_i < 0:
+                    raise TypeError(f"{__functiondef._name}() missing required positional argument: {posarg.arg!r}")
+                self._names[posarg.arg] = self._eval(arguments.defaults[default_i])
+            # pos and kw
+            elif args_i + 1 <= len(args) and posarg.arg in kwargs:
+                raise TypeError(f"{__functiondef._name}() got multiple values for argument {posarg.arg!r}")
+            elif posarg.arg in kwargs:
+                self._names[posarg.arg] = kwargs.pop(posarg.arg)
+            else:
+                # we won't indexerror because if it's not in kwargs and args_i is invalid, the first if catches it
+                self._names[posarg.arg] = args[args_i]
+            args_i += 1
+            default_i += 1
+        # kwargonly
+        for k_i, kwargonly in enumerate(arguments.kwonlyargs):
+            if kwargonly.arg not in kwargs and arguments.kw_defaults[k_i] is None:
+                raise TypeError(f"{__functiondef._name}() missing required keyword argument: {kwargonly.arg!r}")
+            if kwargonly.arg in kwargs:
+                self._names[kwargonly.arg] = kwargs.pop(kwargonly.arg)
+            else:
+                self._names[kwargonly.arg] = self._eval(arguments.kw_defaults[k_i])
+        # *args
+        if arguments.vararg is not None:
+            if approx_len_of(args[args_i:]) > self._config.max_const_len:
+                _raise_in_context(IterableTooLong, f"*{arguments.vararg.arg} would be too large")
+            self._names[arguments.vararg.arg] = tuple(args[args_i:])
+        # **kwargs
+        if arguments.kwarg is not None:
+            if approx_len_of(kwargs) > self._config.max_const_len:
+                _raise_in_context(IterableTooLong, f"**{arguments.kwarg.arg} would be too large")
+            self._names[arguments.kwarg.arg] = kwargs
+        elif kwargs:  # and arguments.kwarg is None (implicit)
+            raise TypeError(f"{__functiondef._name}() got unexpected keyword arguments: {tuple(kwargs.keys())}")
+
+    # noinspection PyProtectedMember
+    def _exec_function(self, __functiondef: _Function, /, *args, **kwargs):
+        with self._function_call_context(__functiondef, *args, **kwargs):
+            retval = self._exec(__functiondef._node.body)
+            if isinstance(retval, (_Break, _Continue)):
+                raise DraconicSyntaxError.from_node(retval.node, msg="Loop control outside loop", expr=self._expr)
+            if isinstance(retval, _Return):
+                return retval.value
+
+    # noinspection PyProtectedMember
+    def _exec_lambda(self, __lambdadef: _Lambda, /, *args, **kwargs):
+        with self._function_call_context(__lambdadef, *args, **kwargs):
+            return self._eval(__lambdadef._node.body)
+
+    # ===== try/except =====
+    def _exec_try(self, node: ast.Try):
+        try:
+            retval = self._exec(node.body)
+            if isinstance(retval, (_Return, _Continue, _Break)):
+                return retval
+        except Exception as exc:
+            if isinstance(exc, WrappedException):
+                exc = exc.original
+            # draconic diff: limit errors cannot be caught
+            if isinstance(exc, LimitException):
+                raise
+            # enter into the except handlers
+            for handler in node.handlers:
+                if self._except_handler_matches(handler, exc):
+                    retval = self._except_handler(handler)
+                    if isinstance(retval, (_Return, _Continue, _Break)):
+                        return retval
+                    break
+            else:
+                raise
+        else:
+            retval = self._exec(node.orelse)
+            if isinstance(retval, (_Return, _Continue, _Break)):
+                return retval
+        finally:
+            retval = self._exec(node.finalbody)
+            if isinstance(retval, (_Return, _Continue, _Break)):
+                return retval
+
+    def _except_handler_matches(self, node: ast.ExceptHandler, exc: BaseException) -> bool:
+        # draconic diff: exception handlers must be string literals, tuple[str] literals, or bare
+        if node.type is None:
+            return True
+        if isinstance(node.type, ast.Str):
+            return type(exc).__name__ == self._eval_str(node.type)
+        elif isinstance(node.type, ast.Tuple):
+            if not all(isinstance(item, ast.Str) for item in node.type.elts):
+                raise FeatureNotAvailable(
+                    "'except' clause expressions must be string literals or tuple of string literals", node, self._expr
+                )
+            return type(exc).__name__ in self._eval_tuple(node.type)
+        else:
+            raise FeatureNotAvailable(
+                "'except' clause expressions must be string literals or tuple of string literals", node, self._expr
+            )
+
+    def _except_handler(self, node: ast.ExceptHandler):
+        # draconic diff: 'as X' clause not allowed
+        if node.name is not None:
+            raise FeatureNotAvailable("'except ... as X' is not available in this interpreter", node, self._expr)
+        # run body
+        return self._exec(node.body)