---
source: crates/ruff_python_parser/tests/fixtures.rs
input_file: crates/ruff_python_parser/resources/invalid/expressions/parenthesized/tuple_starred_expr.py
---
## AST

```
Module(
    ModModule {
        node_index: AtomicNodeIndex(..),
        range: 0..532,
        body: [
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 157..178,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 157..178,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 158..165,
                                        value: Compare(
                                            ExprCompare {
                                                node_index: AtomicNodeIndex(..),
                                                range: 159..165,
                                                left: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 159..160,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                ops: [
                                                    In,
                                                ],
                                                comparators: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 164..165,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 167..168,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 170..177,
                                        value: Compare(
                                            ExprCompare {
                                                node_index: AtomicNodeIndex(..),
                                                range: 171..177,
                                                left: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 171..172,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                ops: [
                                                    In,
                                                ],
                                                comparators: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 176..177,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 179..198,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 179..198,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 180..186,
                                        value: UnaryOp(
                                            ExprUnaryOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 181..186,
                                                op: Not,
                                                operand: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 185..186,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 188..189,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 191..197,
                                        value: UnaryOp(
                                            ExprUnaryOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 192..197,
                                                op: Not,
                                                operand: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 196..197,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 199..222,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 199..222,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 200..208,
                                        value: BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 201..208,
                                                op: And,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 201..202,
                                                            id: Name("x"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 207..208,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 210..211,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 213..221,
                                        value: BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 214..221,
                                                op: And,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 214..215,
                                                            id: Name("x"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 220..221,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 223..244,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 223..244,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 224..231,
                                        value: BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 225..231,
                                                op: Or,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 225..226,
                                                            id: Name("x"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 230..231,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 233..234,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 236..243,
                                        value: BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 237..243,
                                                op: Or,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 237..238,
                                                            id: Name("x"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 242..243,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 245..286,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 245..286,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 246..263,
                                        value: If(
                                            ExprIf {
                                                node_index: AtomicNodeIndex(..),
                                                range: 247..263,
                                                test: BooleanLiteral(
                                                    ExprBooleanLiteral {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 252..256,
                                                        value: true,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 247..248,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                orelse: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 262..263,
                                                        id: Name("y"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 265..266,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 268..285,
                                        value: If(
                                            ExprIf {
                                                node_index: AtomicNodeIndex(..),
                                                range: 269..285,
                                                test: BooleanLiteral(
                                                    ExprBooleanLiteral {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 274..278,
                                                        value: true,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 269..270,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                orelse: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 284..285,
                                                        id: Name("y"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 287..318,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 287..318,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 288..300,
                                        value: Lambda(
                                            ExprLambda {
                                                node_index: AtomicNodeIndex(..),
                                                range: 289..300,
                                                parameters: Some(
                                                    Parameters {
                                                        range: 296..297,
                                                        node_index: AtomicNodeIndex(
                                                            0,
                                                        ),
                                                        posonlyargs: [],
                                                        args: [
                                                            ParameterWithDefault {
                                                                range: 296..297,
                                                                node_index: AtomicNodeIndex(..),
                                                                parameter: Parameter {
                                                                    range: 296..297,
                                                                    node_index: AtomicNodeIndex(..),
                                                                    name: Identifier {
                                                                        id: Name("x"),
                                                                        range: 296..297,
                                                                        node_index: AtomicNodeIndex(..),
                                                                    },
                                                                    annotation: None,
                                                                },
                                                                default: None,
                                                            },
                                                        ],
                                                        vararg: None,
                                                        kwonlyargs: [],
                                                        kwarg: None,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 299..300,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 302..303,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 305..317,
                                        value: Lambda(
                                            ExprLambda {
                                                node_index: AtomicNodeIndex(..),
                                                range: 306..317,
                                                parameters: Some(
                                                    Parameters {
                                                        range: 313..314,
                                                        node_index: AtomicNodeIndex(
                                                            0,
                                                        ),
                                                        posonlyargs: [],
                                                        args: [
                                                            ParameterWithDefault {
                                                                range: 313..314,
                                                                node_index: AtomicNodeIndex(..),
                                                                parameter: Parameter {
                                                                    range: 313..314,
                                                                    node_index: AtomicNodeIndex(..),
                                                                    name: Identifier {
                                                                        id: Name("x"),
                                                                        range: 313..314,
                                                                        node_index: AtomicNodeIndex(..),
                                                                    },
                                                                    annotation: None,
                                                                },
                                                                default: None,
                                                            },
                                                        ],
                                                        vararg: None,
                                                        kwonlyargs: [],
                                                        kwarg: None,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 316..317,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 319..340,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 319..340,
                            elts: [
                                Named(
                                    ExprNamed {
                                        node_index: AtomicNodeIndex(..),
                                        range: 320..327,
                                        target: Starred(
                                            ExprStarred {
                                                node_index: AtomicNodeIndex(..),
                                                range: 320..322,
                                                value: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 321..322,
                                                        id: Name("x"),
                                                        ctx: Store,
                                                    },
                                                ),
                                                ctx: Store,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: AtomicNodeIndex(..),
                                                range: 326..327,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 329..330,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Named(
                                    ExprNamed {
                                        node_index: AtomicNodeIndex(..),
                                        range: 332..339,
                                        target: Starred(
                                            ExprStarred {
                                                node_index: AtomicNodeIndex(..),
                                                range: 332..334,
                                                value: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 333..334,
                                                        id: Name("x"),
                                                        ctx: Store,
                                                    },
                                                ),
                                                ctx: Store,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: AtomicNodeIndex(..),
                                                range: 338..339,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 363..382,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 363..382,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 363..370,
                                        value: Compare(
                                            ExprCompare {
                                                node_index: AtomicNodeIndex(..),
                                                range: 364..370,
                                                left: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 364..365,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                ops: [
                                                    In,
                                                ],
                                                comparators: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 369..370,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 372..373,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 375..382,
                                        value: Compare(
                                            ExprCompare {
                                                node_index: AtomicNodeIndex(..),
                                                range: 376..382,
                                                left: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 376..377,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                ops: [
                                                    In,
                                                ],
                                                comparators: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 381..382,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 383..400,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 383..400,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 383..389,
                                        value: UnaryOp(
                                            ExprUnaryOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 384..389,
                                                op: Not,
                                                operand: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 388..389,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 391..392,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 394..400,
                                        value: UnaryOp(
                                            ExprUnaryOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 395..400,
                                                op: Not,
                                                operand: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 399..400,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 401..422,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 401..422,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 401..409,
                                        value: BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 402..409,
                                                op: And,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 402..403,
                                                            id: Name("x"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 408..409,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 411..412,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 414..422,
                                        value: BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 415..422,
                                                op: And,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 415..416,
                                                            id: Name("x"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 421..422,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 423..442,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 423..442,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 423..430,
                                        value: BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 424..430,
                                                op: Or,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 424..425,
                                                            id: Name("x"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 429..430,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 432..433,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 435..442,
                                        value: BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 436..442,
                                                op: Or,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 436..437,
                                                            id: Name("x"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 441..442,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 443..482,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 443..482,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 443..460,
                                        value: If(
                                            ExprIf {
                                                node_index: AtomicNodeIndex(..),
                                                range: 444..460,
                                                test: BooleanLiteral(
                                                    ExprBooleanLiteral {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 449..453,
                                                        value: true,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 444..445,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                orelse: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 459..460,
                                                        id: Name("y"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 462..463,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 465..482,
                                        value: If(
                                            ExprIf {
                                                node_index: AtomicNodeIndex(..),
                                                range: 466..482,
                                                test: BooleanLiteral(
                                                    ExprBooleanLiteral {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 471..475,
                                                        value: true,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 466..467,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                orelse: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 481..482,
                                                        id: Name("y"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 483..512,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 483..512,
                            elts: [
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 483..495,
                                        value: Lambda(
                                            ExprLambda {
                                                node_index: AtomicNodeIndex(..),
                                                range: 484..495,
                                                parameters: Some(
                                                    Parameters {
                                                        range: 491..492,
                                                        node_index: AtomicNodeIndex(
                                                            0,
                                                        ),
                                                        posonlyargs: [],
                                                        args: [
                                                            ParameterWithDefault {
                                                                range: 491..492,
                                                                node_index: AtomicNodeIndex(..),
                                                                parameter: Parameter {
                                                                    range: 491..492,
                                                                    node_index: AtomicNodeIndex(..),
                                                                    name: Identifier {
                                                                        id: Name("x"),
                                                                        range: 491..492,
                                                                        node_index: AtomicNodeIndex(..),
                                                                    },
                                                                    annotation: None,
                                                                },
                                                                default: None,
                                                            },
                                                        ],
                                                        vararg: None,
                                                        kwonlyargs: [],
                                                        kwarg: None,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 494..495,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 497..498,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 500..512,
                                        value: Lambda(
                                            ExprLambda {
                                                node_index: AtomicNodeIndex(..),
                                                range: 501..512,
                                                parameters: Some(
                                                    Parameters {
                                                        range: 508..509,
                                                        node_index: AtomicNodeIndex(
                                                            0,
                                                        ),
                                                        posonlyargs: [],
                                                        args: [
                                                            ParameterWithDefault {
                                                                range: 508..509,
                                                                node_index: AtomicNodeIndex(..),
                                                                parameter: Parameter {
                                                                    range: 508..509,
                                                                    node_index: AtomicNodeIndex(..),
                                                                    name: Identifier {
                                                                        id: Name("x"),
                                                                        range: 508..509,
                                                                        node_index: AtomicNodeIndex(..),
                                                                    },
                                                                    annotation: None,
                                                                },
                                                                default: None,
                                                            },
                                                        ],
                                                        vararg: None,
                                                        kwonlyargs: [],
                                                        kwarg: None,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 511..512,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 513..515,
                    value: Starred(
                        ExprStarred {
                            node_index: AtomicNodeIndex(..),
                            range: 513..515,
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 514..515,
                                    id: Name("x"),
                                    ctx: Load,
                                },
                            ),
                            ctx: Load,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 519..532,
                    value: Tuple(
                        ExprTuple {
                            node_index: AtomicNodeIndex(..),
                            range: 519..532,
                            elts: [
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        node_index: AtomicNodeIndex(..),
                                        range: 519..520,
                                        value: Int(
                                            2,
                                        ),
                                    },
                                ),
                                Name(
                                    ExprName {
                                        node_index: AtomicNodeIndex(..),
                                        range: 522..523,
                                        id: Name("z"),
                                        ctx: Load,
                                    },
                                ),
                                Starred(
                                    ExprStarred {
                                        node_index: AtomicNodeIndex(..),
                                        range: 525..527,
                                        value: Name(
                                            ExprName {
                                                node_index: AtomicNodeIndex(..),
                                                range: 526..527,
                                                id: Name("x"),
                                                ctx: Load,
                                            },
                                        ),
                                        ctx: Load,
                                    },
                                ),
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        node_index: AtomicNodeIndex(..),
                                        range: 531..532,
                                        value: Int(
                                            2,
                                        ),
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                },
            ),
        ],
    },
)
```
## Errors

  |
