parser: parsing doublestar as a power op without a left hand side

[11happy]

Summary

Parses ** Doublestar as power op without lhs, Part of #10653, referred discussion #10636 (comment)

Test Plan

test case :

{x: **y for x, y in data}

ruff-dev output before:

Error: Expected an expression at byte range 4..6

Caused by:
    Expected an expression

ruff-dev output ast after:

Module(
    ModModule {
        node_index: NodeIndex(None),
        range: 0..25,
        body: [
            Expr(
                StmtExpr {
                    node_index: NodeIndex(None),
                    range: 0..25,
                    value: DictComp(
                        ExprDictComp {
                            node_index: NodeIndex(None),
                            range: 0..25,
                            key: Name(
                                ExprName {
                                    node_index: NodeIndex(None),
                                    range: 1..2,
                                    id: Name("x"),
                                    ctx: Load,
                                },
                            ),
                            value: BinOp(
                                ExprBinOp {
                                    node_index: NodeIndex(None),
                                    range: 4..7,
                                    left: Name(
                                        ExprName {
                                            node_index: NodeIndex(None),
                                            range: 7..7,
                                            id: Name(""),
                                            ctx: Invalid,
                                        },
                                    ),
                                    op: Pow,
                                    right: Name(
                                        ExprName {
                                            node_index: NodeIndex(None),
                                            range: 6..7,
                                            id: Name("y"),
                                            ctx: Load,
                                        },
                                    ),
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 8..24,
                                    node_index: NodeIndex(None),
                                    target: Tuple(
                                        ExprTuple {
                                            node_index: NodeIndex(None),
                                            range: 12..16,
                                            elts: [
                                                Name(
                                                    ExprName {
                                                        node_index: NodeIndex(None),
                                                        range: 12..13,
                                                        id: Name("x"),
                                                        ctx: Store,
                                                    },
                                                ),
                                                Name(
                                                    ExprName {
                                                        node_index: NodeIndex(None),
                                                        range: 15..16,
                                                        id: Name("y"),
                                                        ctx: Store,
                                                    },
                                                ),
                                            ],
                                            ctx: Store,
                                            parenthesized: false,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: NodeIndex(None),
                                            range: 20..24,
                                            id: Name("data"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
        ],
    },
)

[astral-sh-bot]

ruff-ecosystem results

Linter (stable)

ℹ️ ecosystem check detected linter changes. (+1 -0 violations, +0 -0 fixes in 1 projects; 54 projects unchanged)

apache/superset (+1 -0 violations, +0 -0 fixes)

ruff check --no-cache --exit-zero --no-fix --output-format concise --no-preview --select ALL

+ superset/config.py:262:1: ERA001 Found commented-out code

Changes by rule (1 rules affected)

code	total	+ violation	- violation	+ fix	- fix
ERA001	1	1	0	0	0

Linter (preview)

ℹ️ ecosystem check detected linter changes. (+1 -0 violations, +0 -0 fixes in 1 projects; 54 projects unchanged)

apache/superset (+1 -0 violations, +0 -0 fixes)

ruff check --no-cache --exit-zero --no-fix --output-format concise --preview --select ALL

+ superset/config.py:262:1: ERA001 Found commented-out code

Changes by rule (1 rules affected)

code	total	+ violation	- violation	+ fix	- fix
ERA001	1	1	0	0	0

Formatter (stable)

✅ ecosystem check detected no format changes.

Formatter (preview)

✅ ecosystem check detected no format changes.

[MichaReiser]

Would you mind adding a few parser tests that demonstrate that the new recovery logic works as expected?

E.g., the ecosystem changes suggest that we:

a) Fail to emit a diagnostic in that case
b) or we now use this code path for **kwargs when we shouldn't

[11happy]

Would you mind adding a few parser tests that demonstrate that the new recovery logic works as expected?

E.g., the ecosystem changes suggest that we:

a) Fail to emit a diagnostic in that case
b) or we now use this code path for **kwargs when we shouldn't

I have added tests & I think its not the option b, I would appreciate any pointers to move forward

[MichaReiser]

Would you mind changing your PR to use the testing infrastructure described here

ruff/crates/ruff_python_parser/CONTRIBUTING.md

Line 5 in f7bd94b

### Inline tests

Can you also add an example where there's some content to the right, e.g. ** a + 3 * 2

[MichaReiser]

I'm not sure if this is the right place for the fix. Would it be possible to add it to parse_binary_expression_or_higher or even in parse_binary_expression_or_higher_recursive? If not, can you explain why?

Moving it their would give you the diagnostic for free