Merge pull request RustPython#831 from palaviv/exception-context

Exception reraise and context

Author: coolreader18

tests/snippets/try_exceptions.py

@@ -106,6 +106,7 @@ def __init__(self):
         raise NameError from ex
 except NameError as ex2:
     assert ex2.__cause__ == cause
+    assert ex2.__context__ == cause
 
 try:
     raise ZeroDivisionError from None
@@ -125,3 +126,44 @@ def __init__(self):
 except ZeroDivisionError as ex:
     assert type(ex.__cause__) == NameError
 
+with assertRaises(NameError):
+    try:
+        raise NameError
+    except:
+        raise
+
+with assertRaises(RuntimeError):
+    raise
+
+context = None
+try:
+    try:
+        raise ZeroDivisionError
+    except ZeroDivisionError as ex:
+        assert ex.__context__ == None
+        context = ex
+        raise NameError
+except NameError as ex2:
+    assert ex2.__context__ == context
+    assert type(ex2.__context__) == ZeroDivisionError
+
+try:
+    raise ZeroDivisionError
+except ZeroDivisionError as ex:
+    assert ex.__context__ == None
+
+try:
+    raise ZeroDivisionError from NameError
+except ZeroDivisionError as ex:
+    assert type(ex.__cause__) == NameError
+    assert ex.__context__ == None
+
+try:
+    try:
+        raise ZeroDivisionError
+    except ZeroDivisionError as ex:
+        pass
+    finally:
+        raise NameError
+except NameError as ex2:
+    assert ex2.__context__ == None

vm/src/bytecode.rs

@@ -135,6 +135,7 @@ pub enum Instruction {
     PopBlock,
     Raise {
         argc: usize,
+        in_exc: bool,
     },
     BuildString {
         size: usize,
@@ -363,7 +364,7 @@ impl Instruction {
             SetupWith { end } => w!(SetupWith, end),
             CleanupWith { end } => w!(CleanupWith, end),
             PopBlock => w!(PopBlock),
-            Raise { argc } => w!(Raise, argc),
+            Raise { argc, in_exc } => w!(Raise, argc, in_exc),
             BuildString { size } => w!(BuildString, size),
             BuildTuple { size, unpack } => w!(BuildTuple, size, unpack),
             BuildList { size, unpack } => w!(BuildList, size, unpack),

vm/src/compile.rs

@@ -24,6 +24,7 @@ struct Compiler {
     current_qualified_path: Option<String>,
     in_loop: bool,
     in_function_def: bool,
+    in_exc_handler: bool,
 }
 
 /// Compile a given sourcecode into a bytecode object.
@@ -85,6 +86,7 @@ impl Compiler {
             current_qualified_path: None,
             in_loop: false,
             in_function_def: false,
+            in_exc_handler: false,
         }
     }
 
@@ -325,15 +327,24 @@ impl Compiler {
                     match cause {
                         Some(cause) => {
                             self.compile_expression(cause)?;
-                            self.emit(Instruction::Raise { argc: 2 });
+                            self.emit(Instruction::Raise {
+                                argc: 2,
+                                in_exc: self.in_exc_handler,
+                            });
                         }
                         None => {
-                            self.emit(Instruction::Raise { argc: 1 });
+                            self.emit(Instruction::Raise {
+                                argc: 1,
+                                in_exc: self.in_exc_handler,
+                            });
                         }
                     }
                 }
                 None => {
-                    self.emit(Instruction::Raise { argc: 0 });
+                    self.emit(Instruction::Raise {
+                        argc: 0,
+                        in_exc: self.in_exc_handler,
+                    });
                 }
             },
             ast::Statement::Try {
@@ -378,7 +389,10 @@ impl Compiler {
                         });
                     }
                 }
