- more interop builtins

- fixes

com.oracle.truffle.r.engine/src/com/oracle/truffle/r/engine/RRuntimeASTAccessImpl.java

@@ -59,6 +59,7 @@ import com.oracle.truffle.r.runtime.RArguments;
 import com.oracle.truffle.r.runtime.RCaller;
 import com.oracle.truffle.r.runtime.RDeparse;
 import com.oracle.truffle.r.runtime.RError;
+import com.oracle.truffle.r.runtime.RError.ShowCallerOf;
 import com.oracle.truffle.r.runtime.RRuntimeASTAccess;
 import com.oracle.truffle.r.runtime.RootWithBody;
 import com.oracle.truffle.r.runtime.Utils;
@@ -79,7 +80,9 @@ import com.oracle.truffle.r.runtime.nodes.InternalRSyntaxNodeChildren;
 import com.oracle.truffle.r.runtime.nodes.RBaseNode;
 import com.oracle.truffle.r.runtime.nodes.RInstrumentableNode;
 import com.oracle.truffle.r.runtime.nodes.RNode;
+import com.oracle.truffle.r.runtime.nodes.RSyntaxCall;
 import com.oracle.truffle.r.runtime.nodes.RSyntaxElement;
+import com.oracle.truffle.r.runtime.nodes.RSyntaxLookup;
 import com.oracle.truffle.r.runtime.nodes.RSyntaxNode;
 
 /**
@@ -189,6 +192,32 @@ class RRuntimeASTAccessImpl implements RRuntimeASTAccess {
                 RCaller parent = RArguments.getCall(frame);
                 frame = Utils.getCallerFrame(parent, FrameAccess.READ_ONLY);
             }
+            return findCallerFromFrame(frame);
+        } else if (call instanceof ShowCallerOf) {
+            Frame frame = Utils.getActualCurrentFrame();
+
+            boolean match = false;
+            String name = ((ShowCallerOf) call).getCallerOf();
+            Frame f = frame;
+            while (f != null && RArguments.isRFrame(f)) {
+                RCaller parent = RArguments.getCall(f);
+                if (parent.isValidCaller()) {
+                    RSyntaxElement syntaxNode = parent.getSyntaxNode();
+                    if (syntaxNode instanceof RSyntaxCall) {
+                        RSyntaxElement syntaxElement = ((RSyntaxCall) syntaxNode).getSyntaxLHS();
+                        if (syntaxElement instanceof RSyntaxLookup) {
+                            if (match) {
+                                return findCallerFromFrame(f);
+                            }
+                            if (name.equals(((RSyntaxLookup) syntaxElement).getIdentifier())) {
+                                match = true;
+                            }
+                        }
+                    }
+                }
+                f = Utils.getCallerFrame(parent, FrameAccess.READ_ONLY);
+            }
+
             return findCallerFromFrame(frame);
         } else {
             RBaseNode originalCall = checkBuiltin(call);

com.oracle.truffle.r.nodes.builtin/src/com/oracle/truffle/r/nodes/builtin/base/BasePackage.java

@@ -108,10 +108,12 @@ import com.oracle.truffle.r.nodes.builtin.fastr.FastRIdentityNodeGen;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInspect;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInspectNodeGen;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInterop;
+import com.oracle.truffle.r.nodes.builtin.fastr.FastRInterop.FastRInteropCheckException;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInterop.FastRInteropClearException;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInterop.FastRInteropGetException;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInterop.FastRInteropTry;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInteropFactory;
+import com.oracle.truffle.r.nodes.builtin.fastr.FastRInteropFactory.FastRInteropCheckExceptionNodeGen;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInteropFactory.FastRInteropClearExceptionNodeGen;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInteropFactory.FastRInteropGetExceptionNodeGen;
 import com.oracle.truffle.r.nodes.builtin.fastr.FastRInteropFactory.FastRInteropTryNodeGen;
@@ -449,6 +451,7 @@ public class BasePackage extends RBuiltinPackage {
         add(FastROptionBuiltin.class, FastROptionBuiltin::create);
         add(FastRTestsTry.class, FastRTestsTryNodeGen::create);
         add(FastRInteropTry.class, FastRInteropTryNodeGen::create);
+        add(FastRInteropCheckException.class, FastRInteropCheckExceptionNodeGen::create);
         add(FastRInteropGetException.class, FastRInteropGetExceptionNodeGen::create);
         add(FastRInteropClearException.class, FastRInteropClearExceptionNodeGen::create);
         add(FastRInspect.class, FastRInspectNodeGen::create);
@@ -461,8 +464,14 @@ public class BasePackage extends RBuiltinPackage {
         add(FastRInterop.DoCallExternal.class, FastRInteropFactory.DoCallExternalNodeGen::create);
         add(FastRInterop.IsExternal.class, FastRInteropFactory.IsExternalNodeGen::create);
         add(FastRInterop.JavaClass.class, FastRInteropFactory.JavaClassNodeGen::create);
+        add(FastRInterop.GetJavaClass.class, FastRInteropFactory.GetJavaClassNodeGen::create);
         add(FastRInterop.JavaClassName.class, FastRInteropFactory.JavaClassNameNodeGen::create);
         add(FastRInterop.JavaAddToClasspath.class, FastRInteropFactory.JavaAddToClasspathNodeGen::create);
+        add(FastRInterop.JavaClasspath.class, FastRInteropFactory.JavaClasspathNodeGen::create);
+        add(FastRInterop.JavaIsIdentical.class, FastRInteropFactory.JavaIsIdenticalNodeGen::create);
+        add(FastRInterop.JavaIsAssignableFrom.class, FastRInteropFactory.JavaIsAssignableFromNodeGen::create);
+        add(FastRInterop.JavaIsInstance.class, FastRInteropFactory.JavaIsInstanceNodeGen::create);
+        add(FastRInterop.JavaAsTruffleObject.class, FastRInteropFactory.JavaAsTruffleObjectNodeGen::create);
         add(FastRInterop.IsForeignArray.class, FastRInteropFactory.IsForeignArrayNodeGen::create);
         add(FastRInterop.NewJavaArray.class, FastRInteropFactory.NewJavaArrayNodeGen::create);
         add(FastRInterop.ToJavaArray.class, FastRInteropFactory.ToJavaArrayNodeGen::create);

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/RError.java

@@ -123,6 +123,23 @@ public final class RError extends RuntimeException implements TruffleException {
      */
     public static final ErrorContext SHOW_CALLER = new ErrorContextImpl();
 
