Raise ValueError for None in Expr lists to match CPython validator - #7656

Fix all unresolved CodeRabbit comments on this PR:

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

crates/vm/src/stdlib/_ast/expression.rs (1)

136-137: ⚠️ Potential issue | 🟠 Major

Keep the None check scoped to expression-list elements.

This generic dispatcher is also used for required single-expression fields, so Lambda(body=None), Call(func=None), etc. can now receive the list-specific "None disallowed in expression list" error instead of CPython’s field-specific validation error. Move this handling into the expression-sequence conversion path, or pass enough context to distinguish list elements from required fields.

#!/bin/bash
set -euo pipefail

# Compare CPython's behavior for list-element None vs required single-expression None.
python3 - <<'PY'
import ast

args = ast.arguments(
    posonlyargs=[],
    args=[],
    vararg=None,
    kwonlyargs=[],
    kw_defaults=[],
    kwarg=None,
    defaults=[],
)

cases = [
    ("list element None", ast.Expression(body=ast.List(elts=[None], ctx=ast.Load()))),
    ("lambda body None", ast.Expression(body=ast.Lambda(args=args, body=None))),
    ("call func None", ast.Expression(body=ast.Call(func=None, args=[], keywords=[]))),
]

for name, tree in cases:
    try:
        compile(ast.fix_missing_locations(tree), "<ast>", "eval")
    except Exception as exc:
        print(f"{name}: {type(exc).__name__}: {exc}")
    else:
        print(f"{name}: OK")
PY

# Inspect required single-expression call sites that route through ast::Expr::ast_from_object.
rg -n -C2 'get_node_field\(vm, &object, "(body|test|func|value|left|right|target|iter|slice|elt|key)"' crates/vm/src/stdlib/_ast/expression.rs

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/vm/src/stdlib/_ast/expression.rs` around lines 136 - 137, Remove the
generic vm.is_none(&object) check and error return from the shared expression
dispatcher (the code that emits vm.new_value_error("None disallowed in
expression list")), and instead enforce "None disallowed in expression list"
only inside the expression-sequence conversion path (the code that converts AST
list elements to Expr nodes); leave required single-expression sites (e.g.,
Lambda.body, Call.func, etc., which route through ast::Expr::ast_from_object /
get_node_field calls) to use their field-specific validation. Concretely: delete
or conditionally bypass the vm.is_none check in the shared dispatcher and add
the None-check + vm.new_value_error(...) inside the function that converts
Vec<Expr> or list elements to expressions (or pass an explicit flag/context from
callers to distinguish "list element" vs "single required field"), so list
elements trigger the list-specific error while single-expression fields keep
their original validation.