rustpython-ruff_python_parser 0.15.8

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

```
Module(
    ModModule {
        node_index: NodeIndex(None),
        range: 0..549,
        body: [
            Expr(
                StmtExpr {
                    node_index: NodeIndex(None),
                    range: 44..74,
                    value: FString(
                        ExprFString {
                            node_index: NodeIndex(None),
                            range: 44..74,
                            value: FStringValue {
                                inner: Single(
                                    FString(
                                        FString {
                                            range: 44..74,
                                            node_index: NodeIndex(None),
                                            elements: [
                                                Literal(
                                                    InterpolatedStringLiteralElement {
                                                        range: 46..58,
                                                        node_index: NodeIndex(None),
                                                        value: "Magic wand: ",
                                                    },
                                                ),
                                                Interpolation(
                                                    InterpolatedElement {
                                                        range: 58..73,
                                                        node_index: NodeIndex(None),
                                                        expression: Subscript(
                                                            ExprSubscript {
                                                                node_index: NodeIndex(None),
                                                                range: 60..71,
                                                                value: Name(
                                                                    ExprName {
                                                                        node_index: NodeIndex(None),
                                                                        range: 60..63,
                                                                        id: Name("bag"),
                                                                        ctx: Load,
                                                                    },
                                                                ),
                                                                slice: StringLiteral(
                                                                    ExprStringLiteral {
                                                                        node_index: NodeIndex(None),
                                                                        range: 64..70,
                                                                        value: StringLiteralValue {
                                                                            inner: Single(
                                                                                StringLiteral {
                                                                                    range: 64..70,
                                                                                    node_index: NodeIndex(None),
                                                                                    value: "wand",
                                                                                    flags: StringLiteralFlags {
                                                                                        quote_style: Single,
                                                                                        prefix: Empty,
                                                                                        triple_quoted: false,
                                                                                        unclosed: false,
                                                                                    },
                                                                                },
                                                                            ),
                                                                        },
                                                                    },
                                                                ),
                                                                ctx: Load,
                                                            },
                                                        ),
                                                        debug_text: None,
                                                        conversion: None,
                                                        format_spec: None,
                                                    },
                                                ),
                                            ],
                                            flags: FStringFlags {
                                                quote_style: Single,
                                                prefix: Regular,
                                                triple_quoted: false,
                                                unclosed: false,
                                            },
                                        },
                                    ),
                                ),
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: NodeIndex(None),
                    range: 95..112,
                    value: FString(
                        ExprFString {
                            node_index: NodeIndex(None),
                            range: 95..112,
                            value: FStringValue {
                                inner: Single(
                                    FString(
                                        FString {
                                            range: 95..112,
                                            node_index: NodeIndex(None),
                                            elements: [
                                                Interpolation(
                                                    InterpolatedElement {
                                                        range: 97..111,
                                                        node_index: NodeIndex(None),
                                                        expression: Call(
                                                            ExprCall {
                                                                node_index: NodeIndex(None),
                                                                range: 98..110,
                                                                func: Attribute(
                                                                    ExprAttribute {
                                                                        node_index: NodeIndex(None),
                                                                        range: 98..107,
                                                                        value: StringLiteral(
                                                                            ExprStringLiteral {
                                                                                node_index: NodeIndex(None),
                                                                                range: 98..102,
                                                                                value: StringLiteralValue {
                                                                                    inner: Single(
                                                                                        StringLiteral {
                                                                                            range: 98..102,
                                                                                            node_index: NodeIndex(None),
                                                                                            value: "\n",
                                                                                            flags: StringLiteralFlags {
                                                                                                quote_style: Single,
                                                                                                prefix: Empty,
                                                                                                triple_quoted: false,
                                                                                                unclosed: false,
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            },
                                                                        ),
                                                                        attr: Identifier {
                                                                            id: Name("join"),
                                                                            range: 103..107,
                                                                            node_index: NodeIndex(None),
                                                                        },
                                                                        ctx: Load,
                                                                    },
                                                                ),
                                                                arguments: Arguments {
                                                                    range: 107..110,
                                                                    node_index: NodeIndex(None),
                                                                    args: [
                                                                        Name(
                                                                            ExprName {
                                                                                node_index: NodeIndex(None),
                                                                                range: 108..109,
                                                                                id: Name("a"),
                                                                                ctx: Load,
                                                                            },
                                                                        ),
                                                                    ],
                                                                    keywords: [],
                                                                },
                                                            },
                                                        ),
                                                        debug_text: None,
                                                        conversion: None,
                                                        format_spec: None,
                                                    },
                                                ),
                                            ],
                                            flags: FStringFlags {
                                                quote_style: Double,
                                                prefix: Regular,
                                                triple_quoted: false,
                                                unclosed: false,
                                            },
                                        },
                                    ),
                                ),
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: NodeIndex(None),
                    range: 148..220,
                    value: FString(
                        ExprFString {
                            node_index: NodeIndex(None),
                            range: 148..220,
                            value: FStringValue {
                                inner: Single(
                                    FString(
                                        FString {
                                            range: 148..220,
                                            node_index: NodeIndex(None),
                                            elements: [
                                                Literal(
                                                    InterpolatedStringLiteralElement {
                                                        range: 152..169,
                                                        node_index: NodeIndex(None),
                                                        value: "A complex trick: ",
                                                    },
                                                ),
                                                Interpolation(
                                                    InterpolatedElement {
                                                        range: 169..217,
                                                        node_index: NodeIndex(None),
                                                        expression: Subscript(
                                                            ExprSubscript {
                                                                node_index: NodeIndex(None),
                                                                range: 175..185,
                                                                value: Name(
                                                                    ExprName {
                                                                        node_index: NodeIndex(None),
                                                                        range: 175..178,
                                                                        id: Name("bag"),
                                                                        ctx: Load,
                                                                    },
                                                                ),
                                                                slice: StringLiteral(
                                                                    ExprStringLiteral {
                                                                        node_index: NodeIndex(None),
                                                                        range: 179..184,
                                                                        value: StringLiteralValue {
                                                                            inner: Single(
                                                                                StringLiteral {
                                                                                    range: 179..184,
                                                                                    node_index: NodeIndex(None),
                                                                                    value: "bag",
                                                                                    flags: StringLiteralFlags {
                                                                                        quote_style: Single,
                                                                                        prefix: Empty,
                                                                                        triple_quoted: false,
                                                                                        unclosed: false,
                                                                                    },
                                                                                },
                                                                            ),
                                                                        },
                                                                    },
                                                                ),
                                                                ctx: Load,
                                                            },
                                                        ),
                                                        debug_text: None,
                                                        conversion: None,
                                                        format_spec: None,
                                                    },
                                                ),
                                            ],
                                            flags: FStringFlags {
                                                quote_style: Single,
                                                prefix: Regular,
                                                triple_quoted: true,
                                                unclosed: false,
                                            },
                                        },
                                    ),
                                ),
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: NodeIndex(None),
                    range: 221..254,
                    value: FString(
                        ExprFString {
                            node_index: NodeIndex(None),
                            range: 221..254,
                            value: FStringValue {
                                inner: Single(
                                    FString(
                                        FString {
                                            range: 221..254,
                                            node_index: NodeIndex(None),
                                            elements: [
                                                Interpolation(
                                                    InterpolatedElement {
                                                        range: 223..253,
                                                        node_index: NodeIndex(None),
                                                        expression: FString(
                                                            ExprFString {
                                                                node_index: NodeIndex(None),
                                                                range: 224..252,
                                                                value: FStringValue {
                                                                    inner: Single(
                                                                        FString(
                                                                            FString {
                                                                                range: 224..252,
                                                                                node_index: NodeIndex(None),
                                                                                elements: [
                                                                                    Interpolation(
                                                                                        InterpolatedElement {
                                                                                            range: 226..251,
                                                                                            node_index: NodeIndex(None),
                                                                                            expression: FString(
                                                                                                ExprFString {
                                                                                                    node_index: NodeIndex(None),
                                                                                                    range: 227..250,
                                                                                                    value: FStringValue {
                                                                                                        inner: Single(
                                                                                                            FString(
                                                                                                                FString {
                                                                                                                    range: 227..250,
                                                                                                                    node_index: NodeIndex(None),
                                                                                                                    elements: [
                                                                                                                        Interpolation(
                                                                                                                            InterpolatedElement {
                                                                                                                                range: 229..249,
                                                                                                                                node_index: NodeIndex(None),
                                                                                                                                expression: FString(
                                                                                                                                    ExprFString {
                                                                                                                                        node_index: NodeIndex(None),
                                                                                                                                        range: 230..248,
                                                                                                                                        value: FStringValue {
                                                                                                                                            inner: Single(
                                                                                                                                                FString(
                                                                                                                                                    FString {
                                                                                                                                                        range: 230..248,
                                                                                                                                                        node_index: NodeIndex(None),
                                                                                                                                                        elements: [
                                                                                                                                                            Interpolation(
                                                                                                                                                                InterpolatedElement {
                                                                                                                                                                    range: 232..247,
                                                                                                                                                                    node_index: NodeIndex(None),
                                                                                                                                                                    expression: FString(
                                                                                                                                                                        ExprFString {
                                                                                                                                                                            node_index: NodeIndex(None),
                                                                                                                                                                            range: 233..246,
                                                                                                                                                                            value: FStringValue {
                                                                                                                                                                                inner: Single(
                                                                                                                                                                                    FString(
                                                                                                                                                                                        FString {
                                                                                                                                                                                            range: 233..246,
                                                                                                                                                                                            node_index: NodeIndex(None),
                                                                                                                                                                                            elements: [
                                                                                                                                                                                                Interpolation(
                                                                                                                                                                                                    InterpolatedElement {
                                                                                                                                                                                                        range: 235..245,
                                                                                                                                                                                                        node_index: NodeIndex(None),
                                                                                                                                                                                                        expression: FString(
                                                                                                                                                                                                            ExprFString {
                                                                                                                                                                                                                node_index: NodeIndex(None),
                                                                                                                                                                                                                range: 236..244,
                                                                                                                                                                                                                value: FStringValue {
                                                                                                                                                                                                                    inner: Single(
                                                                                                                                                                                                                        FString(
                                                                                                                                                                                                                            FString {
                                                                                                                                                                                                                                range: 236..244,
                                                                                                                                                                                                                                node_index: NodeIndex(None),
                                                                                                                                                                                                                                elements: [
                                                                                                                                                                                                                                    Interpolation(
                                                                                                                                                                                                                                        InterpolatedElement {
                                                                                                                                                                                                                                            range: 238..243,
                                                                                                                                                                                                                                            node_index: NodeIndex(None),
                                                                                                                                                                                                                                            expression: BinOp(
                                                                                                                                                                                                                                                ExprBinOp {
                                                                                                                                                                                                                                                    node_index: NodeIndex(None),
                                                                                                                                                                                                                                                    range: 239..242,
                                                                                                                                                                                                                                                    left: NumberLiteral(
                                                                                                                                                                                                                                                        ExprNumberLiteral {
                                                                                                                                                                                                                                                            node_index: NodeIndex(None),
                                                                                                                                                                                                                                                            range: 239..240,
                                                                                                                                                                                                                                                            value: Int(
                                                                                                                                                                                                                                                                1,
                                                                                                                                                                                                                                                            ),
                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                    ),
                                                                                                                                                                                                                                                    op: Add,
                                                                                                                                                                                                                                                    right: NumberLiteral(
                                                                                                                                                                                                                                                        ExprNumberLiteral {
                                                                                                                                                                                                                                                            node_index: NodeIndex(None),
                                                                                                                                                                                                                                                            range: 241..242,
                                                                                                                                                                                                                                                            value: Int(
                                                                                                                                                                                                                                                                1,
                                                                                                                                                                                                                                                            ),
                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                    ),
                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                            ),
                                                                                                                                                                                                                                            debug_text: None,
                                                                                                                                                                                                                                            conversion: None,
                                                                                                                                                                                                                                            format_spec: None,
                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                    ),
                                                                                                                                                                                                                                ],
                                                                                                                                                                                                                                flags: FStringFlags {
                                                                                                                                                                                                                                    quote_style: Double,
                                                                                                                                                                                                                                    prefix: Regular,
                                                                                                                                                                                                                                    triple_quoted: false,
                                                                                                                                                                                                                                    unclosed: false,
                                                                                                                                                                                                                                },
                                                                                                                                                                                                                            },
                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                    ),
                                                                                                                                                                                                                },
                                                                                                                                                                                                            },
                                                                                                                                                                                                        ),
                                                                                                                                                                                                        debug_text: None,
                                                                                                                                                                                                        conversion: None,
                                                                                                                                                                                                        format_spec: None,
                                                                                                                                                                                                    },
                                                                                                                                                                                                ),
                                                                                                                                                                                            ],
                                                                                                                                                                                            flags: FStringFlags {
                                                                                                                                                                                                quote_style: Double,
                                                                                                                                                                                                prefix: Regular,
                                                                                                                                                                                                triple_quoted: false,
                                                                                                                                                                                                unclosed: false,
                                                                                                                                                                                            },
                                                                                                                                                                                        },
                                                                                                                                                                                    ),
                                                                                                                                                                                ),
                                                                                                                                                                            },
                                                                                                                                                                        },
                                                                                                                                                                    ),
                                                                                                                                                                    debug_text: None,
                                                                                                                                                                    conversion: None,
                                                                                                                                                                    format_spec: None,
                                                                                                                                                                },
                                                                                                                                                            ),
                                                                                                                                                        ],
                                                                                                                                                        flags: FStringFlags {
                                                                                                                                                            quote_style: Double,
                                                                                                                                                            prefix: Regular,
                                                                                                                                                            triple_quoted: false,
                                                                                                                                                            unclosed: false,
                                                                                                                                                        },
                                                                                                                                                    },
                                                                                                                                                ),
                                                                                                                                            ),
                                                                                                                                        },
                                                                                                                                    },
                                                                                                                                ),
                                                                                                                                debug_text: None,
                                                                                                                                conversion: None,
                                                                                                                                format_spec: None,
                                                                                                                            },
                                                                                                                        ),
                                                                                                                    ],
                                                                                                                    flags: FStringFlags {
                                                                                                                        quote_style: Double,
                                                                                                                        prefix: Regular,
                                                                                                                        triple_quoted: false,
                                                                                                                        unclosed: false,
                                                                                                                    },
                                                                                                                },
                                                                                                            ),
                                                                                                        ),
                                                                                                    },
                                                                                                },
                                                                                            ),
                                                                                            debug_text: None,
                                                                                            conversion: None,
                                                                                            format_spec: None,
                                                                                        },
                                                                                    ),
                                                                                ],
                                                                                flags: FStringFlags {
                                                                                    quote_style: Double,
                                                                                    prefix: Regular,
                                                                                    triple_quoted: false,
                                                                                    unclosed: false,
                                                                                },
                                                                            },
                                                                        ),
                                                                    ),
                                                                },
                                                            },
                                                        ),
                                                        debug_text: None,
                                                        conversion: None,
                                                        format_spec: None,
                                                    },
                                                ),
                                            ],
                                            flags: FStringFlags {
                                                quote_style: Double,
                                                prefix: Regular,
                                                triple_quoted: false,
                                                unclosed: false,
                                            },
                                        },
                                    ),
                                ),
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: NodeIndex(None),
                    range: 276..310,
                    value: FString(
                        ExprFString {
                            node_index: NodeIndex(None),
                            range: 276..310,
                            value: FStringValue {
                                inner: Single(
                                    FString(
                                        FString {
                                            range: 276..310,
                                            node_index: NodeIndex(None),
                                            elements: [
                                                Interpolation(
                                                    InterpolatedElement {
                                                        range: 278..303,
                                                        node_index: NodeIndex(None),
                                                        expression: FString(
                                                            ExprFString {
                                                                node_index: NodeIndex(None),
                                                                range: 279..302,
                                                                value: FStringValue {
                                                                    inner: Single(
                                                                        FString(
                                                                            FString {
                                                                                range: 279..302,
                                                                                node_index: NodeIndex(None),
                                                                                elements: [
                                                                                    Interpolation(
                                                                                        InterpolatedElement {
                                                                                            range: 283..293,
                                                                                            node_index: NodeIndex(None),
                                                                                            expression: StringLiteral(
                                                                                                ExprStringLiteral {
                                                                                                    node_index: NodeIndex(None),
                                                                                                    range: 284..292,
                                                                                                    value: StringLiteralValue {
                                                                                                        inner: Single(
                                                                                                            StringLiteral {
                                                                                                                range: 284..292,
                                                                                                                node_index: NodeIndex(None),
                                                                                                                value: "nested",
                                                                                                                flags: StringLiteralFlags {
                                                                                                                    quote_style: Double,
                                                                                                                    prefix: Empty,
                                                                                                                    triple_quoted: false,
                                                                                                                    unclosed: false,
                                                                                                                },
                                                                                                            },
                                                                                                        ),
                                                                                                    },
                                                                                                },
                                                                                            ),
                                                                                            debug_text: None,
                                                                                            conversion: None,
                                                                                            format_spec: None,
                                                                                        },
                                                                                    ),
                                                                                    Literal(
                                                                                        InterpolatedStringLiteralElement {
                                                                                            range: 293..299,
                                                                                            node_index: NodeIndex(None),
                                                                                            value: " inner",
                                                                                        },
                                                                                    ),
                                                                                ],
                                                                                flags: FStringFlags {
                                                                                    quote_style: Single,
                                                                                    prefix: Regular,
                                                                                    triple_quoted: true,
                                                                                    unclosed: false,
                                                                                },
                                                                            },
                                                                        ),
                                                                    ),
                                                                },
                                                            },
                                                        ),
                                                        debug_text: None,
                                                        conversion: None,
                                                        format_spec: None,
                                                    },
                                                ),
                                                Literal(
                                                    InterpolatedStringLiteralElement {
                                                        range: 303..309,
                                                        node_index: NodeIndex(None),
                                                        value: " outer",
                                                    },
                                                ),
                                            ],
                                            flags: FStringFlags {
                                                quote_style: Double,
                                                prefix: Regular,
                                                triple_quoted: false,
                                                unclosed: false,
                                            },
                                        },
                                    ),
                                ),
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: NodeIndex(None),
                    range: 336..359,
                    value: FString(
                        ExprFString {
                            node_index: NodeIndex(None),
                            range: 336..359,
                            value: FStringValue {
                                inner: Single(
                                    FString(
                                        FString {
                                            range: 336..359,
                                            node_index: NodeIndex(None),
                                            elements: [
                                                Literal(
                                                    InterpolatedStringLiteralElement {
                                                        range: 338..343,
                                                        node_index: NodeIndex(None),
                                                        value: "test ",
                                                    },
                                                ),
                                                Interpolation(
                                                    InterpolatedElement {
                                                        range: 343..353,
                                                        node_index: NodeIndex(None),
                                                        expression: Name(
                                                            ExprName {
                                                                node_index: NodeIndex(None),
                                                                range: 344..345,
                                                                id: Name("a"),
                                                                ctx: Load,
                                                            },
                                                        ),
                                                        debug_text: None,
                                                        conversion: None,
                                                        format_spec: None,
                                                    },
                                                ),
                                                Literal(
                                                    InterpolatedStringLiteralElement {
                                                        range: 353..358,
                                                        node_index: NodeIndex(None),
                                                        value: " more",
                                                    },
                                                ),
                                            ],
                                            flags: FStringFlags {
                                                quote_style: Double,
                                                prefix: Regular,
                                                triple_quoted: false,
                                                unclosed: false,
                                            },
                                        },
                                    ),
                                ),
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: NodeIndex(None),
                    range: 403..422,
                    value: FString(
                        ExprFString {
                            node_index: NodeIndex(None),
                            range: 403..422,
                            value: FStringValue {
                                inner: Single(
                                    FString(
                                        FString {
                                            range: 403..422,
                                            node_index: NodeIndex(None),
                                            elements: [
                                                Interpolation(
                                                    InterpolatedElement {
                                                        range: 407..419,
                                                        node_index: NodeIndex(None),
                                                        expression: FString(
                                                            ExprFString {
                                                                node_index: NodeIndex(None),
                                                                range: 408..418,
                                                                value: FStringValue {
                                                                    inner: Single(
                                                                        FString(
                                                                            FString {
                                                                                range: 408..418,
                                                                                node_index: NodeIndex(None),
                                                                                elements: [
                                                                                    Interpolation(
                                                                                        InterpolatedElement {
                                                                                            range: 412..415,
                                                                                            node_index: NodeIndex(None),
                                                                                            expression: Name(
                                                                                                ExprName {
                                                                                                    node_index: NodeIndex(None),
                                                                                                    range: 413..414,
                                                                                                    id: Name("x"),
                                                                                                    ctx: Load,
                                                                                                },
                                                                                            ),
                                                                                            debug_text: None,
                                                                                            conversion: None,
                                                                                            format_spec: None,
                                                                                        },
                                                                                    ),
                                                                                ],
                                                                                flags: FStringFlags {
                                                                                    quote_style: Double,
                                                                                    prefix: Regular,
                                                                                    triple_quoted: true,
                                                                                    unclosed: false,
                                                                                },
                                                                            },
                                                                        ),
                                                                    ),
                                                                },
                                                            },
                                                        ),
                                                        debug_text: None,
                                                        conversion: None,
                                                        format_spec: None,
                                                    },
                                                ),
                                            ],
                                            flags: FStringFlags {
                                                quote_style: Double,
                                                prefix: Regular,
                                                triple_quoted: true,
                                                unclosed: false,
                                            },
                                        },
                                    ),
                                ),
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: NodeIndex(None),
                    range: 468..502,
                    value: FString(
                        ExprFString {
                            node_index: NodeIndex(None),
                            range: 468..502,
                            value: FStringValue {
                                inner: Single(
                                    FString(
                                        FString {
                                            range: 468..502,
                                            node_index: NodeIndex(None),
                                            elements: [
                                                Interpolation(
                                                    InterpolatedElement {
                                                        range: 470..501,
                                                        node_index: NodeIndex(None),
                                                        expression: Call(
                                                            ExprCall {
                                                                node_index: NodeIndex(None),
                                                                range: 471..500,
                                                                func: Attribute(
                                                                    ExprAttribute {
                                                                        node_index: NodeIndex(None),
                                                                        range: 471..480,
                                                                        value: StringLiteral(
                                                                            ExprStringLiteral {
                                                                                node_index: NodeIndex(None),
                                                                                range: 471..475,
                                                                                value: StringLiteralValue {
                                                                                    inner: Single(
                                                                                        StringLiteral {
                                                                                            range: 471..475,
                                                                                            node_index: NodeIndex(None),
                                                                                            value: "\n",
                                                                                            flags: StringLiteralFlags {
                                                                                                quote_style: Single,
                                                                                                prefix: Empty,
                                                                                                triple_quoted: false,
                                                                                                unclosed: false,
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            },
                                                                        ),
                                                                        attr: Identifier {
                                                                            id: Name("join"),
                                                                            range: 476..480,
                                                                            node_index: NodeIndex(None),
                                                                        },
                                                                        ctx: Load,
                                                                    },
                                                                ),
                                                                arguments: Arguments {
                                                                    range: 480..500,
                                                                    node_index: NodeIndex(None),
                                                                    args: [
                                                                        List(
                                                                            ExprList {
                                                                                node_index: NodeIndex(None),
                                                                                range: 481..499,
                                                                                elts: [
                                                                                    StringLiteral(
                                                                                        ExprStringLiteral {
                                                                                            node_index: NodeIndex(None),
                                                                                            range: 482..486,
                                                                                            value: StringLiteralValue {
                                                                                                inner: Single(
                                                                                                    StringLiteral {
                                                                                                        range: 482..486,
                                                                                                        node_index: NodeIndex(None),
                                                                                                        value: "\t",
                                                                                                        flags: StringLiteralFlags {
                                                                                                            quote_style: Single,
                                                                                                            prefix: Empty,
                                                                                                            triple_quoted: false,
                                                                                                            unclosed: false,
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                    StringLiteral(
                                                                                        ExprStringLiteral {
                                                                                            node_index: NodeIndex(None),
                                                                                            range: 488..492,
                                                                                            value: StringLiteralValue {
                                                                                                inner: Single(
                                                                                                    StringLiteral {
                                                                                                        range: 488..492,
                                                                                                        node_index: NodeIndex(None),
                                                                                                        value: "\u{b}",
                                                                                                        flags: StringLiteralFlags {
                                                                                                            quote_style: Single,
                                                                                                            prefix: Empty,
                                                                                                            triple_quoted: false,
                                                                                                            unclosed: false,
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                    StringLiteral(
                                                                                        ExprStringLiteral {
                                                                                            node_index: NodeIndex(None),
                                                                                            range: 494..498,
                                                                                            value: StringLiteralValue {
                                                                                                inner: Single(
                                                                                                    StringLiteral {
                                                                                                        range: 494..498,
                                                                                                        node_index: NodeIndex(None),
                                                                                                        value: "\r",
                                                                                                        flags: StringLiteralFlags {
                                                                                                            quote_style: Single,
                                                                                                            prefix: Empty,
                                                                                                            triple_quoted: false,
                                                                                                            unclosed: false,
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                ],
                                                                                ctx: Load,
                                                                            },
                                                                        ),
                                                                    ],
                                                                    keywords: [],
                                                                },
                                                            },
                                                        ),
                                                        debug_text: None,
                                                        conversion: None,
                                                        format_spec: None,
                                                    },
                                                ),
                                            ],
                                            flags: FStringFlags {
                                                quote_style: Double,
                                                prefix: Regular,
                                                triple_quoted: false,
                                                unclosed: false,
                                            },
                                        },
                                    ),
                                ),
                            },
                        },
                    ),
                },
            ),
        ],
    },
)
```
## Unsupported Syntax Errors

  |
