tmp

arihant2math · arihant2math · commit 5aa2f3df4681 · 2025-03-27T15:27:04.000Z
diff --git a/compiler/codegen/src/compile.rs b/compiler/codegen/src/compile.rs
@@ -15,14 +15,13 @@ use malachite_bigint::BigInt;
 use num_complex::Complex;
 use num_traits::{Num, ToPrimitive};
 use ruff_python_ast::{
-    Alias, Arguments, BoolOp, CmpOp, Comprehension, ConversionFlag, DebugText, Decorator, DictItem, ExceptHandler, ExceptHandlerExceptHandler, Expr, ExprAttribute, ExprBoolOp, ExprFString, ExprList, ExprName, ExprStarred, ExprSubscript, ExprTuple, ExprUnaryOp, FString, FStringElement, FStringElements, FStringPart, Identifier, Int, Keyword, MatchCase, ModExpression, ModModule, Operator, Parameters, Pattern, PatternMatchAs, PatternMatchOr, PatternMatchSingleton, PatternMatchStar, PatternMatchValue, Singleton, Stmt, StmtExpr, TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, TypeParams, UnaryOp, WithItem
+    Alias, Arguments, BoolOp, CmpOp, Comprehension, ConversionFlag, DebugText, Decorator, DictItem, ExceptHandler, ExceptHandlerExceptHandler, Expr, ExprAttribute, ExprBoolOp, ExprFString, ExprList, ExprName, ExprStarred, ExprSubscript, ExprTuple, ExprUnaryOp, FString, FStringElement, FStringElements, FStringPart, Identifier, Int, Keyword, MatchCase, ModExpression, ModModule, Operator, Parameters, Pattern, PatternMatchAs, PatternMatchOr, PatternMatchSequence, PatternMatchSingleton, PatternMatchStar, PatternMatchValue, Singleton, Stmt, StmtExpr, TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, TypeParams, UnaryOp, WithItem
 };
 use ruff_source_file::OneIndexed;
 use ruff_text_size::{Ranged, TextRange};
 // use rustpython_ast::located::{self as located_ast, Located};
 use rustpython_compiler_core::{
-    Mode,
-    bytecode::{self, Arg as OpArgMarker, CodeObject, ConstantData, Instruction, OpArg, OpArgType},
+    bytecode::{self, Arg as OpArgMarker, CodeObject, ComparisonOperator, ConstantData, Instruction, OpArg, OpArgType}, Mode
 };
 use rustpython_compiler_source::SourceCode;
 // use rustpython_parser_core::source_code::{LineNumber, SourceLocation};
@@ -1954,6 +1953,49 @@ impl Compiler<'_> {
         Ok(())
     }
 
+    fn pattern_helper_sequence_subscr(
+        &mut self,
+        patterns: &[Pattern],
+        star: usize,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // Keep the subject around for extracting elements.
+        pc.on_top += 1;
+        let size = patterns.len();
+        for i in 0..size {
+            let pattern = &patterns[i];
+            // if pattern.is_wildcard() {
+                // continue;
+            // }
+            if i == star {
+                // This must be a starred wildcard.
+                // assert!(pattern.is_star_wildcard());
+                continue;
+            }
+            // Duplicate the subject.
+            emit!(self, Instruction::CopyItem { index: 1 as u32 });
+            if i < star {
+                // For indices before the star, use a nonnegative index equal to i.
+                self.emit_load_const(ConstantData::Integer { value: i.into() });
+            } else {
+                // For indices after the star, compute a nonnegative index:
+                // index = len(subject) - (size - i)
+                emit!(self, Instruction::GET_LEN);
+                emit!(self, Instruction::LoadConstNew { arg: PyObject::from_ssize_t((size - i) as isize) });
+                // Subtract to compute the correct index.
+                emit!(self, Instruction::BINARY { arg: BinaryOp::Sub });
+            }
+            // Use BINARY_OP/NB_SUBSCR to extract the element.
+            emit!(self, Instruction::BINARY_OP { arg: NB_SUBSCR });
+            // Compile the subpattern in irrefutable mode.
+            self.compiler_pattern_subpattern(pattern, pc)?;
+        }
+        // Pop the subject off the stack.
+        pc.on_top = pc.on_top.saturating_sub(1);
+        emit!(self, Instruction::POP_TOP);
+        Ok(())
+    }
+
     fn compile_pattern_subpattern(
         &mut self,
         p: &Pattern,
@@ -2145,6 +2187,63 @@ impl Compiler<'_> {
         Ok(())
     }
 
+    fn codegen_pattern_sequence(&mut self, p: &PatternMatchSequence, pc: &mut PatternContext) -> CompileResult<()> {
+        // Ensure the pattern is a MatchSequence.
+        let patterns = p.patterns; // a slice of Pattern
+        let size = patterns.len();
+        let mut star: Option<usize> = None;
+        let mut only_wildcard = true;
+        let mut star_wildcard = false;
+        
+        // Find a starred pattern, if it exists. There may be at most one.
+        for (i, pattern) in patterns.iter().enumerate() {
+            if pattern.is_match_star() {
+                if star.is_some() {
+                    return Err(self.error(CodegenErrorType::MultipleStarArgs));
+                    // return self._py_compile_error(loc(p), "multiple starred names in sequence pattern");
+                }
+                // star wildcard check
+                star_wildcard = pattern.as_match_star().map(|m| m.name.is_none()).unwrap_or(false);
+                only_wildcard &= star_wildcard;
+                star = Some(i);
+                continue;
+            }
+            // wildcard check
+            only_wildcard &= pattern.as_match_as().map(|m| m.name.is_none()).unwrap_or(false);
+        }
+        
+        // Keep the subject on top during the sequence and length checks.
+        pc.on_top += 1;
+        emit!(self, Instruction::MatchSequence);
+        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+        
+        if star.is_none() {
+            // No star: len(subject) == size
+            emit!(self, Instruction::GetLen);
+            self.emit_load_const(ConstantData::Integer { value: size.into() });
+            emit!(self, Instruction::CompareOperation { op: ComparisonOperator::Equal });
+            self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+        } else if size > 1 {
+            // Star exists: len(subject) >= size - 1
+            emit!(self, Instruction::GetLen);
+            self.emit_load_const(ConstantData::Integer { value: (size - 1).into() });
+            emit!(self, Instruction::CompareOperation { op: ComparisonOperator::GreaterOrEqual });
+            self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+        }
+        
+        // Whatever comes next should consume the subject.
+        pc.on_top -= 1;
+        if only_wildcard {
+            // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
+            emit!(self, Instruction::Pop);
+        } else if star_wildcard {
+            self.pattern_helper_sequence_subscr(patterns, star, pc)?;
+        } else {
+            self.pattern_helper_sequence_unpack(patterns, star, pc)?;
+        }
+        Ok(())
+    }
+
     fn compile_pattern_value(
         &mut self,
         p: &PatternMatchValue,
