RustPython
diff --git a/‎Lib/test/_test_multiprocessing.py‎
Lines changed: 0 additions & 2 deletions b/‎Lib/test/_test_multiprocessing.py‎
Lines changed: 0 additions & 2 deletions
diff --git a/‎crates/codegen/src/compile.rs‎
Lines changed: 78 additions & 0 deletions b/‎crates/codegen/src/compile.rs‎
Lines changed: 78 additions & 0 deletions
@@ -5442,8 +5442,6 @@ def run_in_child(cls, start_method):
         flags = (tuple(sys.flags), grandchild_flags)
         print(json.dumps(flags))
 
-    # TODO: RUSTPYTHON - SyntaxError in subprocess after fork
-    @unittest.expectedFailure
     def test_flags(self):
         import json
         # start child process using unusual flags
 
@@ -2366,6 +2366,14 @@ impl Compiler {
                     );
 
                     self.switch_to_block(after_block);
+                } else {
+                    // Optimized-out asserts still need to consume any nested
+                    // scope symbol tables they contain so later nested scopes
+                    // stay aligned with AST traversal order.
+                    self.consume_skipped_nested_scopes_in_expr(test)?;
+                    if let Some(expr) = msg {
+                        self.consume_skipped_nested_scopes_in_expr(expr)?;
+                    }
                 }
             }
             ast::Stmt::Break(_) => {
@@ -7605,6 +7613,62 @@ impl Compiler {
         })
     }
 
+    fn consume_next_subtable(&mut self) -> CompileResult<()> {
+        {
+            let _ = self.push_symbol_table()?;
+        }
+        let _ = self.pop_symbol_table();
+        Ok(())
+    }
+
+    fn consume_skipped_nested_scopes_in_expr(
+        &mut self,
+        expression: &ast::Expr,
+    ) -> CompileResult<()> {
+        use ast::visitor::Visitor;
+
+        struct SkippedScopeVisitor<'a> {
+            compiler: &'a mut Compiler,
+            error: Option<CodegenError>,
+        }
+
+        impl SkippedScopeVisitor<'_> {
+            fn consume_scope(&mut self) {
+                if self.error.is_none() {
+                    self.error = self.compiler.consume_next_subtable().err();
+                }
+            }
+        }
+
+        impl ast::visitor::Visitor<'_> for SkippedScopeVisitor<'_> {
+            fn visit_expr(&mut self, expr: &ast::Expr) {
+                if self.error.is_some() {
+                    return;
+                }
+
+                match expr {
+                    ast::Expr::Lambda(_)
+                    | ast::Expr::ListComp(_)
+                    | ast::Expr::SetComp(_)
+                    | ast::Expr::DictComp(_)
+                    | ast::Expr::Generator(_) => self.consume_scope(),
+                    _ => ast::visitor::walk_expr(self, expr),
+                }
+            }
+        }
+
+        let mut visitor = SkippedScopeVisitor {
+            compiler: self,
+            error: None,
+        };
+        visitor.visit_expr(expression);
+        if let Some(err) = visitor.error {
+            Err(err)
+        } else {
+            Ok(())
+        }
+    }
+
     fn compile_comprehension(
         &mut self,
         name: &str,
@@ -9184,4 +9248,18 @@ async def test():
 "
         ));
     }
+
+    #[test]
+    fn test_optimized_assert_preserves_nested_scope_order() {
+        compile_exec_optimized(
+            "\
+class S:
+    def f(self, sequence):
+        _formats = [self._types_mapping[type(item)] for item in sequence]
+        _list_len = len(_formats)
+        assert sum(len(fmt) <= 8 for fmt in _formats) == _list_len
+        _recreation_codes = [self._extract_recreation_code(item) for item in sequence]
+",
+        );
+    }
 }