1 | # parse_options: {"target-version": "3.11"}
2 | f'Magic wand: { bag['wand'] }'     # nested quotes
  |                     ^ Syntax Error: Cannot reuse outer quote character in f-strings on Python 3.11 (syntax was added in Python 3.12)
3 | f"{'\n'.join(a)}"                  # escape sequence
4 | f'''A complex trick: {
  |


  |
1 | # parse_options: {"target-version": "3.11"}
2 | f'Magic wand: { bag['wand'] }'     # nested quotes
3 | f"{'\n'.join(a)}"                  # escape sequence
  |     ^ Syntax Error: Cannot use an escape sequence (backslash) in f-strings on Python 3.11 (syntax was added in Python 3.12)
4 | f'''A complex trick: {
5 |     bag['bag']                     # comment
  |


  |
3 | f"{'\n'.join(a)}"                  # escape sequence
4 | f'''A complex trick: {
5 |     bag['bag']                     # comment
  |                                    ^^^^^^^^^ Syntax Error: Cannot use comments in f-strings on Python 3.11 (syntax was added in Python 3.12)
6 | }'''
7 | f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"  # arbitrary nesting
  |


  |
5 |     bag['bag']                     # comment
6 | }'''
7 | f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"  # arbitrary nesting
  |                 ^ Syntax Error: Cannot reuse outer quote character in f-strings on Python 3.11 (syntax was added in Python 3.12)
8 | f"{f'''{"nested"} inner'''} outer" # nested (triple) quotes
9 | f"test {a \
  |


  |
5 |     bag['bag']                     # comment
6 | }'''
7 | f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"  # arbitrary nesting
  |              ^ Syntax Error: Cannot reuse outer quote character in f-strings on Python 3.11 (syntax was added in Python 3.12)