2 | # Test the first and any other element as there are two separate calls.
3 |
4 | (*x in y, z, *x in y)
  |   ^^^^^^ Syntax Error: Comparison expression cannot be used here
5 | (*not x, z, *not x)
6 | (*x and y, z, *x and y)
  |


  |
2 | # Test the first and any other element as there are two separate calls.
3 |
4 | (*x in y, z, *x in y)
  |               ^^^^^^ Syntax Error: Comparison expression cannot be used here
5 | (*not x, z, *not x)
6 | (*x and y, z, *x and y)
  |


  |
4 | (*x in y, z, *x in y)
5 | (*not x, z, *not x)
  |   ^^^^^ Syntax Error: Boolean expression cannot be used here
6 | (*x and y, z, *x and y)
7 | (*x or y, z, *x or y)
  |


  |
4 | (*x in y, z, *x in y)
5 | (*not x, z, *not x)
  |              ^^^^^ Syntax Error: Boolean expression cannot be used here
6 | (*x and y, z, *x and y)
7 | (*x or y, z, *x or y)
  |


  |
4 | (*x in y, z, *x in y)
5 | (*not x, z, *not x)
6 | (*x and y, z, *x and y)
  |   ^^^^^^^ Syntax Error: Boolean expression cannot be used here
7 | (*x or y, z, *x or y)
8 | (*x if True else y, z, *x if True else y)
  |


  |
