rustpython-parser 0.4.0

---
source: parser/src/parser.rs
expression: "ast::Suite::parse(source, \"<test>\").unwrap()"
---
[
    Expr(
        StmtExpr {
            range: 2..17,
            value: Tuple(
                ExprTuple {
                    range: 2..17,
                    elts: [
                        BinOp(
                            ExprBinOp {
                                range: 2..14,
                                left: BinOp(
                                    ExprBinOp {
                                        range: 2..10,
                                        left: Name(
                                            ExprName {
                                                range: 2..7,
                                                id: Identifier(
                                                    "match",
                                                ),
                                                ctx: Load,
                                            },
                                        ),
                                        op: Mult,
                                        right: Name(
                                            ExprName {
                                                range: 9..10,
                                                id: Identifier(
                                                    "a",
                                                ),
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ),
                                op: Add,
                                right: Name(
                                    ExprName {
                                        range: 13..14,
                                        id: Identifier(
                                            "b",
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            },
                        ),
                        Name(
                            ExprName {
                                range: 16..17,
                                id: Identifier(
                                    "c",
                                ),
                                ctx: Load,
                            },
                        ),
                    ],
                    ctx: Load,
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 43..60,
            value: Tuple(
                ExprTuple {
                    range: 43..60,
                    elts: [
                        BinOp(
                            ExprBinOp {
                                range: 43..57,
                                left: Name(
                                    ExprName {
                                        range: 43..48,
                                        id: Identifier(
                                            "match",
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                op: Mult,
                                right: BinOp(
                                    ExprBinOp {
                                        range: 51..56,
                                        left: Name(
                                            ExprName {
                                                range: 51..52,
                                                id: Identifier(
                                                    "a",
                                                ),
                                                ctx: Load,
                                            },
                                        ),
                                        op: Add,
                                        right: Name(
                                            ExprName {
                                                range: 55..56,
                                                id: Identifier(
                                                    "b",
                                                ),
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ),
                            },
                        ),
                        Name(
                            ExprName {
                                range: 59..60,
                                id: Identifier(
                                    "c",
                                ),
                                ctx: Load,
                            },
                        ),
                    ],
                    ctx: Load,
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 86..103,
            value: Call(
                ExprCall {
                    range: 86..103,
                    func: Name(
                        ExprName {
                            range: 86..91,
                            id: Identifier(
                                "match",
                            ),
                            ctx: Load,
                        },
                    ),
                    args: [
                        Starred(
                            ExprStarred {
                                range: 93..99,
                                value: BinOp(
                                    ExprBinOp {
                                        range: 94..99,
                                        left: Name(
                                            ExprName {
                                                range: 94..95,
                                                id: Identifier(
                                                    "a",
                                                ),
                                                ctx: Load,
                                            },
                                        ),
                                        op: Add,
                                        right: Name(
                                            ExprName {
                                                range: 98..99,
                                                id: Identifier(
                                                    "b",
                                                ),
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ),
                                ctx: Load,
                            },
                        ),
                        Name(
                            ExprName {
                                range: 101..102,
                                id: Identifier(
                                    "c",
                                ),
                                ctx: Load,
                            },
                        ),
                    ],
                    keywords: [],
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 130..146,
            value: BinOp(
                ExprBinOp {
                    range: 130..146,
                    left: BinOp(
                        ExprBinOp {
                            range: 130..142,
                            left: Name(
                                ExprName {
                                    range: 130..135,
                                    id: Identifier(
                                        "match",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            op: Sub,
                            right: BinOp(
                                ExprBinOp {
                                    range: 137..142,
                                    left: Name(
                                        ExprName {
                                            range: 137..138,
                                            id: Identifier(
                                                "a",
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                    op: Mult,
                                    right: Name(
                                        ExprName {
                                            range: 141..142,
                                            id: Identifier(
                                                "b",
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                },
                            ),
                        },
                    ),
                    op: Add,
                    right: Name(
                        ExprName {
                            range: 145..146,
                            id: Identifier(
                                "c",
                            ),
                            ctx: Load,
                        },
                    ),
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 173..191,
            value: BinOp(
                ExprBinOp {
                    range: 173..191,
                    left: BinOp(
                        ExprBinOp {
                            range: 173..187,
                            left: Name(
                                ExprName {
                                    range: 173..178,
                                    id: Identifier(
                                        "match",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            op: Sub,
                            right: BinOp(
                                ExprBinOp {
                                    range: 181..186,
                                    left: Name(
                                        ExprName {
                                            range: 181..182,
                                            id: Identifier(
                                                "a",
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                    op: Mult,
                                    right: Name(
                                        ExprName {
                                            range: 185..186,
                                            id: Identifier(
                                                "b",
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                },
                            ),
                        },
                    ),
                    op: Add,
                    right: Name(
                        ExprName {
                            range: 190..191,
                            id: Identifier(
                                "c",
                            ),
                            ctx: Load,
                        },
                    ),
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 218..236,
            value: BinOp(
                ExprBinOp {
                    range: 218..236,
                    left: BinOp(
                        ExprBinOp {
                            range: 218..232,
                            left: Call(
                                ExprCall {
                                    range: 218..228,
                                    func: Name(
                                        ExprName {
                                            range: 218..223,
                                            id: Identifier(
                                                "match",
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                    args: [
                                        UnaryOp(
                                            ExprUnaryOp {
                                                range: 225..227,
                                                op: USub,
                                                operand: Name(
                                                    ExprName {
                                                        range: 226..227,
                                                        id: Identifier(
                                                            "a",
                                                        ),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    keywords: [],
                                },
                            ),
                            op: Mult,
                            right: Name(
                                ExprName {
                                    range: 231..232,
                                    id: Identifier(
                                        "b",
                                    ),
                                    ctx: Load,
                                },
                            ),
                        },
                    ),
                    op: Add,
                    right: Name(
                        ExprName {
                            range: 235..236,
                            id: Identifier(
                                "c",
                            ),
                            ctx: Load,
                        },
                    ),
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 264..274,
            value: Attribute(
                ExprAttribute {
                    range: 264..274,
                    value: Call(
                        ExprCall {
                            range: 264..272,
                            func: Name(
                                ExprName {
                                    range: 264..269,
                                    id: Identifier(
                                        "match",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            args: [],
                            keywords: [],
                        },
                    ),
                    attr: Identifier(
                        "a",
                    ),
                    ctx: Load,
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 291..303,
            value: Attribute(
                ExprAttribute {
                    range: 291..303,
                    value: Call(
                        ExprCall {
                            range: 291..301,
                            func: Name(
                                ExprName {
                                    range: 291..296,
                                    id: Identifier(
                                        "match",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            args: [
                                Tuple(
                                    ExprTuple {
                                        range: 298..300,
                                        elts: [],
                                        ctx: Load,
                                    },
                                ),
                            ],
                            keywords: [],
                        },
                    ),
                    attr: Identifier(
                        "a",
                    ),
                    ctx: Load,
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 322..335,
            value: Attribute(
                ExprAttribute {
                    range: 322..335,
                    value: Call(
                        ExprCall {
                            range: 322..333,
                            func: Name(
                                ExprName {
                                    range: 322..327,
                                    id: Identifier(
                                        "match",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            args: [
                                Tuple(
                                    ExprTuple {
                                        range: 329..331,
                                        elts: [],
                                        ctx: Load,
                                    },
                                ),
                            ],
                            keywords: [],
                        },
                    ),
                    attr: Identifier(
                        "a",
                    ),
                    ctx: Load,
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 354..365,
            value: Attribute(
                ExprAttribute {
                    range: 354..365,
                    value: Subscript(
                        ExprSubscript {
                            range: 354..363,
                            value: Name(
                                ExprName {
                                    range: 354..359,
                                    id: Identifier(
                                        "match",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            slice: Name(
                                ExprName {
                                    range: 361..362,
                                    id: Identifier(
                                        "a",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            ctx: Load,
                        },
                    ),
                    attr: Identifier(
                        "b",
                    ),
                    ctx: Load,
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 383..395,
            value: Attribute(
                ExprAttribute {
                    range: 383..395,
                    value: Subscript(
                        ExprSubscript {
                            range: 383..393,
                            value: Name(
                                ExprName {
                                    range: 383..388,
                                    id: Identifier(
                                        "match",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            slice: Tuple(
                                ExprTuple {
                                    range: 390..392,
                                    elts: [
                                        Name(
                                            ExprName {
                                                range: 390..391,
                                                id: Identifier(
                                                    "a",
                                                ),
                                                ctx: Load,
                                            },
                                        ),
                                    ],
                                    ctx: Load,
                                },
                            ),
                            ctx: Load,
                        },
                    ),
                    attr: Identifier(
                        "b",
                    ),
                    ctx: Load,
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 436..450,
            value: Attribute(
                ExprAttribute {
                    range: 436..450,
                    value: Subscript(
                        ExprSubscript {
                            range: 436..448,
                            value: Name(
                                ExprName {
                                    range: 436..441,
                                    id: Identifier(
                                        "match",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            slice: Tuple(
                                ExprTuple {
                                    range: 443..447,
                                    elts: [
                                        Name(
                                            ExprName {
                                                range: 444..445,
                                                id: Identifier(
                                                    "a",
                                                ),
                                                ctx: Load,
                                            },
                                        ),
                                    ],
                                    ctx: Load,
                                },
                            ),
                            ctx: Load,
                        },
                    ),
                    attr: Identifier(
                        "b",
                    ),
                    ctx: Load,
                },
            ),
        },
    ),
    Expr(
        StmtExpr {
            range: 471..488,
            value: Subscript(
                ExprSubscript {
                    range: 471..488,
                    value: Call(
                        ExprCall {
                            range: 471..478,
                            func: Name(
                                ExprName {
                                    range: 471..476,
                                    id: Identifier(
                                        "match",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            args: [],
                            keywords: [],
                        },
                    ),
                    slice: Slice(
                        ExprSlice {
                            range: 479..487,
                            lower: Some(
                                Name(
                                    ExprName {
                                        range: 479..480,
                                        id: Identifier(
                                            "a",
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ),
                            upper: Some(
                                Name(
                                    ExprName {
                                        range: 486..487,
                                        id: Identifier(
                                            "b",
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ),
                            step: None,
                        },
                    ),
                    ctx: Load,
                },
            ),
        },
    ),
    If(
        StmtIf {
            range: 508..527,
            test: NamedExpr(
                ExprNamedExpr {
                    range: 511..521,
                    target: Name(
                        ExprName {
                            range: 511..516,
                            id: Identifier(
                                "match",
                            ),
                            ctx: Store,
                        },
                    ),
                    value: Constant(
                        ExprConstant {
                            range: 520..521,
                            value: Int(
                                1,
                            ),
                            kind: None,
                        },
                    ),
                },
            ),
            body: [
                Pass(
                    StmtPass {
                        range: 523..527,
                    },
                ),
            ],
            orelse: [],
        },
    ),
    Match(
        StmtMatch {
            range: 528..582,
            subject: Name(
                ExprName {
                    range: 534..539,
                    id: Identifier(
                        "match",
                    ),
                    ctx: Load,
                },
            ),
            cases: [
                MatchCase {
                    range: 545..557,
                    pattern: MatchValue(
                        PatternMatchValue {
                            range: 550..551,
                            value: Constant(
                                ExprConstant {
                                    range: 550..551,
                                    value: Int(
                                        1,
                                    ),
                                    kind: None,
                                },
                            ),
                        },
                    ),
                    guard: None,
                    body: [
                        Pass(
                            StmtPass {
                                range: 553..557,
                            },
                        ),
                    ],
                },
                MatchCase {
                    range: 562..582,
                    pattern: MatchValue(
                        PatternMatchValue {
                            range: 567..568,
                            value: Constant(
                                ExprConstant {
                                    range: 567..568,
                                    value: Int(
                                        2,
                                    ),
                                    kind: None,
                                },
                            ),
                        },
                    ),
                    guard: None,
                    body: [
                        Pass(
                            StmtPass {
                                range: 578..582,
                            },
                        ),
                    ],
                },
            ],
        },
    ),
    Assign(
        StmtAssign {
            range: 583..619,
            targets: [
                Name(
                    ExprName {
                        range: 583..588,
                        id: Identifier(
                            "match",
                        ),
                        ctx: Store,
                    },
                ),
            ],
            value: Lambda(
                ExprLambda {
                    range: 591..619,
                    args: Arguments {
                        range: 598..603,
                        posonlyargs: [],
                        args: [
                            ArgWithDefault {
                                range: 598..603,
                                def: Arg {
                                    range: 598..603,
                                    arg: Identifier(
                                        "query",
                                    ),
                                    annotation: None,
                                    type_comment: None,
                                },
                                default: None,
                            },
                        ],
                        vararg: None,
                        kwonlyargs: [],
                        kwarg: None,
                    },
                    body: Compare(
                        ExprCompare {
                            range: 605..619,
                            left: Name(
                                ExprName {
                                    range: 605..610,
                                    id: Identifier(
                                        "query",
                                    ),
                                    ctx: Load,
                                },
                            ),
                            ops: [
                                Eq,
                            ],
                            comparators: [
                                Name(
                                    ExprName {
                                        range: 614..619,
                                        id: Identifier(
                                            "event",
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                        },
                    ),
                },
            ),
            type_comment: None,
        },
    ),
    Expr(
        StmtExpr {
            range: 620..636,
            value: Call(
                ExprCall {
                    range: 620..636,
                    func: Name(
                        ExprName {
                            range: 620..625,
                            id: Identifier(
                                "print",
                            ),
                            ctx: Load,
                        },
                    ),
                    args: [
                        Call(
                            ExprCall {
                                range: 626..635,
                                func: Name(
                                    ExprName {
                                        range: 626..631,
                                        id: Identifier(
                                            "match",
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                args: [
                                    Constant(
                                        ExprConstant {
                                            range: 632..634,
                                            value: Int(
                                                12,
                                            ),
                                            kind: None,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        ),
                    ],
                    keywords: [],
                },
            ),
        },
    ),
]