8 | f"{f'''{"nested"} inner'''} outer" # nested (triple) quotes
9 | f"test {a \
  |


  |
5 |     bag['bag']                     # comment
6 | }'''
7 | f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"  # arbitrary nesting
  |           ^ Syntax Error: Cannot reuse outer quote character in f-strings on Python 3.11 (syntax was added in Python 3.12)
8 | f"{f'''{"nested"} inner'''} outer" # nested (triple) quotes
9 | f"test {a \
  |


  |
5 |     bag['bag']                     # comment
6 | }'''
7 | f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"  # arbitrary nesting
  |        ^ Syntax Error: Cannot reuse outer quote character in f-strings on Python 3.11 (syntax was added in Python 3.12)
8 | f"{f'''{"nested"} inner'''} outer" # nested (triple) quotes
9 | f"test {a \
  |


  |
5 |     bag['bag']                     # comment
6 | }'''
7 | f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"  # arbitrary nesting
  |     ^ Syntax Error: Cannot reuse outer quote character in f-strings on Python 3.11 (syntax was added in Python 3.12)
8 | f"{f'''{"nested"} inner'''} outer" # nested (triple) quotes
9 | f"test {a \
  |


   |
 6 | }'''
 7 | f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"  # arbitrary nesting
 8 | f"{f'''{"nested"} inner'''} outer" # nested (triple) quotes
   |         ^ Syntax Error: Cannot reuse outer quote character in f-strings on Python 3.11 (syntax was added in Python 3.12)
 9 | f"test {a \
10 |     } more"                        # line continuation
   |


   |
 7 | f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"  # arbitrary nesting
 8 | f"{f'''{"nested"} inner'''} outer" # nested (triple) quotes
 9 | f"test {a \
   |           ^ Syntax Error: Cannot use an escape sequence (backslash) in f-strings on Python 3.11 (syntax was added in Python 3.12)