4 | (*x in y, z, *x in y)
5 | (*not x, z, *not x)
6 | (*x and y, z, *x and y)
  |                ^^^^^^^ Syntax Error: Boolean expression cannot be used here
7 | (*x or y, z, *x or y)
8 | (*x if True else y, z, *x if True else y)
  |


  |
5 | (*not x, z, *not x)
6 | (*x and y, z, *x and y)
7 | (*x or y, z, *x or y)
  |   ^^^^^^ Syntax Error: Boolean expression cannot be used here
8 | (*x if True else y, z, *x if True else y)
9 | (*lambda x: x, z, *lambda x: x)
  |


  |
5 | (*not x, z, *not x)
6 | (*x and y, z, *x and y)
7 | (*x or y, z, *x or y)
  |               ^^^^^^ Syntax Error: Boolean expression cannot be used here
8 | (*x if True else y, z, *x if True else y)
9 | (*lambda x: x, z, *lambda x: x)
  |


   |
 6 | (*x and y, z, *x and y)
 7 | (*x or y, z, *x or y)
 8 | (*x if True else y, z, *x if True else y)
   |   ^^^^^^^^^^^^^^^^ Syntax Error: Conditional expression cannot be used here
 9 | (*lambda x: x, z, *lambda x: x)
10 | (*x := 2, z, *x := 2)
   |


   |
 6 | (*x and y, z, *x and y)
 7 | (*x or y, z, *x or y)
 8 | (*x if True else y, z, *x if True else y)
   |                         ^^^^^^^^^^^^^^^^ Syntax Error: Conditional expression cannot be used here
 9 | (*lambda x: x, z, *lambda x: x)
