[GR-38619] Espresso List remove interop.

PullRequest: graal/16197

Author: javeleon

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/meta/Meta.java

@@ -857,6 +857,7 @@ public Meta(EspressoContext context) {
         java_util_List_set = java_util_List.requireDeclaredMethod(Name.set, Signature.Object_int_Object);
         java_util_List_size = java_util_List.requireDeclaredMethod(Name.size, Signature._int);
         java_util_List_add = java_util_List.requireDeclaredMethod(Name.add, Signature._boolean_Object);
+        java_util_List_remove = java_util_List.requireDeclaredMethod(Name.remove, Signature.Object_int);
         assert java_util_List.isInterface();
 
         java_util_Set = knownKlass(Type.java_util_Set);
@@ -1562,6 +1563,7 @@ private DiffVersionLoadHelper diff() {
     public final Method java_util_List_set;
     public final Method java_util_List_size;
     public final Method java_util_List_add;
+    public final Method java_util_List_remove;
 
     public final ObjectKlass java_util_Set;
     public final Method java_util_Set_add;

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/runtime/dispatch/staticobject/ListInterop.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2023, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -23,29 +23,25 @@
 
 package com.oracle.truffle.espresso.runtime.dispatch.staticobject;
 
-import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.dsl.Bind;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Cached.Shared;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.Specialization;
-import com.oracle.truffle.api.interop.ArityException;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.InvalidArrayIndexException;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
-import com.oracle.truffle.api.interop.UnsupportedTypeException;
 import com.oracle.truffle.api.library.ExportLibrary;
 import com.oracle.truffle.api.library.ExportMessage;
 import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.espresso.impl.Method;
-import com.oracle.truffle.espresso.meta.EspressoError;
 import com.oracle.truffle.espresso.nodes.EspressoNode;
 import com.oracle.truffle.espresso.nodes.interop.LookupAndInvokeKnownMethodNode;
 import com.oracle.truffle.espresso.runtime.EspressoException;
 import com.oracle.truffle.espresso.runtime.InteropUtils;
-import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
 import com.oracle.truffle.espresso.runtime.dispatch.messages.GenerateInteropNodes;
 import com.oracle.truffle.espresso.runtime.dispatch.messages.Shareable;
+import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
 import com.oracle.truffle.espresso.vm.InterpreterToVM;
 
 @GenerateInteropNodes
@@ -100,6 +96,20 @@ static void writeArrayElement(StaticObject receiver, long index, Object value,
         listSet.listSet(receiver, index, value, error);
     }
 
+    @ExportMessage
+    static void removeArrayElement(StaticObject receiver, long index,
+                    @Cached ListRemove listRemove,
+                    @Bind("getMeta().java_util_List_size") Method listSizeMethod,
+                    @Cached.Shared("size") @Cached LookupAndInvokeKnownMethodNode size,
+                    @Cached @Shared("error") BranchProfile error) throws UnsupportedMessageException, InvalidArrayIndexException {
+        int listSize = (int) size.execute(receiver, listSizeMethod);
+        if (!boundsCheck(index, listSize)) {
+            error.enter();
+            throw InvalidArrayIndexException.create(index);
+        }
+        listRemove.listRemove(receiver, index, error);
+    }
+
     @ExportMessage
     static boolean isArrayElementReadable(StaticObject receiver, long index,
                     @Bind("getMeta().java_util_List_size") Method listSizeMethod,
@@ -115,14 +125,20 @@ static boolean isArrayElementModifiable(StaticObject receiver, long index,
     }
 
     @ExportMessage
-    static boolean isArrayElementInsertable(@SuppressWarnings("unused") StaticObject receiver, @SuppressWarnings("unused") long index) {
-        // we can't easily determine is the guest list is modifiable or not,
-        // so we return true here and let writeArrayElement fail in case the
-        // associated guest method throws
-        return true;
+    static boolean isArrayElementInsertable(@SuppressWarnings("unused") StaticObject receiver, long index,
+                    @Bind("getMeta().java_util_List_size") Method listSizeMethod,
+                    @Cached.Shared("size") @Cached LookupAndInvokeKnownMethodNode size) {
+        int listSize = (int) size.execute(receiver, listSizeMethod);
+        return boundsCheck(index, listSize + 1);
     }
 
-    // TODO(GR-38619): isArrayElementRemovable
+    @ExportMessage
+    static boolean isArrayElementRemovable(@SuppressWarnings("unused") StaticObject receiver, @SuppressWarnings("unused") long index,
+                    @Bind("getMeta().java_util_List_size") Method listSizeMethod,
+                    @Cached.Shared("size") @Cached LookupAndInvokeKnownMethodNode size) {
+        int listSize = (int) size.execute(receiver, listSizeMethod);
+        return boundsCheck(index, listSize);
+    }
 
     private static boolean boundsCheck(StaticObject receiver, long index, Method listSize,
                     LookupAndInvokeKnownMethodNode size) {
@@ -135,7 +151,6 @@ private static boolean boundsCheck(long index, int size) {
 
     @GenerateUncached
     abstract static class ListGet extends EspressoNode {
-        static final int LIMIT = 3;
 
         public Object listGet(StaticObject receiver, long index, BranchProfile error) throws InvalidArrayIndexException {
             try {
@@ -161,7 +176,6 @@ static Object doCached(StaticObject receiver, int index,
 
     @GenerateUncached
     abstract static class ListSet extends EspressoNode {
-        static final int LIMIT = 3;
 
         public void listSet(StaticObject receiver, long index, Object value, BranchProfile error) throws InvalidArrayIndexException {
             try {
@@ -172,13 +186,10 @@ public void listSet(StaticObject receiver, long index, Object value, BranchProfi
                     throw InvalidArrayIndexException.create(index);
                 }
                 throw e; // unexpected exception
-            } catch (ArityException | UnsupportedTypeException e) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                throw EspressoError.shouldNotReachHere();
             }
         }
 
-        protected abstract void execute(StaticObject receiver, int index, Object value) throws ArityException, UnsupportedTypeException;
+        protected abstract void execute(StaticObject receiver, int index, Object value);
 
         @Specialization
         static void doCached(StaticObject receiver, int index, Object value,
@@ -190,7 +201,6 @@ static void doCached(StaticObject receiver, int index, Object value,
 
     @GenerateUncached
     abstract static class ListAdd extends EspressoNode {
-        static final int LIMIT = 3;
 
         public void listAdd(StaticObject receiver, Object value, BranchProfile error) throws UnsupportedMessageException {
             try {
@@ -204,13 +214,10 @@ public void listAdd(StaticObject receiver, Object value, BranchProfile error) th
                     throw UnsupportedMessageException.create();
                 }
                 throw e; // unexpected exception
-            } catch (ArityException | UnsupportedTypeException e) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                throw EspressoError.shouldNotReachHere();
             }
         }
 
-        protected abstract void execute(StaticObject receiver, Object value) throws ArityException, UnsupportedTypeException;
+        protected abstract void execute(StaticObject receiver, Object value);
 
         @Specialization
         static void doCached(StaticObject receiver, Object value,
@@ -219,4 +226,32 @@ static void doCached(StaticObject receiver, Object value,
             lookupAndInvoke.execute(receiver, addMethod, new Object[]{value});
         }
     }
+
+    @GenerateUncached
+    abstract static class ListRemove extends EspressoNode {
+
+        public void listRemove(StaticObject receiver, long index, BranchProfile error) throws UnsupportedMessageException, InvalidArrayIndexException {
+            try {
+                execute(receiver, (int) index);
+            } catch (EspressoException e) {
+                error.enter();
+                if (InterpreterToVM.instanceOf(e.getGuestException(), receiver.getKlass().getMeta().java_lang_IndexOutOfBoundsException)) {
+                    throw InvalidArrayIndexException.create(index);
+                }
+                if (InterpreterToVM.instanceOf(e.getGuestException(), receiver.getKlass().getMeta().java_lang_UnsupportedOperationException)) {
+                    throw UnsupportedMessageException.create(e);
+                }
+                throw e; // unexpected exception
+            }
+        }
+
+        protected abstract void execute(StaticObject receiver, int index);
+
+        @Specialization
+        static void doCached(StaticObject receiver, int index,
+                        @Bind("getMeta().java_util_List_remove") Method removeMethod,
+                        @Cached LookupAndInvokeKnownMethodNode lookupAndInvoke) {
+            lookupAndInvoke.execute(receiver, removeMethod, new Object[]{index});
+        }
+    }
 }