rustpython-ruff_python_parser 0.15.8

---
source: crates/ruff_python_parser/tests/fixtures.rs
input_file: crates/ruff_python_parser/resources/inline/err/duplicate_match_class_attr.py
---
## AST

```
Module(
    ModModule {
        node_index: NodeIndex(None),
        range: 0..231,
        body: [
            Match(
                StmtMatch {
                    node_index: NodeIndex(None),
                    range: 0..230,
                    subject: Name(
                        ExprName {
                            node_index: NodeIndex(None),
                            range: 6..7,
                            id: Name("x"),
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 13..38,
                            node_index: NodeIndex(None),
                            pattern: MatchClass(
                                PatternMatchClass {
                                    node_index: NodeIndex(None),
                                    range: 18..33,
                                    cls: Name(
                                        ExprName {
                                            node_index: NodeIndex(None),
                                            range: 18..23,
                                            id: Name("Class"),
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 23..33,
                                        node_index: NodeIndex(None),
                                        patterns: [],
                                        keywords: [
                                            PatternKeyword {
                                                range: 24..27,
                                                node_index: NodeIndex(None),
                                                attr: Identifier {
                                                    id: Name("x"),
                                                    range: 24..25,
                                                    node_index: NodeIndex(None),
                                                },
                                                pattern: MatchValue(
                                                    PatternMatchValue {
                                                        node_index: NodeIndex(None),
                                                        range: 26..27,
                                                        value: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                node_index: NodeIndex(None),
                                                                range: 26..27,
                                                                value: Int(
                                                                    1,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                            PatternKeyword {
                                                range: 29..32,
                                                node_index: NodeIndex(None),
                                                attr: Identifier {
                                                    id: Name("x"),
                                                    range: 29..30,
                                                    node_index: NodeIndex(None),
                                                },
                                                pattern: MatchValue(
                                                    PatternMatchValue {
                                                        node_index: NodeIndex(None),
                                                        range: 31..32,
                                                        value: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                node_index: NodeIndex(None),
                                                                range: 31..32,
                                                                value: Int(
                                                                    2,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 35..38,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 35..38,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 43..70,
                            node_index: NodeIndex(None),
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    node_index: NodeIndex(None),
                                    range: 48..65,
                                    patterns: [
                                        MatchClass(
                                            PatternMatchClass {
                                                node_index: NodeIndex(None),
                                                range: 49..64,
                                                cls: Name(
                                                    ExprName {
                                                        node_index: NodeIndex(None),
                                                        range: 49..54,
                                                        id: Name("Class"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                arguments: PatternArguments {
                                                    range: 54..64,
                                                    node_index: NodeIndex(None),
                                                    patterns: [],
                                                    keywords: [
                                                        PatternKeyword {
                                                            range: 55..58,
                                                            node_index: NodeIndex(None),
                                                            attr: Identifier {
                                                                id: Name("x"),
                                                                range: 55..56,
                                                                node_index: NodeIndex(None),
                                                            },
                                                            pattern: MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 57..58,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 57..58,
                                                                            value: Int(
                                                                                1,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                        PatternKeyword {
                                                            range: 60..63,
                                                            node_index: NodeIndex(None),
                                                            attr: Identifier {
                                                                id: Name("x"),
                                                                range: 60..61,
                                                                node_index: NodeIndex(None),
                                                            },
                                                            pattern: MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 62..63,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 62..63,
                                                                            value: Int(
                                                                                2,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                },
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 67..70,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 67..70,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 75..113,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 80..108,
                                    keys: [
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 81..84,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 81..84,
                                                            node_index: NodeIndex(None),
                                                            value: "x",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 89..92,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 89..92,
                                                            node_index: NodeIndex(None),
                                                            value: "y",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                node_index: NodeIndex(None),
                                                range: 86..87,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: Name("x"),
                                                        range: 86..87,
                                                        node_index: NodeIndex(None),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchClass(
                                            PatternMatchClass {
                                                node_index: NodeIndex(None),
                                                range: 94..107,
                                                cls: Name(
                                                    ExprName {
                                                        node_index: NodeIndex(None),
                                                        range: 94..97,
                                                        id: Name("Foo"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                arguments: PatternArguments {
                                                    range: 97..107,
                                                    node_index: NodeIndex(None),
                                                    patterns: [],
                                                    keywords: [
                                                        PatternKeyword {
                                                            range: 98..101,
                                                            node_index: NodeIndex(None),
                                                            attr: Identifier {
                                                                id: Name("x"),
                                                                range: 98..99,
                                                                node_index: NodeIndex(None),
                                                            },
                                                            pattern: MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 100..101,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 100..101,
                                                                            value: Int(
                                                                                1,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                        PatternKeyword {
                                                            range: 103..106,
                                                            node_index: NodeIndex(None),
                                                            attr: Identifier {
                                                                id: Name("x"),
                                                                range: 103..104,
                                                                node_index: NodeIndex(None),
                                                            },
                                                            pattern: MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 105..106,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 105..106,
                                                                            value: Int(
                                                                                2,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                },
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 110..113,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 110..113,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 118..162,
                            node_index: NodeIndex(None),
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    node_index: NodeIndex(None),
                                    range: 123..157,
                                    patterns: [
                                        MatchMapping(
                                            PatternMatchMapping {
                                                node_index: NodeIndex(None),
                                                range: 124..126,
                                                keys: [],
                                                patterns: [],
                                                rest: None,
                                            },
                                        ),
                                        MatchMapping(
                                            PatternMatchMapping {
                                                node_index: NodeIndex(None),
                                                range: 128..156,
                                                keys: [
                                                    StringLiteral(
                                                        ExprStringLiteral {
                                                            node_index: NodeIndex(None),
                                                            range: 129..132,
                                                            value: StringLiteralValue {
                                                                inner: Single(
                                                                    StringLiteral {
                                                                        range: 129..132,
                                                                        node_index: NodeIndex(None),
                                                                        value: "x",
                                                                        flags: StringLiteralFlags {
                                                                            quote_style: Double,
                                                                            prefix: Empty,
                                                                            triple_quoted: false,
                                                                            unclosed: false,
                                                                        },
                                                                    },
                                                                ),
                                                            },
                                                        },
                                                    ),
                                                    StringLiteral(
                                                        ExprStringLiteral {
                                                            node_index: NodeIndex(None),
                                                            range: 137..140,
                                                            value: StringLiteralValue {
                                                                inner: Single(
                                                                    StringLiteral {
                                                                        range: 137..140,
                                                                        node_index: NodeIndex(None),
                                                                        value: "y",
                                                                        flags: StringLiteralFlags {
                                                                            quote_style: Double,
                                                                            prefix: Empty,
                                                                            triple_quoted: false,
                                                                            unclosed: false,
                                                                        },
                                                                    },
                                                                ),
                                                            },
                                                        },
                                                    ),
                                                ],
                                                patterns: [
                                                    MatchAs(
                                                        PatternMatchAs {
                                                            node_index: NodeIndex(None),
                                                            range: 134..135,
                                                            pattern: None,
                                                            name: Some(
                                                                Identifier {
                                                                    id: Name("x"),
                                                                    range: 134..135,
                                                                    node_index: NodeIndex(None),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchClass(
                                                        PatternMatchClass {
                                                            node_index: NodeIndex(None),
                                                            range: 142..155,
                                                            cls: Name(
                                                                ExprName {
                                                                    node_index: NodeIndex(None),
                                                                    range: 142..145,
                                                                    id: Name("Foo"),
                                                                    ctx: Load,
                                                                },
                                                            ),
                                                            arguments: PatternArguments {
                                                                range: 145..155,
                                                                node_index: NodeIndex(None),
                                                                patterns: [],
                                                                keywords: [
                                                                    PatternKeyword {
                                                                        range: 146..149,
                                                                        node_index: NodeIndex(None),
                                                                        attr: Identifier {
                                                                            id: Name("x"),
                                                                            range: 146..147,
                                                                            node_index: NodeIndex(None),
                                                                        },
                                                                        pattern: MatchValue(
                                                                            PatternMatchValue {
                                                                                node_index: NodeIndex(None),
                                                                                range: 148..149,
                                                                                value: NumberLiteral(
                                                                                    ExprNumberLiteral {
                                                                                        node_index: NodeIndex(None),
                                                                                        range: 148..149,
                                                                                        value: Int(
                                                                                            1,
                                                                                        ),
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ),
                                                                    },
                                                                    PatternKeyword {
                                                                        range: 151..154,
                                                                        node_index: NodeIndex(None),
                                                                        attr: Identifier {
                                                                            id: Name("x"),
                                                                            range: 151..152,
                                                                            node_index: NodeIndex(None),
                                                                        },
                                                                        pattern: MatchValue(
                                                                            PatternMatchValue {
                                                                                node_index: NodeIndex(None),
                                                                                range: 153..154,
                                                                                value: NumberLiteral(
                                                                                    ExprNumberLiteral {
                                                                                        node_index: NodeIndex(None),
                                                                                        range: 153..154,
                                                                                        value: Int(
                                                                                            2,
                                                                                        ),
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ),
                                                                    },
                                                                ],
                                                            },
                                                        },
                                                    ),
                                                ],
                                                rest: None,
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 159..162,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 159..162,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 167..230,
                            node_index: NodeIndex(None),
                            pattern: MatchClass(
                                PatternMatchClass {
                                    node_index: NodeIndex(None),
                                    range: 172..225,
                                    cls: Name(
                                        ExprName {
                                            node_index: NodeIndex(None),
                                            range: 172..177,
                                            id: Name("Class"),
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 177..225,
                                        node_index: NodeIndex(None),
                                        patterns: [],
                                        keywords: [
                                            PatternKeyword {
                                                range: 178..181,
                                                node_index: NodeIndex(None),
                                                attr: Identifier {
                                                    id: Name("x"),
                                                    range: 178..179,
                                                    node_index: NodeIndex(None),
                                                },
                                                pattern: MatchValue(
                                                    PatternMatchValue {
                                                        node_index: NodeIndex(None),
                                                        range: 180..181,
                                                        value: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                node_index: NodeIndex(None),
                                                                range: 180..181,
                                                                value: Int(
                                                                    1,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                            PatternKeyword {
                                                range: 183..201,
                                                node_index: NodeIndex(None),
                                                attr: Identifier {
                                                    id: Name("d"),
                                                    range: 183..184,
                                                    node_index: NodeIndex(None),
                                                },
                                                pattern: MatchMapping(
                                                    PatternMatchMapping {
                                                        node_index: NodeIndex(None),
                                                        range: 185..201,
                                                        keys: [
                                                            StringLiteral(
                                                                ExprStringLiteral {
                                                                    node_index: NodeIndex(None),
                                                                    range: 186..189,
                                                                    value: StringLiteralValue {
                                                                        inner: Single(
                                                                            StringLiteral {
                                                                                range: 186..189,
                                                                                node_index: NodeIndex(None),
                                                                                value: "x",
                                                                                flags: StringLiteralFlags {
                                                                                    quote_style: Double,
                                                                                    prefix: Empty,
                                                                                    triple_quoted: false,
                                                                                    unclosed: false,
                                                                                },
                                                                            },
                                                                        ),
                                                                    },
                                                                },
                                                            ),
                                                            StringLiteral(
                                                                ExprStringLiteral {
                                                                    node_index: NodeIndex(None),
                                                                    range: 194..197,
                                                                    value: StringLiteralValue {
                                                                        inner: Single(
                                                                            StringLiteral {
                                                                                range: 194..197,
                                                                                node_index: NodeIndex(None),
                                                                                value: "x",
                                                                                flags: StringLiteralFlags {
                                                                                    quote_style: Double,
                                                                                    prefix: Empty,
                                                                                    triple_quoted: false,
                                                                                    unclosed: false,
                                                                                },
                                                                            },
                                                                        ),
                                                                    },
                                                                },
                                                            ),
                                                        ],
                                                        patterns: [
                                                            MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 191..192,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 191..192,
                                                                            value: Int(
                                                                                1,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                            MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 199..200,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 199..200,
                                                                            value: Int(
                                                                                2,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        ],
                                                        rest: None,
                                                    },
                                                ),
                                            },
                                            PatternKeyword {
                                                range: 203..224,
                                                node_index: NodeIndex(None),
                                                attr: Identifier {
                                                    id: Name("other"),
                                                    range: 203..208,
                                                    node_index: NodeIndex(None),
                                                },
                                                pattern: MatchClass(
                                                    PatternMatchClass {
                                                        node_index: NodeIndex(None),
                                                        range: 209..224,
                                                        cls: Name(
                                                            ExprName {
                                                                node_index: NodeIndex(None),
                                                                range: 209..214,
                                                                id: Name("Class"),
                                                                ctx: Load,
                                                            },
                                                        ),
                                                        arguments: PatternArguments {
                                                            range: 214..224,
                                                            node_index: NodeIndex(None),
                                                            patterns: [],
                                                            keywords: [
                                                                PatternKeyword {
                                                                    range: 215..218,
                                                                    node_index: NodeIndex(None),
                                                                    attr: Identifier {
                                                                        id: Name("x"),
                                                                        range: 215..216,
                                                                        node_index: NodeIndex(None),
                                                                    },
                                                                    pattern: MatchValue(
                                                                        PatternMatchValue {
                                                                            node_index: NodeIndex(None),
                                                                            range: 217..218,
                                                                            value: NumberLiteral(
                                                                                ExprNumberLiteral {
                                                                                    node_index: NodeIndex(None),
                                                                                    range: 217..218,
                                                                                    value: Int(
                                                                                        1,
                                                                                    ),
                                                                                },
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                                PatternKeyword {
                                                                    range: 220..223,
                                                                    node_index: NodeIndex(None),
                                                                    attr: Identifier {
                                                                        id: Name("x"),
                                                                        range: 220..221,
                                                                        node_index: NodeIndex(None),
                                                                    },
                                                                    pattern: MatchValue(
                                                                        PatternMatchValue {
                                                                            node_index: NodeIndex(None),
                                                                            range: 222..223,
                                                                            value: NumberLiteral(
                                                                                ExprNumberLiteral {
                                                                                    node_index: NodeIndex(None),
                                                                                    range: 222..223,
                                                                                    value: Int(
                                                                                        2,
                                                                                    ),
                                                                                },
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ],
                                                        },
                                                    },
                                                ),
                                            },
                                        ],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 227..230,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 227..230,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
        ],
    },
)
```
## Semantic Syntax Errors

  |
