Also restore in finally and with blocks.

fangerer · fangerer · commit 72790ef2ce72 · 2018-07-18T18:56:18.000+02:00
diff --git a/graalpython/com.oracle.graal.python.test/src/tests/test_raise-try.py b/graalpython/com.oracle.graal.python.test/src/tests/test_raise-try.py
@@ -73,6 +73,53 @@ def test_exception_restoring():
     assert trace == [1, 2, 3, 4, 5]
 
 
+def test_exception_restoring_finally():
+    import sys
+    trace = []
+    try:
+        try:
+            assert sys.exc_info() == (None, None, None)
+            trace.append(1)
+            raise ValueError("1")
+        except ValueError:
+            assert sys.exc_info()[0] == ValueError
+            trace.append(2)
+            raise KeyError("2")
+        finally:
+            assert sys.exc_info()[0] == KeyError, "was: %s" % sys.exc_info()[0]
+            trace.append(3)
+    except KeyError:
+        assert sys.exc_info()[0] == KeyError, "was: %s" % sys.exc_info()[0]
+        trace.append(4)
+    assert trace == [1, 2, 3, 4]
+
+
+def test_exception_restoring_raise_finally():
+    import sys
+    trace = []
+    try:
+        try:
+            try:
+                assert sys.exc_info() == (None, None, None)
+                trace.append(1)
+                raise ValueError("1")
+            except ValueError:
+                assert sys.exc_info()[0] == ValueError
+                trace.append(2)
+                raise KeyError("2")
+            finally:
+                assert sys.exc_info()[0] == KeyError, "was: %s" % sys.exc_info()[0]
+                trace.append(3)
+                raise TypeError
+        finally:
+            assert sys.exc_info()[0] == TypeError, "was: %s" % sys.exc_info()[0]
+            trace.append(4)
+    except TypeError:
+        assert sys.exc_info()[0] == TypeError, "was: %s" % sys.exc_info()[0]
+        trace.append(5)
+    assert trace == [1, 2, 3, 4, 5]
+
+
 def test_exception_restoring_with_return():
     import sys
     trace = []
@@ -98,6 +145,6 @@ def handler():
             trace.append(4)
             raise
     except ValueError:
-        assert sys.exc_info()[0] == ValueError, "IS: %s" % sys.exc_info()[0]
+        assert sys.exc_info()[0] == ValueError
         trace.append(5)
     assert trace == [1, 2, 3, 4, 5]
diff --git a/graalpython/com.oracle.graal.python.test/src/tests/test_with.py b/graalpython/com.oracle.graal.python.test/src/tests/test_with.py
@@ -127,3 +127,47 @@ def test_with_return_and_exception():
                     "value: None",
                     "a = 11",
     ], "was: " + str(LOG3)