10 | (*x := 2, z, *x := 2)
   |


   |
 7 | (*x or y, z, *x or y)
 8 | (*x if True else y, z, *x if True else y)
 9 | (*lambda x: x, z, *lambda x: x)
   |   ^^^^^^^^^^^ Syntax Error: Lambda expression cannot be used here
10 | (*x := 2, z, *x := 2)
   |


   |
 7 | (*x or y, z, *x or y)
 8 | (*x if True else y, z, *x if True else y)
 9 | (*lambda x: x, z, *lambda x: x)
   |                    ^^^^^^^^^^^ Syntax Error: Lambda expression cannot be used here
10 | (*x := 2, z, *x := 2)
   |


   |
 8 | (*x if True else y, z, *x if True else y)
 9 | (*lambda x: x, z, *lambda x: x)
10 | (*x := 2, z, *x := 2)
   |  ^^ Syntax Error: Assignment expression target must be an identifier
   |


   |
 8 | (*x if True else y, z, *x if True else y)
 9 | (*lambda x: x, z, *lambda x: x)
10 | (*x := 2, z, *x := 2)
   |              ^^ Syntax Error: Assignment expression target must be an identifier
   |


   |
13 | # Non-parenthesized
14 | *x in y, z, *x in y
   |  ^^^^^^ Syntax Error: Comparison expression cannot be used here
