Function compile_try_expression

hy/core/result_macros.py:1464–1567

(compiler, expr, root, body, catchers, orelse, finalbody)

    ],
)
def compile_try_expression(compiler, expr, root, body, catchers, orelse, finalbody):
    if orelse is not None and not catchers:
        # Python forbids `else` when there are no `except` clauses.
        # But we can get the same effect by appending the `else` forms
        # to the body.
        body += list(orelse)
        orelse = None
    body = compiler._compile_branch(body)
    if not (catchers or finalbody):
        # Python forbids this, so just return the body, per `do`.
        return body

    return_var = asty.Name(expr, id=mangle(compiler.get_anon_var()), ctx=ast.Store())

    handler_results = Result()
    handlers = []
    except_syms_seen = set()
    for catcher in catchers:
        # exceptions catch should be either:
        # [[list of exceptions]]
        # or
        # [variable [list of exceptions]]
        # or
        # [variable exception]
        # or
        # [exception]
        # or
        # []
        except_sym, exceptions, ebody = catcher
        if not PY3_11 and except_sym == Symbol("except*"):
            compiler._syntax_error(except_sym, "`{}` requires Python 3.11 or later")
        except_syms_seen.add(str(except_sym))
        if len(except_syms_seen) > 1:
            compiler._syntax_error(
                except_sym, "cannot have both `except` and `except*` on the same `try`"
            )

        name = None
        if len(exceptions) == 0:
            exceptions = "ALL"
        elif len(exceptions) == 1:
            [exceptions] = exceptions
        else:
            [name, exceptions] = exceptions
            name = mangle(compiler._nonconst(name))

        if exceptions == "ALL":
            # Catch all exceptions.
            types = Result()
        elif isinstance(exceptions, List):
            # [FooBar BarFoo] → Catch Foobar and BarFoo exceptions.
            elts, types, _ = compiler._compile_collect(exceptions)
            types += asty.Tuple(exceptions, elts=elts, ctx=ast.Load())
        else:
            # A single exception type.
            types = compiler.compile(exceptions)

        # Create a "fake" scope for the exception variable.