simplify some more jython emulation code

timfel · timfel · commit a488d690d576 · 2021-03-10T12:18:22.000+01:00
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinFunctions.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinFunctions.java
@@ -1068,14 +1068,6 @@ boolean isInstance(VirtualFrame frame, Object instance, PTuple clsTuple,
 
         @Fallback
         boolean isInstance(VirtualFrame frame, Object instance, Object cls) {
-            if (getPythonLanguage().getEngineOption(PythonOptions.EmulateJython)) {
-                TruffleLanguage.Env env = getContext().getEnv();
-                if (env.isHostObject(cls)) {
-                    Object hostCls = env.asHostObject(cls);
-                    Object hostInstance = env.isHostObject(instance) ? env.asHostObject(instance) : instance;
-                    return hostCls instanceof Class && ((Class<?>) hostCls).isAssignableFrom(hostInstance.getClass());
-                }
-            }
             TriState check = isInstanceCheckInternal(frame, instance, cls);
             if (check == TriState.UNDEFINED) {
                 return typeInstanceCheckNode.executeWith(frame, cls, instance);
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/ExceptNode.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/ExceptNode.java
@@ -57,6 +57,7 @@
 import com.oracle.truffle.api.instrumentation.InstrumentableNode;
 import com.oracle.truffle.api.instrumentation.ProbeNode;
 import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.Node;
 
@@ -104,15 +105,8 @@ public boolean matchesPException(VirtualFrame frame, PException e) {
 
     public boolean matchesTruffleException(@SuppressWarnings("unused") VirtualFrame frame, AbstractTruffleException e) {
         assert !(e instanceof PException);
-        // TODO: (tfel) should we allow catching with the meta-object of arbitrary truffle
-        // exceptions?
-        return exceptType == null;
-    }
-
-    public boolean matchesHostException(VirtualFrame frame, Throwable e) {
-        assert !(e instanceof AbstractTruffleException);
         if (exceptType == null) {
-            return false; // host exceptions must be matched explicitly
+            return true;
         }
         return getMatchNode().executeMatch(frame, e, exceptType.execute(frame));
     }
@@ -147,16 +141,14 @@ public boolean isInstrumentable() {
     }
 }
 
-interface EmulateJythonNode {
-    default boolean emulateJython(PythonLanguage language) {
-        return language.getEngineOption(PythonOptions.EmulateJython);
-    }
-}
-
 @ImportStatic(PythonOptions.class)
-abstract class ValidExceptionNode extends Node implements EmulateJythonNode {
+abstract class ValidExceptionNode extends Node {
     protected abstract boolean execute(VirtualFrame frame, Object type);
 
+    protected static boolean emulateJython(PythonLanguage language) {
+        return language.getEngineOption(PythonOptions.EmulateJython);
+    }
+
     protected static boolean isPythonExceptionType(PythonBuiltinClassType type) {
         PythonBuiltinClassType base = type;
         while (base != null) {
@@ -209,7 +201,7 @@ static ValidExceptionNode create() {
 }
 
 @ImportStatic({PGuards.class, PythonOptions.class})
-abstract class ExceptMatchNode extends Node implements EmulateJythonNode {
+abstract class ExceptMatchNode extends Node {
     @Child private PRaiseNode raiseNode;
 
     protected abstract boolean executeMatch(VirtualFrame frame, Object exception, Object clause);
@@ -238,38 +230,20 @@ boolean matchPythonSingle(VirtualFrame frame, PException e, Object clause,
         return isSubtype.execute(frame, plib.getLazyPythonClass(e.getUnreifiedException()), clause);
     }
 
-    @Specialization(guards = {"emulateJython(language)", "context.getEnv().isHostException(e)", "context.getEnv().isHostObject(clause)"})
-    @SuppressWarnings("unused")
-    boolean matchJava(VirtualFrame frame, Throwable e, Object clause,
-                    @Cached ValidExceptionNode isValidException,
-                    @CachedLanguage PythonLanguage language,
-                    @CachedContext(PythonLanguage.class) PythonContext context) {
-        raiseIfNoException(frame, clause, isValidException);
-        // cast must succeed due to ValidExceptionNode above
-        Class<?> javaClause = (Class<?>) context.getEnv().asHostObject(clause);
-        Throwable hostException = context.getEnv().asHostException(e);
-        return javaClause.isInstance(hostException);
-    }
-
-    @Specialization(guards = {"emulateJython(language)", "context.getEnv().isHostObject(clause)"})
+    @Specialization(guards = {"eLib.isException(e)", "clauseLib.isMetaObject(clause)"}, limit = "3", replaces = "matchPythonSingle")
     @SuppressWarnings("unused")
-    boolean doNotMatchPython(VirtualFrame frame, @SuppressWarnings("unused") PException e, Object clause,
-                    @CachedLanguage PythonLanguage language,
-                    @CachedContext(PythonLanguage.class) PythonContext context,
-                    @Cached ValidExceptionNode isValidException) {
-        raiseIfNoException(frame, clause, isValidException);
-        return false;
-    }
-
-    @Specialization(guards = {"lib.isLazyPythonClass(clause)", "emulateJython(language)", "context.getEnv().isHostException(e)"})
-    @SuppressWarnings("unused")
-    boolean doNotMatchJava(VirtualFrame frame, @SuppressWarnings("unused") Throwable e, Object clause,
-                    @CachedLanguage PythonLanguage language,
-                    @CachedContext(PythonLanguage.class) PythonContext context,
+    boolean matchJava(VirtualFrame frame, AbstractTruffleException e, Object clause,
                     @Cached ValidExceptionNode isValidException,
-                    @CachedLibrary(limit = "2") PythonObjectLibrary lib) {
+                    @CachedLibrary("e") InteropLibrary eLib,
+                    @CachedLibrary("clause") InteropLibrary clauseLib) {
+        // n.b.: we can only allow Java exceptions in clauses, because we cannot tell for other
+        // foreign exception types if they *are* exception types
         raiseIfNoException(frame, clause, isValidException);
-        return false;
+        try {
+            return clauseLib.isMetaInstance(clause, e);
+        } catch (UnsupportedMessageException e1) {
+            throw CompilerDirectives.shouldNotReachHere();
+        }
     }
 
     @Specialization
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
@@ -39,7 +39,6 @@
 import com.oracle.graal.python.nodes.literal.TupleLiteralNode;
 import com.oracle.graal.python.nodes.util.ExceptionStateNodes.ExceptionState;
 import com.oracle.graal.python.nodes.util.ExceptionStateNodes.SetCaughtExceptionNode;
-import com.oracle.graal.python.runtime.PythonOptions;
 import com.oracle.graal.python.runtime.exception.ExceptionHandledException;
 import com.oracle.graal.python.runtime.exception.PException;
 import com.oracle.graal.python.runtime.interop.InteropArray;
@@ -105,12 +104,6 @@ public void executeVoid(VirtualFrame frame) {
         } catch (ControlFlowException e) {
             throw e;
         } catch (Exception | StackOverflowError | AssertionError e) {
-            if (shouldCatchJavaExceptions() && getContext().getEnv().isHostException(e)) {
-                boolean handled = catchHostException(frame, e);
-                if (handled) {
-                    return;
-                }
-            }
             PException pe = wrapJavaExceptionIfApplicable(e);
             if (pe != null) {
                 boolean handled = catchPException(frame, pe);
@@ -185,34 +178,6 @@ private boolean catchTruffleException(VirtualFrame frame, AbstractTruffleExcepti
         return false;
     }
 
-    @ExplodeLoop(kind = LoopExplosionKind.FULL_EXPLODE_UNTIL_RETURN)
-    private boolean catchHostException(VirtualFrame frame, Throwable exception) {
-        assert !(exception instanceof AbstractTruffleException);
-        try {
-            for (ExceptNode exceptNode : exceptNodes) {
-                if (everMatched.profile(exceptNode.matchesHostException(frame, exception))) {
-                    ExceptionState exceptionState = saveExceptionState(frame);
-                    try {
-                        exceptNode.executeExcept(frame, exception);
-                    } finally {
-                        restoreExceptionState(frame, exceptionState);
-                    }
-                }
-            }
-        } catch (ExceptionHandledException eh) {
-            return true;
-        } catch (PException handlerException) {
-            throw handlerException;
-        } catch (Exception | StackOverflowError | AssertionError e) {
-            PException handlerException = wrapJavaExceptionIfApplicable(e);
-            if (handlerException == null) {
-                throw e;
-            }
-            throw handlerException.getExceptionForReraise();
-        }
-        return false;
-    }
-
     public StatementNode getBody() {
         return body;
     }
@@ -327,8 +292,4 @@ public void setCatchesFunction(CatchesFunction catchesFunction) {
         CompilerDirectives.transferToInterpreterAndInvalidate();
         this.catchesFunction = catchesFunction;
     }
-
-    private boolean shouldCatchJavaExceptions() {
-        return getPythonLanguage().getEngineOption(PythonOptions.EmulateJython);
-    }
 }
