shellsim 0.1.8__tar.gz → 0.1.9__tar.gz

{shellsim-0.1.8 → shellsim-0.1.9}/Cargo.lock

@@ -330,7 +330,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.8"
+version = "0.1.9"
 dependencies = [
  "base64",
  "crc32fast",

{shellsim-0.1.8 → shellsim-0.1.9}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "shellsim"
-version = "0.1.8"
+version = "0.1.9"
 edition = "2021"
 description = "In-process BusyBox-like environment for RL rollouts and agent tests"
 license = "Apache-2.0"

{shellsim-0.1.8 → shellsim-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shellsim
-Version: 0.1.8
+Version: 0.1.9
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS :: MacOS X

{shellsim-0.1.8 → shellsim-0.1.9}/python/native/Cargo.lock

@@ -406,7 +406,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.8"
+version = "0.1.9"
 dependencies = [
  "base64",
  "crc32fast",
@@ -427,7 +427,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim-python-bindings"
-version = "0.1.8"
+version = "0.1.9"
 dependencies = [
  "pyo3",
  "serde",

{shellsim-0.1.8 → shellsim-0.1.9}/python/native/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "shellsim-python-bindings"
-version = "0.1.8"
+version = "0.1.9"
 edition = "2021"
 description = "Python bindings for shellsim"
 license = "Apache-2.0"

{shellsim-0.1.8 → shellsim-0.1.9}/src/python/ast.rs

@@ -173,14 +173,13 @@ pub enum ExpressionKind {
         value: Box<Expression>,
         clauses: Vec<ComprehensionClause>,
     },
-    /// The VM deliberately materializes this as a list for now.  This gives
-    /// generator expressions an ordinary iterable and isolated comprehension
-    /// scope while keeping the bounded-resource contract simple and explicit.
+    /// A lazy comprehension evaluated in its own generator frame.
     GeneratorExpression {
         element: Box<Expression>,
         clauses: Vec<ComprehensionClause>,
     },
     Yield(Option<Box<Expression>>),
+    YieldFrom(Box<Expression>),
     Attribute {
         value: Box<Expression>,
         name: String,

{shellsim-0.1.8 → shellsim-0.1.9}/src/python/compiler.rs

@@ -936,10 +936,7 @@ impl Compiler {
                 self.emit_dict_comprehension(*key, *value, clauses, span);
             }
             ExpressionKind::GeneratorExpression { element, clauses } => {
-                // The first implementation intentionally materializes generator expressions.
-                // It is still a separate function scope (like CPython's generator frame), and
-                // all iteration remains metered by the ordinary bytecode loop.
-                self.emit_comprehension(ComprehensionKind::List, *element, clauses, span);
+                self.emit_generator_expression(*element, clauses, span);
             }
             ExpressionKind::Yield(value) => {
                 if !self.in_function {
@@ -947,11 +944,6 @@ impl Compiler {
                         Operation::RuntimeError("'yield' outside function".into()),
                         span,
                     );
-                } else if let Some(region) = self.protected_regions.last() {
-                    self.emit(
-                        Operation::RuntimeError(format!("yield is not supported inside a {region} cleanup region; suspending here would lose exception or context-manager state")),
-                        span,
-                    );
                 } else {
                     if let Some(value) = value {
                         self.expression(*value);
@@ -961,6 +953,24 @@ impl Compiler {
                     self.emit(Operation::Yield, span);
                 }
             }
+            ExpressionKind::YieldFrom(value) => {
+                if !self.in_function {
+                    self.emit(
+                        Operation::RuntimeError("'yield from' outside function".into()),
+                        span,
+                    );
+                } else {
+                    self.expression(*value);
+                    self.emit(Operation::GetIterator, span);
+                    let next = self.emit(Operation::ForIterator(usize::MAX), span);
+                    self.emit(Operation::Yield, span);
+                    self.emit(Operation::PopTop, span);
+                    self.emit(Operation::Jump(next), span);
+                    let exhausted = self.instructions.len();
+                    self.patch_jump(next, exhausted);
+                    self.emit(Operation::LoadConstant(Constant::None), span);
+                }
+            }
             ExpressionKind::Attribute { value, name } => {
                 self.expression(*value);
                 self.emit(Operation::LoadAttribute(name), span);
@@ -1216,6 +1226,46 @@ impl Compiler {
         );
     }
 
+    fn emit_generator_expression(
+        &mut self,
+        element: Expression,
+        clauses: Vec<ComprehensionClause>,
+        span: Span,
+    ) {
+        let named_expression = self.comprehension_named_expression_context();
+        let mut nested = Compiler {
+            instructions: Vec::new(),
+            loops: Vec::new(),
+            finalizers: Vec::new(),
+            protected_regions: Vec::new(),
+            in_function: true,
+            globals: HashSet::new(),
+            nonlocals: HashSet::new(),
+            named_expression,
+            is_class_scope: false,
+            structural_depth: self.structural_depth,
+        };
+        nested.emit_generator_comprehension_body(&clauses, 0, &element, span);
+        nested.emit(Operation::LoadConstant(Constant::None), span);
+        nested.emit(Operation::Return, span);
+        self.emit(
+            Operation::MakeFunction {
+                name: "<genexpr>".into(),
+                code: nested.finish(Vec::new()),
+                defaults: 0,
+            },
+            span,
+        );
+        self.emit(
+            Operation::Call {
+                positional: 0,
+                keywords: Vec::new(),
+                starred: Vec::new(),
+            },
+            span,
+        );
+    }
+
     fn emit_dict_comprehension(
         &mut self,
         key: Expression,
@@ -1307,6 +1357,35 @@ impl Compiler {
         self.patch_jump(next, exhausted);
     }
 
+    fn emit_generator_comprehension_body(
+        &mut self,
+        clauses: &[ComprehensionClause],
+        index: usize,
+        element: &Expression,
+        span: Span,
+    ) {
+        let clause = &clauses[index];
+        self.expression(clause.iterable.clone());
+        self.emit(Operation::GetIterator, span);
+        let next = self.emit(Operation::ForIterator(usize::MAX), span);
+        self.store_target(clause.target.clone(), span);
+        for condition in &clause.conditions {
+            self.expression(condition.clone());
+            let skip = self.emit(Operation::PopJumpIfFalse(usize::MAX), span);
+            self.patch_jump(skip, next);
+        }
+        if index + 1 < clauses.len() {
+            self.emit_generator_comprehension_body(clauses, index + 1, element, span);
+        } else {
+            self.expression(element.clone());
+            self.emit(Operation::Yield, span);
+            self.emit(Operation::PopTop, span);
+        }
+        self.emit(Operation::Jump(next), span);
+        let exhausted = self.instructions.len();
+        self.patch_jump(next, exhausted);
+    }
+
     fn emit_dict_comprehension_body(
         &mut self,
         clauses: &[ComprehensionClause],