[GR-9228] Support TryBlockTag

Author: timfel

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/PythonLanguage.java

@@ -70,7 +70,7 @@
 import com.oracle.truffle.api.source.Source;
 
 @TruffleLanguage.Registration(id = PythonLanguage.ID, name = PythonLanguage.NAME, version = PythonLanguage.VERSION, mimeType = PythonLanguage.MIME_TYPE, interactive = true, internal = false)
-@ProvidedTags({StandardTags.CallTag.class, StandardTags.StatementTag.class, StandardTags.RootTag.class, DebuggerTags.AlwaysHalt.class})
+@ProvidedTags({StandardTags.CallTag.class, StandardTags.StatementTag.class, StandardTags.RootTag.class, StandardTags.TryBlockTag.class, DebuggerTags.AlwaysHalt.class})
 public final class PythonLanguage extends TruffleLanguage<PythonContext> {
 
     public static final String ID = "python";

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/TryExceptNode.java

@@ -27,24 +27,41 @@
 
 import static com.oracle.graal.python.runtime.PythonOptions.CatchAllExceptions;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.exception.PBaseException;
+import com.oracle.graal.python.builtins.objects.module.PythonModule;
 import com.oracle.graal.python.nodes.PNode;
+import com.oracle.graal.python.nodes.attributes.ReadAttributeFromObjectNode;
+import com.oracle.graal.python.nodes.frame.ReadGlobalOrBuiltinNode;
+import com.oracle.graal.python.nodes.literal.TupleLiteralNode;
 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.exception.PythonErrorType;
-import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
-import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.instrumentation.StandardTags;
+import com.oracle.truffle.api.instrumentation.Tag;
+import com.oracle.truffle.api.interop.ArityException;
+import com.oracle.truffle.api.interop.CanResolve;
+import com.oracle.truffle.api.interop.ForeignAccess;
+import com.oracle.truffle.api.interop.MessageResolution;
+import com.oracle.truffle.api.interop.Resolve;
+import com.oracle.truffle.api.interop.TruffleObject;
+import com.oracle.truffle.api.interop.UnknownIdentifierException;
 import com.oracle.truffle.api.nodes.ControlFlowException;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
+import com.oracle.truffle.api.nodes.Node;
 
-public class TryExceptNode extends StatementNode {
+public class TryExceptNode extends StatementNode implements TruffleObject {
 
     @Child private PNode body;
-    @Children final ExceptNode[] exceptNodes;
+    @Children private final ExceptNode[] exceptNodes;
     @Child private PNode orelse;
 
     @CompilationFinal boolean seenException;
@@ -125,4 +142,118 @@ public ExceptNode[] getExceptNodes() {
     public PNode getOrelse() {
         return orelse;
     }
+
+    @Override
+    public boolean hasTag(Class<? extends Tag> tag) {
+        return super.hasTag(tag) || StandardTags.TryBlockTag.class == tag;
+    }
+
+    public Object getNodeObject() {
+        return this;
+    }
+
+    public ForeignAccess getForeignAccess() {
+        return ExceptBlockMRForeign.ACCESS;
+    }
+
+    @MessageResolution(receiverType = TryExceptNode.class)
+    static class ExceptBlockMR {
+        @Resolve(message = "HAS_KEYS")
+        abstract static class HasKeysNode extends Node {
+            Object access(@SuppressWarnings("unused") TryExceptNode object) {
+                return true;
+            }
+        }
+
+        @Resolve(message = "KEYS")
+        abstract static class KeysNode extends Node {
+            Object access(TryExceptNode object) {
+                return object.getContext().getEnv().asGuestValue(new String[]{StandardTags.TryBlockTag.CATCHES});
+            }
+        }
+
+        @Resolve(message = "READ")
+        abstract static class ReadNode extends Node {
+            Object access(TryExceptNode object, String name) {
+                if (name.equals(StandardTags.TryBlockTag.CATCHES)) {
+                    ExceptNode[] exceptNodes = object.getExceptNodes();
+                    List<String> literalCatches = new ArrayList<>();
+                    for (ExceptNode node : exceptNodes) {
+                        PNode exceptType = node.getExceptType();
+                        if (exceptType instanceof ReadGlobalOrBuiltinNode) {
+                            literalCatches.add(((ReadGlobalOrBuiltinNode) exceptType).getAttributeId());
+                        } else if (exceptType instanceof TupleLiteralNode) {
+                            for (PNode tupleValue : ((TupleLiteralNode) exceptType).getValues()) {
+                                if (tupleValue instanceof ReadGlobalOrBuiltinNode) {
+                                    literalCatches.add(((ReadGlobalOrBuiltinNode) tupleValue).getAttributeId());
+                                }
+                            }
+                        }
+                    }
+                    return new CatchesFunction(object.getContext().getBuiltins(), literalCatches.toArray(new String[0]));
+                } else {
+                    throw UnknownIdentifierException.raise(name);
+                }
+            }
+        }
+
+        @CanResolve
+        abstract static class CheckFunction extends Node {
+            protected static boolean test(TruffleObject receiver) {
+                return receiver instanceof TryExceptNode;
+            }
+        }
+
+        protected static class CatchesFunction implements TruffleObject {
+            private final PythonModule builtins;
+            @CompilationFinal(dimensions = 1) private final String[] attributes;
+            private final ReadAttributeFromObjectNode getAttribute = ReadAttributeFromObjectNode.create();
+
+            CatchesFunction(PythonModule builtins, String[] array) {
+                this.builtins = builtins;
+                this.attributes = array;
+            }
+
+            boolean catches(Object exception) {
+                for (String name : attributes) {
+                    Object execute = getAttribute.execute(builtins, name);
+                    if (execute == exception) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            public ForeignAccess getForeignAccess() {
+                return ExceptListMRForeign.ACCESS;
+            }
+
+            @MessageResolution(receiverType = CatchesFunction.class)
+            static class ExceptListMR {
+                @Resolve(message = "IS_EXECUTABLE")
+                abstract static class IsExecutableNode extends Node {
+                    Object access(@SuppressWarnings("unused") CatchesFunction object) {
+                        return true;
+                    }
+                }
+
+                @Resolve(message = "EXECUTE")
+                abstract static class ExecuteNode extends Node {
+                    Object access(CatchesFunction object, Object[] arguments) {
+                        if (arguments.length != 1) {
+                            throw ArityException.raise(1, arguments.length);
+                        }
+                        return object.catches(arguments[0]);
+                    }
+                }
+
+                @CanResolve
+                abstract static class CheckFunction extends Node {
+                    protected static boolean test(TruffleObject receiver) {
+                        return receiver instanceof TryExceptNode;
+                    }
+                }
+            }
+        }
+    }
 }