1 | match x:
2 |     case Class(x=1, x=2): ...
  |                     ^ Syntax Error: attribute name `x` repeated in class pattern
3 |     case [Class(x=1, x=2)]: ...
4 |     case {"x": x, "y": Foo(x=1, x=2)}: ...
  |


  |
1 | match x:
2 |     case Class(x=1, x=2): ...
3 |     case [Class(x=1, x=2)]: ...
  |                      ^ Syntax Error: attribute name `x` repeated in class pattern
4 |     case {"x": x, "y": Foo(x=1, x=2)}: ...
5 |     case [{}, {"x": x, "y": Foo(x=1, x=2)}]: ...
  |


  |
2 |     case Class(x=1, x=2): ...
3 |     case [Class(x=1, x=2)]: ...
4 |     case {"x": x, "y": Foo(x=1, x=2)}: ...
  |                                 ^ Syntax Error: attribute name `x` repeated in class pattern
5 |     case [{}, {"x": x, "y": Foo(x=1, x=2)}]: ...
6 |     case Class(x=1, d={"x": 1, "x": 2}, other=Class(x=1, x=2)): ...
  |


  |
3 |     case [Class(x=1, x=2)]: ...
4 |     case {"x": x, "y": Foo(x=1, x=2)}: ...
5 |     case [{}, {"x": x, "y": Foo(x=1, x=2)}]: ...
  |                                      ^ Syntax Error: attribute name `x` repeated in class pattern
6 |     case Class(x=1, d={"x": 1, "x": 2}, other=Class(x=1, x=2)): ...
  |


  |
4 |     case {"x": x, "y": Foo(x=1, x=2)}: ...
5 |     case [{}, {"x": x, "y": Foo(x=1, x=2)}]: ...
6 |     case Class(x=1, d={"x": 1, "x": 2}, other=Class(x=1, x=2)): ...
  |                                ^^^ Syntax Error: mapping pattern checks duplicate key `"x"`
  |


  |
4 |     case {"x": x, "y": Foo(x=1, x=2)}: ...
5 |     case [{}, {"x": x, "y": Foo(x=1, x=2)}]: ...
6 |     case Class(x=1, d={"x": 1, "x": 2}, other=Class(x=1, x=2)): ...
  |                                                          ^ Syntax Error: attribute name `x` repeated in class pattern
  |