+    /**
+     * This flags a call to {@code error} or {@code warning} where the error message should show the
+     * caller provided function if such is available. Otherwise the caller of the current function
+     * will be shown.
+     */
+    public static final class ShowCallerOf extends ErrorContext {
+        private final String function;
+
+        public ShowCallerOf(String function) {
+            this.function = function;
+        }
+
+        public String getCallerOf() {
+            return function;
+        }
+    }
+
     /**
      * A very special case that ensures that no caller is output in the error/warning message. This
      * is needed where, even if there is a caller, GnuR does not show it.
@@ -193,7 +210,7 @@ public final class RError extends RuntimeException implements TruffleException {
 
     @TruffleBoundary
     public static RError handleInteropException(Node node, RuntimeException e) {
-        if (e instanceof TruffleException) {
+        if (e instanceof TruffleException || e.getCause() instanceof ClassNotFoundException) {
             if (RContext.getInstance().stateInteropTry.isInTry()) {
                 // will be catched and handled in .fastr.interop.try builtin
                 throw new FastRInteropTryException(e);

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/context/RContext.java

@@ -828,11 +828,29 @@ public final class RContext {
         }
     };
 
-    public Class<?> loadClass(String className) throws ClassNotFoundException {
-        if (FastRConfig.InternalGridAwtSupport) {
-            return interopClassLoader.loadClass(className);
+    private final HashMap<String, Class<?>> classCache = new HashMap<>();
+
+    /**
+     * This function also takes class names with '/' instead of '.'. A null return value means that
+     * the class was not found.
+     */
+    public Class<?> loadClass(String className) {
+        if (classCache.containsKey(className)) {
+            return classCache.get(className);
         }
-        return Class.forName(className);
+        String demangled = className.replaceAll("/", ".");
+        Class<?> result;
+        try {
+            if (FastRConfig.InternalGridAwtSupport) {
+                result = interopClassLoader.loadClass(demangled);
+            } else {
+                result = Class.forName(demangled);
+            }
+        } catch (ClassNotFoundException e) {
+            result = null;
+        }
+        classCache.put(className, result);
+        return result;
     }
 
     /**
@@ -849,6 +867,29 @@ public final class RContext {
             urls[i] = Paths.get(entries[i]).toUri().toURL();
         }
         interopClassLoader = URLClassLoader.newInstance(urls, interopClassLoader);
+        classCache.clear();
+    }
+
+    /**
+     * Returns all entries in the Java interop class loader.
+     * 
+     * @return the CP entries
+     */
+    public String[] getInteropClasspathEntries() {
+        if (!FastRConfig.InternalGridAwtSupport) {
+            throw RError.error(RError.NO_CALLER, RError.Message.GENERIC, "Custom class loading not supported.");
+        }
+        if (interopClassLoader instanceof URLClassLoader) {
+            URL[] urls = ((URLClassLoader) interopClassLoader).getURLs();
+            if (urls != null) {
+                String[] ret = new String[urls.length];
+                for (int i = 0; i < urls.length; i++) {
+                    ret[i] = urls[i].getPath();
+                }
+                return ret;
+            }
+        }
+        return new String[0];
     }
 
     public final class ConsoleIO {

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/interop/ForeignArray2R.java

@@ -267,7 +267,6 @@ public abstract class ForeignArray2R extends RBaseNode {
         int size = arrayData.elements.size();
 
         int[] dims = arrayData.dims != null && arrayData.dims.size() > 1 ? arrayData.dims.stream().mapToInt((i) -> i.intValue()).toArray() : null;
-        assert dims == null || sizeByDims(dims) == size : sizeByDims(dims) + " " + size;
 
         switch (type) {
             case NONE:

com.oracle.truffle.r.test/src/com/oracle/truffle/r/test/ExpectedTestOutput.test

@@ -148283,16 +148283,18 @@ NULL
 [1] "com.oracle.truffle.r.test.library.fastr.TestJavaInterop$TestClass"
 ##com.oracle.truffle.r.test.library.fastr.TestJavaInterop.testGetClass#
-#if (!any(R.version$engine == "FastR")) { cat('Error in java.class(1) : unsupported type', '<<<NEWLINE>>>') } else { java.class(1) }
-Error in java.class(1) : unsupported type
+#if (!any(R.version$engine == "FastR")) { cat('Error in java.class(1) : unsupported type java.lang.Double', '<<<NEWLINE>>>') } else { java.class(1) }
+Error in java.class(1) : unsupported type java.lang.Double
 ##com.oracle.truffle.r.test.library.fastr.TestJavaInterop.testGetClass#
-#if (!any(R.version$engine == "FastR")) { cat('Error in java.class(NULL) : unsupported type', '<<<NEWLINE>>>') } else { java.class(NULL) }
-Error in java.class(NULL) : unsupported type
+#if (!any(R.version$engine == "FastR")) { cat('Error in java.class(NULL) :', '<<<NEWLINE>>>', ' unsupported type com.oracle.truffle.r.runtime.data.RNull', '<<<NEWLINE>>>') } else { java.class(NULL) }
+Error in java.class(NULL) :
+  unsupported type com.oracle.truffle.r.runtime.data.RNull
 ##com.oracle.truffle.r.test.library.fastr.TestJavaInterop.testGetClass#
-#if (!any(R.version$engine == "FastR")) { cat('Error in java.class(to$methodReturnsNull()) : unsupported type', '<<<NEWLINE>>>') } else { to <- new.external(new.java.class('com.oracle.truffle.r.test.library.fastr.TestJavaInterop$TestClass'));java.class(to$methodReturnsNull()) }
-Error in java.class(to$methodReturnsNull()) : unsupported type
+#if (!any(R.version$engine == "FastR")) { cat('Error in java.class(to$methodReturnsNull()) :', '<<<NEWLINE>>>', ' unsupported type com.oracle.truffle.r.runtime.data.RNull', '<<<NEWLINE>>>') } else { to <- new.external(new.java.class('com.oracle.truffle.r.test.library.fastr.TestJavaInterop$TestClass'));java.class(to$methodReturnsNull()) }
+Error in java.class(to$methodReturnsNull()) :
+  unsupported type com.oracle.truffle.r.runtime.data.RNull
 ##com.oracle.truffle.r.test.library.fastr.TestJavaInterop.testIdentical#
 #if (!any(R.version$engine == "FastR")) { FALSE } else { b1 <- as.external.byte(1); b2 <- as.external.byte(1); identical(b1, b2) }

com.oracle.truffle.r.test/src/com/oracle/truffle/r/test/library/fastr/TestJavaInterop.java

@@ -247,9 +247,9 @@ public class TestJavaInterop extends TestBase {
     public void testGetClass() {
         assertEvalFastR(CREATE_TRUFFLE_OBJECT + "java.class(to)", "'com.oracle.truffle.r.test.library.fastr.TestJavaInterop$TestClass'");
 
-        assertEvalFastR(CREATE_TRUFFLE_OBJECT + "java.class(to$methodReturnsNull())", errorIn("java.class(to$methodReturnsNull())", "unsupported type"));
-        assertEvalFastR("java.class(NULL)", errorIn("java.class(NULL)", "unsupported type"));
-        assertEvalFastR("java.class(1)", errorIn("java.class(1)", "unsupported type"));
+        assertEvalFastR(CREATE_TRUFFLE_OBJECT + "java.class(to$methodReturnsNull())", errorIn("java.class(to$methodReturnsNull())", "unsupported type com.oracle.truffle.r.runtime.data.RNull"));
+        assertEvalFastR("java.class(NULL)", errorIn("java.class(NULL)", "unsupported type com.oracle.truffle.r.runtime.data.RNull"));
+        assertEvalFastR("java.class(1)", errorIn("java.class(1)", "unsupported type java.lang.Double"));
     }
 
     @Test