10 |     } more"                        # line continuation
11 | f"""{f"""{x}"""}"""                # mark the whole triple quote
   |


   |
 9 | f"test {a \
10 |     } more"                        # line continuation
11 | f"""{f"""{x}"""}"""                # mark the whole triple quote
   |       ^^^ Syntax Error: Cannot reuse outer quote character in f-strings on Python 3.11 (syntax was added in Python 3.12)
12 | f"{'\n'.join(['\t', '\v', '\r'])}"  # multiple escape sequences, multiple errors
   |


   |
10 |     } more"                        # line continuation
11 | f"""{f"""{x}"""}"""                # mark the whole triple quote
12 | f"{'\n'.join(['\t', '\v', '\r'])}"  # multiple escape sequences, multiple errors
   |     ^ Syntax Error: Cannot use an escape sequence (backslash) in f-strings on Python 3.11 (syntax was added in Python 3.12)
   |


   |
10 |     } more"                        # line continuation
11 | f"""{f"""{x}"""}"""                # mark the whole triple quote
12 | f"{'\n'.join(['\t', '\v', '\r'])}"  # multiple escape sequences, multiple errors
   |                ^ Syntax Error: Cannot use an escape sequence (backslash) in f-strings on Python 3.11 (syntax was added in Python 3.12)
   |


   |
10 |     } more"                        # line continuation
11 | f"""{f"""{x}"""}"""                # mark the whole triple quote
12 | f"{'\n'.join(['\t', '\v', '\r'])}"  # multiple escape sequences, multiple errors
   |                      ^ Syntax Error: Cannot use an escape sequence (backslash) in f-strings on Python 3.11 (syntax was added in Python 3.12)
   |


   |
10 |     } more"                        # line continuation
11 | f"""{f"""{x}"""}"""                # mark the whole triple quote
12 | f"{'\n'.join(['\t', '\v', '\r'])}"  # multiple escape sequences, multiple errors
   |                            ^ Syntax Error: Cannot use an escape sequence (backslash) in f-strings on Python 3.11 (syntax was added in Python 3.12)
   |