15 | *not x, z, *not x
16 | *x and y, z, *x and y
   |


   |
13 | # Non-parenthesized
14 | *x in y, z, *x in y
   |              ^^^^^^ Syntax Error: Comparison expression cannot be used here
15 | *not x, z, *not x
16 | *x and y, z, *x and y
   |


   |
13 | # Non-parenthesized
14 | *x in y, z, *x in y
15 | *not x, z, *not x
   |  ^^^^^ Syntax Error: Boolean expression cannot be used here
16 | *x and y, z, *x and y
17 | *x or y, z, *x or y
   |


   |
13 | # Non-parenthesized
14 | *x in y, z, *x in y
15 | *not x, z, *not x
   |             ^^^^^ Syntax Error: Boolean expression cannot be used here
16 | *x and y, z, *x and y
17 | *x or y, z, *x or y
   |


   |
14 | *x in y, z, *x in y
15 | *not x, z, *not x
16 | *x and y, z, *x and y
   |  ^^^^^^^ Syntax Error: Boolean expression cannot be used here
17 | *x or y, z, *x or y
18 | *x if True else y, z, *x if True else y
   |


   |
14 | *x in y, z, *x in y
15 | *not x, z, *not x
16 | *x and y, z, *x and y
   |               ^^^^^^^ Syntax Error: Boolean expression cannot be used here
17 | *x or y, z, *x or y
18 | *x if True else y, z, *x if True else y
   |


   |
15 | *not x, z, *not x
16 | *x and y, z, *x and y
17 | *x or y, z, *x or y
   |  ^^^^^^ Syntax Error: Boolean expression cannot be used here
18 | *x if True else y, z, *x if True else y
19 | *lambda x: x, z, *lambda x: x
   |


   |
15 | *not x, z, *not x
16 | *x and y, z, *x and y
17 | *x or y, z, *x or y
   |              ^^^^^^ Syntax Error: Boolean expression cannot be used here
18 | *x if True else y, z, *x if True else y
19 | *lambda x: x, z, *lambda x: x
   |


   |
16 | *x and y, z, *x and y
17 | *x or y, z, *x or y
18 | *x if True else y, z, *x if True else y
   |  ^^^^^^^^^^^^^^^^ Syntax Error: Conditional expression cannot be used here
19 | *lambda x: x, z, *lambda x: x
20 | *x := 2, z, *x := 2
   |


   |
16 | *x and y, z, *x and y
17 | *x or y, z, *x or y
18 | *x if True else y, z, *x if True else y
   |                        ^^^^^^^^^^^^^^^^ Syntax Error: Conditional expression cannot be used here
19 | *lambda x: x, z, *lambda x: x
20 | *x := 2, z, *x := 2
   |


   |
17 | *x or y, z, *x or y
18 | *x if True else y, z, *x if True else y
19 | *lambda x: x, z, *lambda x: x
   |  ^^^^^^^^^^^ Syntax Error: Lambda expression cannot be used here
20 | *x := 2, z, *x := 2
   |


   |
17 | *x or y, z, *x or y
18 | *x if True else y, z, *x if True else y
19 | *lambda x: x, z, *lambda x: x
   |                   ^^^^^^^^^^^ Syntax Error: Lambda expression cannot be used here
20 | *x := 2, z, *x := 2
   |


   |
18 | *x if True else y, z, *x if True else y
19 | *lambda x: x, z, *lambda x: x
20 | *x := 2, z, *x := 2
   |    ^^ Syntax Error: Expected a statement
   |


   |
18 | *x if True else y, z, *x if True else y
19 | *lambda x: x, z, *lambda x: x
20 | *x := 2, z, *x := 2
   |                ^^ Syntax Error: Expected ',', found ':='
   |