-                self.emit(Instruction::Raise { argc: 1 });
+                self.emit(Instruction::Raise {
+                    argc: 1,
+                    in_exc: self.in_exc_handler,
+                });
                 self.set_label(end_label);
             }
             ast::Statement::Break => {
@@ -558,6 +572,8 @@ impl Compiler {
         self.emit(Instruction::Jump { target: else_label });
 
         // except handlers:
+        let was_in_exc_handler = self.in_exc_handler;
+        self.in_exc_handler = true;
         self.set_label(handler_label);
         // Exception is on top of stack now
         handler_label = self.new_label();
@@ -586,19 +602,16 @@ impl Compiler {
 
                 // We have a match, store in name (except x as y)
                 if let Some(alias) = &handler.name {
+                    // Duplicate exception for context:
+                    self.emit(Instruction::Duplicate);
                     self.store_name(alias);
-                } else {
-                    // Drop exception from top of stack:
-                    self.emit(Instruction::Pop);
                 }
-            } else {
-                // Catch all!
-                // Drop exception from top of stack:
-                self.emit(Instruction::Pop);
             }
 
             // Handler code:
             self.compile_statements(&handler.body)?;
+            // Drop exception from top of stack:
+            self.emit(Instruction::Pop);
             self.emit(Instruction::Jump {
                 target: finally_label,
             });
@@ -619,7 +632,12 @@ impl Compiler {
         if let Some(statements) = finalbody {
             self.compile_statements(statements)?;
         }
-        self.emit(Instruction::Raise { argc: 1 });
+        self.emit(Instruction::Raise {
+            argc: 0,
+            in_exc: true,
+        });
+
+        self.in_exc_handler = was_in_exc_handler;
 
         // We successfully ran the try block:
         // else:
@@ -633,7 +651,6 @@ impl Compiler {
         if let Some(statements) = finalbody {
             self.compile_statements(statements)?;
         }
-
         // unimplemented!();
         Ok(())
     }

vm/src/exceptions.rs

@@ -20,12 +20,22 @@ fn exception_init(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 // print excption chain
 pub fn print_exception(vm: &VirtualMachine, exc: &PyObjectRef) {
+    let mut had_cause = false;
     if let Ok(cause) = vm.get_attribute(exc.clone(), "__cause__") {
         if !vm.get_none().is(&cause) {
+            had_cause = true;
             print_exception(vm, &cause);
             println!("\nThe above exception was the direct cause of the following exception:\n");
         }
     }
+    if !had_cause {
+        if let Ok(context) = vm.get_attribute(exc.clone(), "__context__") {
+            if !vm.get_none().is(&context) {
+                print_exception(vm, &context);
+                println!("\nDuring handling of the above exception, another exception occurred:\n");
+            }
+        }
+    }
     print_exception_inner(vm, exc)
 }
 

vm/src/frame.rs

@@ -715,18 +715,38 @@ impl Frame {
                 Ok(None)
             }
 
-            bytecode::Instruction::Raise { argc } => {
+            bytecode::Instruction::Raise { argc, in_exc } => {
                 let cause = match argc {
                     2 => self.get_exception(vm, true)?,
                     _ => vm.get_none(),
                 };
                 let exception = match argc {
+                    0 => match in_exc {
+                        true => self.get_exception(vm, false)?,
+                        false => {
+                            return Err(vm.new_exception(
+                                vm.ctx.exceptions.runtime_error.clone(),
+                                "No active exception to reraise".to_string(),
+                            ));
+                        }
+                    },
                     1 | 2 => self.get_exception(vm, false)?,
-                    0 | 3 => panic!("Not implemented!"),
+                    3 => panic!("Not implemented!"),
                     _ => panic!("Invalid parameter for RAISE_VARARGS, must be between 0 to 3"),
                 };
-                info!("Exception raised: {:?} with cause: {:?}", exception, cause);
+                let context = match argc {
+                    0 => vm.get_none(), // We have already got the exception,
+                    _ => match in_exc {
+                        true => self.get_exception(vm, false)?,
+                        false => vm.get_none(),
+                    },
+                };
+                info!(
+                    "Exception raised: {:?} with cause: {:?} and context: {:?}",
+                    exception, cause, context
+                );
                 vm.set_attr(&exception, vm.new_str("__cause__".to_string()), cause)?;
+                vm.set_attr(&exception, vm.new_str("__context__".to_string()), context)?;
                 Err(exception)
             }