Actionable comments posted: 1

crates/codegen/src/compile.rs (1)

8271-8283: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Extract key once and reuse it in this dict-comp path.

key.as_ref().expect(...) is repeated several times in the same flow. Bind it once and reuse it for compile/await/range operations.

Proposed refactor

+                    let key = key
+                        .as_ref()
+                        .expect("RustPython does not support PEP798 yet");
                     generators,
                     &|compiler, collection_add_i| {
                         // changed evaluation order for Py38 named expression PEP 572
-                        compiler.compile_expression(
-                            &key.as_ref()
-                                .expect("RustPython does not support PEP798 yet"),
-                        )?;
+                        compiler.compile_expression(key)?;
                         compiler.compile_expression(value)?;
 
                         compiler.set_source_range(TextRange::new(
-                            key.as_ref()
-                                .expect("RustPython does not support PEP798 yet")
-                                .range()
-                                .start(),
+                            key.range().start(),
                             value.range().end(),
                         ));
@@
-                    Self::contains_await(
-                        &key.as_ref()
-                            .expect("RustPython does not support PEP798 yet"),
-                    ) || Self::contains_await(value)
+                    Self::contains_await(key) || Self::contains_await(value)
                         || Self::generators_contain_await(generators),
                     *range,
                     TextRange::new(
-                        key.as_ref()
-                            .expect("RustPython does not support PEP798 yet")
-                            .range()
-                            .start(),
+                        key.range().start(),
                         value.range().end(),
                     ),
-                    key.as_ref()
-                        .expect("RustPython does not support PEP798 yet")
-                        .range(),
+                    key.range(),
                 )?;

As per coding guidelines, when logic is shared, extract the differing value first and call the common logic once to avoid duplication.

Also applies to: 8294-8309

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/codegen/src/compile.rs` around lines 8271 - 8283, The dict-comp
handling in compile.rs repeats key.as_ref().expect(...) multiple times; extract
that value once in the affected flow and reuse it for compile_expression, any
await handling, and source-range calculation. Update the dict-comp path around
the existing compiler.compile_expression and compiler.set_source_range calls,
and apply the same refactor to the other referenced block so the shared logic
uses a single bound key value instead of duplicated expectations.

Source: Coding guidelines

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@crates/codegen/src/unparse.rs`:
- Around line 256-260: The call in unparse_expr for the key handling path has a
redundant leading borrow that triggers a needless_borrow warning. Update the
expression in unparse.rs around the self.unparse_expr call so it passes the
reference returned by key.as_ref().expect("RustPython does not support PEP798
yet") directly, without adding an extra &.

---

Nitpick comments:
In `@crates/codegen/src/compile.rs`:
- Around line 8271-8283: The dict-comp handling in compile.rs repeats
key.as_ref().expect(...) multiple times; extract that value once in the affected
flow and reuse it for compile_expression, any await handling, and source-range
calculation. Update the dict-comp path around the existing
compiler.compile_expression and compiler.set_source_range calls, and apply the
same refactor to the other referenced block so the shared logic uses a single
bound key value instead of duplicated expectations.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Configuration used: Path: .coderabbit.yml

Review profile: CHILL

Plan: Pro

Run ID: e4cf7347-2742-4018-9f90-8b6b99d09026

Reviewing files that changed from the base of the PR and between 39a2fda and a0690de.

• Cargo.lock is excluded by !**/*.lock
• Lib/test/test_grammar.py is excluded by !Lib/**
• Lib/test/test_syntax.py is excluded by !Lib/**

• .github/dependabot.yml
• Cargo.toml
• crates/codegen/src/compile.rs
• crates/codegen/src/symboltable.rs
• crates/codegen/src/unparse.rs
• crates/vm/Cargo.toml
• crates/vm/src/stdlib/_ast.rs
• crates/vm/src/stdlib/_ast/argument.rs
• crates/vm/src/stdlib/_ast/constant.rs
• crates/vm/src/stdlib/_ast/elif_else_clause.rs
• crates/vm/src/stdlib/_ast/module.rs
• crates/vm/src/stdlib/_ast/node.rs
• crates/vm/src/stdlib/_ast/parameter.rs
• crates/vm/src/stdlib/_ast/pattern.rs
• crates/vm/src/stdlib/_ast/string.rs
• crates/vm/src/stdlib/_ast/validate.rs