+
+
+def test_with_restore():
+    import sys
+    log = []
+    try:
+        log.append("raise")
+        raise ValueError("1")
+    except:
+        assert sys.exc_info()[0] == ValueError
+        with Context(log, True, False) as sample:
+            assert sys.exc_info()[0] == ValueError
+            log.append("with body")
+        assert sys.exc_info()[0] == ValueError
+        log.append("except exit")
+    assert log == [  "raise"
+                   , "__enter__"
+                   , "with body"
+                   , "type: None"
+                   , "value: None"
+                   , "except exit"], "was: %s" % log
+
+
+def test_with_restore_raise():
+    import sys
+    log = []
+    try:
+        log.append("raise")
+        raise ValueError("1")
+    except:
+        assert sys.exc_info()[0] == ValueError
+        with Context(log, True, False) as sample:
+            assert sys.exc_info()[0] == ValueError
+            log.append("with body")
+            raise TypeError
+            log.append("INVALID")
+        assert sys.exc_info()[0] == ValueError
+        log.append("except exit")
+    assert log == [  "raise"
+                   , "__enter__"
+                   , "with body"
+                   , "type: <class 'TypeError'>"
+                   , "value: "
+                   , "except exit"], "was: %s" % log
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/generator/GeneratorTryExceptNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/generator/GeneratorTryExceptNode.java
@@ -47,6 +47,7 @@
 import com.oracle.graal.python.runtime.exception.ExceptionHandledException;
 import com.oracle.graal.python.runtime.exception.PException;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.nodes.ControlFlowException;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
 
 public class GeneratorTryExceptNode extends TryExceptNode implements GeneratorControlNode {
@@ -127,17 +128,19 @@ private void catchException(VirtualFrame frame, PException exception, PException
             // we tried and haven't found a matching except node
             throw exception;
         }
+        getContext().setCurrentException(exceptionState);
     }
 
     private void runExceptionHandler(VirtualFrame frame, PException exception, ExceptNode exceptNode, PException exceptionState) {
         try {
             exceptNode.executeExcept(frame, exception);
         } catch (ExceptionHandledException e) {
             return;
-        } finally {
+        } catch (ControlFlowException e) {
             // restore previous exception state, this won't happen if the except block raises an
             // exception
             getContext().setCurrentException(exceptionState);
+            throw e;
         }
     }
 
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/generator/GeneratorTryFinallyNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/generator/GeneratorTryFinallyNode.java
@@ -56,6 +56,7 @@ public GeneratorTryFinallyNode(PNode body, PNode finalbody, int finallyFlag) {
 
     @Override
     public Object execute(VirtualFrame frame) {
+        PException exceptionState = getContext().getCurrentException();
         PException exception = null;
         if (isActive(frame, finallyFlag)) {
             getFinalbody().execute(frame);
@@ -72,6 +73,7 @@ public Object execute(VirtualFrame frame) {
         if (exception != null) {
             throw exception;
         }
+        getContext().setCurrentException(exceptionState);
         return PNone.NONE;
     }
 
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/TryExceptNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/TryExceptNode.java
@@ -42,12 +42,14 @@
 import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.nodes.ControlFlowException;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
+import com.oracle.truffle.api.profiles.ValueProfile;
 
 public class TryExceptNode extends StatementNode implements TruffleObject {
     @Child private PNode body;
     @Children private final ExceptNode[] exceptNodes;
     @Child private PNode orelse;
     @CompilationFinal private TryExceptNodeMessageResolution.CatchesFunction catchesFunction;
+    @CompilationFinal private ValueProfile exceptionStateProfile;
 
     @CompilationFinal boolean seenException;
 
@@ -111,17 +113,21 @@ private void catchException(VirtualFrame frame, PException exception, PException
                         exceptNode.executeExcept(frame, exception);
                     } catch (ExceptionHandledException e) {
                         wasHandled = true;
-                    } finally {
+                    } catch (ControlFlowException e) {
                         // restore previous exception state, this won't happen if the except block
                         // raises an exception
                         getContext().setCurrentException(exceptionState);
+                        throw e;
                     }
                 }
             }
         }
         if (!wasHandled) {
             throw exception;
         }
+        // restore previous exception state, this won't happen if the except block
+        // raises an exception
+        getContext().setCurrentException(exceptionState);
     }
 
     public PNode getBody() {
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/TryFinallyNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/TryFinallyNode.java
@@ -27,7 +27,10 @@
 
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.nodes.PNode;
+import com.oracle.graal.python.runtime.PythonContext;
+import com.oracle.graal.python.runtime.exception.PException;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.nodes.ControlFlowException;
 
 public class TryFinallyNode extends StatementNode {
 
@@ -41,10 +44,24 @@ public TryFinallyNode(PNode body, PNode finalbody) {
 
     @Override
     public Object execute(VirtualFrame frame) {
+        PythonContext context = getContext();
+        PException exceptionState = context.getCurrentException();
         try {
             body.execute(frame);
+        } catch (PException e) {
+            // any thrown Python exception is visible in the finally block
+            context.setCurrentException(e);
+            throw e;
         } finally {
-            finalbody.execute(frame);
+            try {
+                finalbody.execute(frame);
+            } catch (ControlFlowException e) {
+                // restore
+                context.setCurrentException(exceptionState);
+                throw e;
+            }
+            // restore
+            context.setCurrentException(exceptionState);
         }
         return PNone.NONE;
     }
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/WithNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/WithNode.java
@@ -89,6 +89,7 @@ protected Object runWith(VirtualFrame frame, Object withObject,
                     @Cached("create()") IsCallableNode isCallableNode,
                     @Cached("create()") IsCallableNode isExitCallableNode) {
 
+        PException exceptionState = getContext().getCurrentException();
         boolean gotException = false;
         // CPython first looks up '__exit__
         Object exitCallable = exitGetter.executeObject(withObject, "__exit__");
@@ -113,6 +114,7 @@ protected Object runWith(VirtualFrame frame, Object withObject,
                     throw raise(TypeError, "%p is not callable", exitCallable);
                 }
             }
+            getContext().setCurrentException(exceptionState);
         }
         return PNone.NONE;
     }

Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,7 @@ public GeneratorTryFinallyNode(PNode body, PNode finalbody, int finallyFlag) {`
`56`	`56`
`57`	`57`	`@Override`
`58`	`58`	`public Object execute(VirtualFrame frame) {`
	`59`	`+ PException exceptionState = getContext().getCurrentException();`
`59`	`60`	`PException exception = null;`
`60`	`61`	`if (isActive(frame, finallyFlag)) {`
`61`	`62`	`getFinalbody().execute(frame);`
`@@ -72,6 +73,7 @@ public Object execute(VirtualFrame frame) {`
`72`	`73`	`if (exception != null) {`
`73`	`74`	`throw exception;`
`74`	`75`	`}`
	`76`	`+ getContext().setCurrentException(exceptionState);`
`75`	`77`	`return PNone.NONE;`
`76`	`78`	`}`
`77`	`79`
Original file line number	Diff line number	Diff line change
`@@ -42,12 +42,14 @@`
`42`	`42`	`import com.oracle.truffle.api.interop.TruffleObject;`
`43`	`43`	`import com.oracle.truffle.api.nodes.ControlFlowException;`
`44`	`44`	`import com.oracle.truffle.api.nodes.ExplodeLoop;`
	`45`	`+import com.oracle.truffle.api.profiles.ValueProfile;`
`45`	`46`
`46`	`47`	`public class TryExceptNode extends StatementNode implements TruffleObject {`
`47`	`48`	`@Child private PNode body;`
`48`	`49`	`@Children private final ExceptNode[] exceptNodes;`
`49`	`50`	`@Child private PNode orelse;`
`50`	`51`	`@CompilationFinal private TryExceptNodeMessageResolution.CatchesFunction catchesFunction;`
	`52`	`+ @CompilationFinal private ValueProfile exceptionStateProfile;`
`51`	`53`
`52`	`54`	`@CompilationFinal boolean seenException;`
`53`	`55`
`@@ -111,17 +113,21 @@ private void catchException(VirtualFrame frame, PException exception, PException`
`111`	`113`	`exceptNode.executeExcept(frame, exception);`
`112`	`114`	`} catch (ExceptionHandledException e) {`
`113`	`115`	`wasHandled = true;`
`114`		`- } finally {`
	`116`	`+ } catch (ControlFlowException e) {`
`115`	`117`	`// restore previous exception state, this won't happen if the except block`
`116`	`118`	`// raises an exception`
`117`	`119`	`getContext().setCurrentException(exceptionState);`
	`120`	`+ throw e;`
`118`	`121`	`}`
`119`	`122`	`}`
`120`	`123`	`}`
`121`	`124`	`}`
`122`	`125`	`if (!wasHandled) {`
`123`	`126`	`throw exception;`
`124`	`127`	`}`
	`128`	`+ // restore previous exception state, this won't happen if the except block`
	`129`	`+ // raises an exception`
	`130`	`+ getContext().setCurrentException(exceptionState);`
`125`	`131`	`}`
`126`	`132`
`127`	`133`	`public PNode getBody() {`
Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,7 @@ protected Object runWith(VirtualFrame frame, Object withObject,`
`89`	`89`	`@Cached("create()") IsCallableNode isCallableNode,`
`90`	`90`	`@Cached("create()") IsCallableNode isExitCallableNode) {`
`91`	`91`
	`92`	`+ PException exceptionState = getContext().getCurrentException();`
`92`	`93`	`boolean gotException = false;`
`93`	`94`	`// CPython first looks up '__exit__`
`94`	`95`	`Object exitCallable = exitGetter.executeObject(withObject, "__exit__");`
`@@ -113,6 +114,7 @@ protected Object runWith(VirtualFrame frame, Object withObject,`
`113`	`114`	`throw raise(TypeError, "%p is not callable", exitCallable);`
`114`	`115`	`}`
`115`	`116`	`}`
	`117`	`+ getContext().setCurrentException(exceptionState);`
`116`	`118`	`}`
`117`	`119`	`return PNone.NONE;`
`118`	`120`	`}`