crates/jit/tests/common.rs (1)

94-113: Fail fast on unsupported annotation values (still silently dropped).

This still skips invalid annotation values by returning None, which leads to a later generic panic. Please fail fast with a targeted error to surface malformed annotate bytecode immediately.

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

2181-2208: Treat ExpressionContext::Iter as a binding for __debug__.
Comprehension/loop targets use Iter; those should be rejected just like Store.

🛠️ Proposed fix

-            match context {
-                ExpressionContext::Store => {
+            match context {
+                ExpressionContext::Store | ExpressionContext::Iter => {
                     return Err(SymbolTableError {
                         error: "cannot assign to __debug__".to_owned(),
                         location,
                     });
                 }

Is "for __debug__ in iterable:" a SyntaxError in Python (i.e., is __debug__ forbidden as an iteration target)?

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

2181-2225: debug can still slip through pattern-capture bindings.

Now that register_name no longer enforces the forbidden-name rule, pattern captures (MatchAs, MatchStar, mapping rest) still call register_ident without check_name. That allows __debug__ to be bound via pattern matching, which should be rejected.

Please add check_name(..., ExpressionContext::Store, ...) before those register_ident calls.

🔧 Proposed fix

 fn scan_pattern(&mut self, pattern: &Pattern) -> SymbolTableResult {
     use Pattern::*;
     match pattern {
         MatchMapping(PatternMatchMapping { keys, patterns, rest, .. }) => {
             self.scan_expressions(keys, ExpressionContext::Load)?;
             self.scan_patterns(patterns)?;
             if let Some(rest) = rest {
+                self.check_name(rest.as_str(), ExpressionContext::Store, rest.range)?;
                 self.register_ident(rest, SymbolUsage::Assigned)?;
             }
         }
         MatchStar(PatternMatchStar { name, .. }) => {
             if let Some(name) = name {
+                self.check_name(name.as_str(), ExpressionContext::Store, name.range)?;
                 self.register_ident(name, SymbolUsage::Assigned)?;
             }
         }
         MatchAs(PatternMatchAs { pattern, name, .. }) => {
             if let Some(pattern) = pattern {
                 self.scan_pattern(pattern)?;
             }
             if let Some(name) = name {
+                self.check_name(name.as_str(), ExpressionContext::Store, name.range)?;
                 self.register_ident(name, SymbolUsage::Assigned)?;
             }
         }
         MatchOr(PatternMatchOr { patterns, .. }) => self.scan_patterns(patterns)?,
     }
     Ok(())
 }

crates/jit/tests/common.rs (1)

95-144: Warn-and-skip still hides malformed annotations.

The new warnings still drop malformed entries, which later causes a generic “Argument have annotation” panic. Prefer failing fast here with an explicit panic/error that includes the offending index/type.

🔧 Proposed fix

-                                match code.constants.get(val_idx) {
-                                    Some(ConstantData::Str { value }) => {
-                                        Some(value.as_str().map(|s| s.to_owned()).unwrap_or_else(
-                                            |_| value.to_string_lossy().into_owned(),
-                                        ))
-                                    }
-                                    Some(other) => {
-                                        eprintln!(
-                                            "Warning: Malformed annotation for '{:?}': expected string constant at index {}, got {:?}",
-                                            param_name, val_idx, other
-                                        );
-                                        None
-                                    }
-                                    None => {
-                                        eprintln!(
-                                            "Warning: Malformed annotation for '{:?}': constant index {} out of bounds (len={})",
-                                            param_name,
-                                            val_idx,
-                                            code.constants.len()
-                                        );
-                                        None
-                                    }
-                                }
+                                match code.constants.get(val_idx) {
+                                    Some(ConstantData::Str { value }) => Some(
+                                        value
+                                            .as_str()
+                                            .map(|s| s.to_owned())
+                                            .unwrap_or_else(|_| value.to_string_lossy().into_owned()),
+                                    ),
+                                    Some(other) => panic!(
+                                        "Unsupported annotation const for '{:?}' at idx {}: {:?}",
+                                        param_name, val_idx, other
+                                    ),
+                                    None => panic!(
+                                        "Annotation const idx out of bounds for '{:?}': {} (len={})",
+                                        param_name, val_idx, code.constants.len()
+                                    ),
+                                }
                             } else {
                                 match code.names.get(val_idx) {
-                                    Some(name) => Some(name.clone()),
-                                    None => {
-                                        eprintln!(
-                                            "Warning: Malformed annotation for '{}': name index {} out of bounds (len={})",
-                                            param_name,
-                                            val_idx,
-                                            code.names.len()
-                                        );
-                                        None
-                                    }
+                                    Some(name) => Some(name.clone()),
+                                    None => panic!(
+                                        "Annotation name idx out of bounds for '{:?}': {} (len={})",
+                                        param_name, val_idx, code.names.len()
+                                    ),
                                 }
                             };

crates/compiler-core/src/marshal.rs (1)

471-476: Consider a distinct error for unsupported Slice constants.

Returning BadType hides the difference between “unknown marker” vs “known but unsupported.” A dedicated error improves diagnostics and feature‑gating.

💡 Possible refactor

 pub enum MarshalError {
     /// Unexpected End Of File
     Eof,
     /// Invalid Bytecode
     InvalidBytecode,
     /// Invalid utf8 in string
     InvalidUtf8,
     /// Invalid source location
     InvalidLocation,
     /// Bad type marker
     BadType,
+    /// Known type marker that RustPython does not yet support
+    UnsupportedType(u8),
 }
 
 impl core::fmt::Display for MarshalError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::Eof => f.write_str("unexpected end of data"),
             Self::InvalidBytecode => f.write_str("invalid bytecode"),
             Self::InvalidUtf8 => f.write_str("invalid utf8"),
             Self::InvalidLocation => f.write_str("invalid source location"),
             Self::BadType => f.write_str("bad type marker"),
+            Self::UnsupportedType(marker) => write!(f, "unsupported type marker: {marker:`#x`}"),
         }
     }
 }
 
         Type::Slice => {
             // Slice constants are not yet supported in RustPython
             // This would require adding a Slice variant to ConstantData enum
             // For now, return an error if we encounter a slice in marshal data
-            return Err(MarshalError::BadType);
+            return Err(MarshalError::UnsupportedType(Type::Slice as u8));
         }