[GR-4054] Implemented scopes for FastR.

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

@@ -28,11 +28,13 @@ import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.TruffleLanguage;
+import com.oracle.truffle.api.frame.Frame;
 import com.oracle.truffle.api.frame.FrameDescriptor;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.instrumentation.Instrumenter;
 import com.oracle.truffle.api.instrumentation.ProvidedTags;
 import com.oracle.truffle.api.instrumentation.StandardTags;
+import com.oracle.truffle.api.metadata.ScopeProvider;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.RootNode;
 import com.oracle.truffle.api.source.SourceSection;
@@ -54,6 +56,7 @@ import com.oracle.truffle.r.runtime.context.RContext.RCloseable;
 import com.oracle.truffle.r.runtime.data.RFunction;
 import com.oracle.truffle.r.runtime.data.RPromise;
 import com.oracle.truffle.r.runtime.data.RTypedValue;
+import com.oracle.truffle.r.runtime.env.RScope;
 import com.oracle.truffle.r.runtime.ffi.RFFIFactory;
 import com.oracle.truffle.r.runtime.nodes.RBaseNode;
 
@@ -63,7 +66,7 @@ import com.oracle.truffle.r.runtime.nodes.RBaseNode;
  */
 @TruffleLanguage.Registration(name = "R", version = "0.1", mimeType = {RRuntime.R_APP_MIME, RRuntime.R_TEXT_MIME}, interactive = true)
 @ProvidedTags({StandardTags.CallTag.class, StandardTags.StatementTag.class, StandardTags.RootTag.class, RSyntaxTags.LoopTag.class})
-public final class TruffleRLanguage extends TruffleLanguage<RContext> {
+public final class TruffleRLanguage extends TruffleLanguage<RContext> implements ScopeProvider<RContext> {
 
     /**
      * The choice of {@link RFFIFactory} is made statically so that it is bound into an AOT-compiled
@@ -242,4 +245,9 @@ public final class TruffleRLanguage extends TruffleLanguage<RContext> {
     public RContext actuallyFindContext0(Node contextNode) {
         return findContext(contextNode);
     }
+
+    @Override
+    public AbstractScope findScope(RContext langContext, Node node, Frame frame) {
+        return RScope.createScope(node, frame);
+    }
 }

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/env/RScope.java

+/*
+ * Copyright (c) 2014, 2017, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.r.runtime.env;
+
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.frame.Frame;
+import com.oracle.truffle.api.interop.ForeignAccess;
+import com.oracle.truffle.api.interop.Message;
+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.interop.UnsupportedMessageException;
+import com.oracle.truffle.api.metadata.ScopeProvider.AbstractScope;
+import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.r.runtime.ArgumentsSignature;
+import com.oracle.truffle.r.runtime.RArguments;
+import com.oracle.truffle.r.runtime.RInternalError;
+import com.oracle.truffle.r.runtime.data.RFunction;
+import com.oracle.truffle.r.runtime.data.RStringVector;
+import com.oracle.truffle.r.runtime.env.REnvironment.PutException;
+
+/**
+ * Represents a variable scope for external tools like a debugger.<br>
+ * This is basically a view on R environments.
+ */
+public final class RScope extends AbstractScope {
+
+    private final Node current;
+    private REnvironment env;
+
+    /**
+     * Intended to be used when creating a parent scope where we do not know any associated node.
+     */
+    private RScope(REnvironment env) {
+        this.env = env;
+        this.current = null;
+    }
+
+    private RScope(Node current, REnvironment env) {
+        this.current = current;
+        this.env = env;
+    }
+
+    @Override
+    protected String getName() {
+        // TODO promises (= closure)
+        return "function";
+    }
+
+    @Override
+    protected Node getNode() {
+        return current;
+    }
+
+    @Override
+    protected Object getVariables(Frame frame) {
+        return new VariablesMapObject(env, false);
+    }
+
+    private static REnvironment getEnv(Frame frame) {
+        assert RArguments.isRFrame(frame);
+        return REnvironment.frameToEnvironment(frame.materialize());
+    }
+
+    @Override
+    protected Object getArguments(Frame frame) {
+        return new VariablesMapObject(env, true);
+    }
+
+    @Override
+    protected AbstractScope findParent() {
+        if (this.env == REnvironment.emptyEnv()) {
+            return null;
+        }
+
+        return new RScope(env.getParent());
+    }
+
+    private static String[] ls(REnvironment env) {
+        RStringVector ls = env.ls(true, null, false);
+        return ls.getDataWithoutCopying();
+    }
+
+    private static String[] collectArgs(REnvironment env) {
+        ArgumentsSignature signature = RArguments.getSignature(env.getFrame());
+        return signature.getNames();
+    }
+
+    public static RScope createScope(Node node, Frame frame) {
+        return new RScope(node.getRootNode(), getEnv(frame));
+    }
+
+    private static Object getInteropValue(Object value) {
+        return value;
+    }
+
+    static final class VariablesMapObject implements TruffleObject {
+
+        private final REnvironment env;
+        private final boolean argumentsOnly;
+
+        private VariablesMapObject(REnvironment env, boolean argumentsOnly) {
+            this.env = env;
+            this.argumentsOnly = argumentsOnly;
+        }
+
+        @Override
+        public ForeignAccess getForeignAccess() {
+            return VariablesMapMessageResolutionForeign.ACCESS;
+        }
+
+        public static boolean isInstance(TruffleObject obj) {
+            return obj instanceof VariablesMapObject;
+        }
+
+        @MessageResolution(receiverType = VariablesMapObject.class)
+        static final class VariablesMapMessageResolution {
+
+            @Resolve(message = "KEYS")
+            abstract static class VarsMapKeysNode extends Node {
+
+                @TruffleBoundary
+                public Object access(VariablesMapObject varMap) {
+                    if (varMap.argumentsOnly) {
+                        return new ArgumentNamesObject(collectArgs(varMap.env));
+                    } else {
+                        return new VariableNamesObject(varMap.env);
+                    }
+                }
+            }
+
+            @Resolve(message = "KEY_INFO")
+            public abstract static class VarMapsKeyInfoNode extends Node {
+
+                private static final int READABLE = 1 << 1;
+                private static final int WRITABLE = 1 << 2;
+                private static final int INVOCABLE = 1 << 3;
+
+                @SuppressWarnings("try")
+                protected Object access(VariablesMapObject receiver, String identifier) {
+                    int info = READABLE;
+
+                    if (!receiver.env.bindingIsLocked(identifier)) {
+                        info += WRITABLE;
+                    }
+                    if (receiver.env.get(identifier) instanceof RFunction) {
+                        info += INVOCABLE;
+                    }
+                    return info;
+                }
+            }
+
+            @Resolve(message = "READ")
+            abstract static class VarsMapReadNode extends Node {
+
+                @TruffleBoundary
+                public Object access(VariablesMapObject varMap, String name) {
+                    if (varMap.env == null) {
+                        throw UnsupportedMessageException.raise(Message.READ);
+                    }
+                    Object value = varMap.env.get(name);
+
+                    // If Java-null is returned, the identifier does not exist !
+                    if (value == null) {
+                        throw UnknownIdentifierException.raise(name);
+                    } else {
+                        return getInteropValue(value);
+                    }
+                }
+            }
+
+            @Resolve(message = "WRITE")
+            abstract static class VarsMapWriteNode extends Node {
+
+                @TruffleBoundary
+                public Object access(VariablesMapObject varMap, String name, Object value) {
+                    if (varMap.env == null) {
+                        throw UnsupportedMessageException.raise(Message.WRITE);
+                    }
+                    try {
+                        varMap.env.put(name, value);
+                        return value;
+                    } catch (PutException e) {
+                        throw RInternalError.shouldNotReachHere(e);
+                    }
+                }
+            }
+
+        }
+    }
+
+    static final class VariableNamesObject implements TruffleObject {
+
+        private final REnvironment env;
+
+        private VariableNamesObject(REnvironment env) {
+            this.env = env;
+        }
+
+        @Override
+        public ForeignAccess getForeignAccess() {
+            return VariableNamesMessageResolutionForeign.ACCESS;
+        }
+
+        public static boolean isInstance(TruffleObject obj) {
+            return obj instanceof VariableNamesObject;
+        }
+
+        @MessageResolution(receiverType = VariableNamesObject.class)
+        static final class VariableNamesMessageResolution {
+
+            @Resolve(message = "HAS_SIZE")
+            abstract static class VarNamesHasSizeNode extends Node {
+
+                @SuppressWarnings("unused")
+                public Object access(VariableNamesObject varNames) {
+                    return true;
+                }
+            }
+
+            @Resolve(message = "GET_SIZE")
+            abstract static class VarNamesGetSizeNode extends Node {
+
+                public Object access(VariableNamesObject varNames) {
+                    return ls(varNames.env).length;
+                }
+            }
+
+            @Resolve(message = "READ")
+            abstract static class VarNamesReadNode extends Node {
+
+                @TruffleBoundary
+                public Object access(VariableNamesObject varNames, int index) {
+                    String[] names = ls(varNames.env);
+                    if (index >= 0 && index < names.length) {
+                        return names[index];
+                    } else {
+                        throw UnknownIdentifierException.raise(Integer.toString(index));
+                    }
+                }
+            }
+
+        }
+    }
+
+    static final class ArgumentNamesObject implements TruffleObject {
+
+        private final String[] names;
+
+        private ArgumentNamesObject(String[] names) {
+            this.names = names;
+        }
+
+        @Override
+        public ForeignAccess getForeignAccess() {
+            return VariableNamesMessageResolutionForeign.ACCESS;
+        }
+
+        public static boolean isInstance(TruffleObject obj) {
+            return obj instanceof ArgumentNamesObject;
+        }
+
+        @MessageResolution(receiverType = ArgumentNamesObject.class)
+        static final class ArgumentNamesMessageResolution {
+
+            @Resolve(message = "HAS_SIZE")
+            abstract static class ArgNamesHasSizeNode extends Node {
+
+                @SuppressWarnings("unused")
+                public Object access(ArgumentNamesObject varNames) {
+                    return true;
+                }
+            }
+
+            @Resolve(message = "GET_SIZE")
+            abstract static class ArgNamesGetSizeNode extends Node {
+
+                public Object access(ArgumentNamesObject varNames) {
+                    return varNames.names.length;
+                }
+            }
+
+            @Resolve(message = "READ")
+            abstract static class ArgNamesReadNode extends Node {
+
+                @TruffleBoundary
+                public Object access(ArgumentNamesObject varNames, int index) {
+                    if (index >= 0 && index < varNames.names.length) {
+                        return varNames.names[index];
+                    } else {
+                        throw UnknownIdentifierException.raise(Integer.toString(index));
+                    }
+                }
+            }
+
+        }
+    }
+
+}

com.oracle.truffle.r.test/src/com/oracle/truffle/r/test/tck/FastRDebugTest.java

@@ -29,7 +29,9 @@ import static org.junit.Assert.assertTrue;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.util.HashSet;
 import java.util.LinkedList;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.After;
@@ -38,6 +40,7 @@ import org.junit.Before;
 import org.junit.Test;
 
 import com.oracle.truffle.api.debug.Breakpoint;
+import com.oracle.truffle.api.debug.DebugScope;
 import com.oracle.truffle.api.debug.DebugStackFrame;
 import com.oracle.truffle.api.debug.DebugValue;
 import com.oracle.truffle.api.debug.Debugger;
@@ -54,6 +57,7 @@ import com.oracle.truffle.r.runtime.context.ContextInfo;
 import com.oracle.truffle.r.runtime.context.DefaultConsoleHandler;
 import com.oracle.truffle.r.runtime.context.RContext.ContextKind;
 import com.oracle.truffle.r.runtime.data.RPromise.EagerPromise;
+import com.oracle.truffle.r.runtime.env.REnvironment;
 import com.oracle.truffle.r.runtime.env.frame.RFrameSlot;
 
 public class FastRDebugTest {
@@ -230,6 +234,136 @@ public class FastRDebugTest {
         assertExecutedOK();
     }
 
+    @Test
+    public void testScopeFunction() throws Throwable {
+        final Source srcFunMain = RSource.fromTextInternal("function () {\n" +
+                        "    i = 3L\n" +
+                        "    n = 15L\n" +
+                        "    str = \"hello\"\n" +
+                        "    i <- i + 1L\n" +
+                        "    ab <<- i\n" +
+                        "    i\n" +
+                        "}", RSource.Internal.DEBUGTEST_DEBUG);
+        final Source source = RSource.fromTextInternal("x <- 10L\n" +
+                        "makeActiveBinding('ab', function(v) { if(missing(v)) x else x <<- v }, .GlobalEnv)\n" +
+                        "main <- " + srcFunMain.getCode() + "\n",
+                        RSource.Internal.DEBUGTEST_DEBUG);
+        engine.eval(source);
+
+        // @formatter:on
+        run.addLast(() -> {
+            assertNull(suspendedEvent);
+            assertNotNull(debuggerSession);
+            debuggerSession.suspendNextExecution();
+        });
+
+        assertLocation(1, "main()", "x", 10, "ab", 10, "main", srcFunMain.getCode());
+        stepInto(1);
+        assertLocation(4, "i = 3L");
+        stepOver(1);
+        assertLocation(5, "n = 15L", "i", 3);
+        stepOver(1);
+        assertLocation(6, "str = \"hello\"", "i", 3, "n", 15);
+        stepOver(1);
+        assertLocation(7, "i <- i + 1L", "i", 3, "n", 15, "str", "hello");
+        stepOver(1);
+        assertLocation(8, "ab <<- i", "i", 4, "n", 15, "str", "hello");
+        stepOver(1);
+        assertScope(9, "i", true, false, "ab", 4, "x", 4);
+        stepOut();
+        assertLocation(1, "main()", "x", 4, "ab", 4, "main", srcFunMain.getCode());
+        performWork();
+
+        final Source evalSource = RSource.fromTextInternal("main()\n", RSource.Internal.DEBUGTEST_EVAL);
+        engine.eval(evalSource);
+
+        assertExecutedOK();
+    }
+
+    @Test
+    public void testScopePromise() throws Throwable {
+        final Source source = RSource.fromTextInternal("main <- function(e) {\n" +
+                        "   x <- 10L\n" +
+                        "   e()\n" +
+                        "   x\n" +
+                        "}\n" +
+                        "closure <- function() {\n" +
+                        "   x <<- 123L\n" +
+                        "   x\n" +
+                        "}\n",
+
+                        RSource.Internal.DEBUGTEST_DEBUG);
+        engine.eval(source);
+
+        // @formatter:on
+        run.addLast(() -> {
+            assertNull(suspendedEvent);
+            assertNotNull(debuggerSession);
+            debuggerSession.suspendNextExecution();
+        });
+
+        stepOver(1);
+        stepInto(1);
+        stepOver(1);
+        assertScope(3, "e()", false, false, "x", 10);
+        stepInto(1);
+        assertLocation(7, "x <<- 123L");
+        assertScope(7, "x <<- 123L", true, false, "x", 0);
+        stepOver(1);
+        assertScope(8, "x", true, false, "x", 123);
+        continueExecution();
+        performWork();
+
+        final Source evalSource = RSource.fromTextInternal("x <- 0L\nmain(closure)\n", RSource.Internal.DEBUGTEST_EVAL);
+        engine.eval(evalSource);
+
+        assertExecutedOK();
+    }
+
+    @Test
+    public void testChangedScopeChain() throws Throwable {
+        final Source source = RSource.fromTextInternal("main <- function(e) {\n" +
+                        "   x <- 10L\n" +
+                        "   environment(e) <- environment()\n" +
+                        "   e()\n" +
+                        "   x\n" +
+                        "}\n" +
+                        "closure <- function() {\n" +
+                        "   x <<- 123L\n" +
+                        "   x\n" +
+                        "}\n",
+                        RSource.Internal.DEBUGTEST_DEBUG);
+        engine.eval(source);
+
+        // @formatter:on
+        run.addLast(() -> {
+            assertNull(suspendedEvent);
+            assertNotNull(debuggerSession);
+            debuggerSession.suspendNextExecution();
+        });
+
+        stepOver(1);
+        stepInto(1);
+        stepOver(2);
+        assertScope(4, "e()", false, false, "x", 10);
+        stepInto(1);
+        assertLocation(8, "x <<- 123L");
+        assertScope(8, "x <<- 123L", true, false, "x", 10);
+        stepOver(1);
+        stepOut();
+        assertScope(9, "x", false, false, "x", 123);
+        assertIdentifiers(false, "x", "e");
+        stepOut();
+        assertScope(9, "x", false, false, "x", 0);
+        continueExecution();
+        performWork();
+
+        final Source evalSource = RSource.fromTextInternal("x <- 0L\nmain(closure)\n", RSource.Internal.DEBUGTEST_EVAL);
+        engine.eval(evalSource);
+
+        assertExecutedOK();
+    }
+
     private void performWork() {
         try {
             if (ex == null && !run.isEmpty()) {
@@ -246,7 +380,7 @@ public class FastRDebugTest {
     }
 
     private void stepOut() {
-        run.addLast(() -> suspendedEvent.prepareStepOut());
+        run.addLast(() -> suspendedEvent.prepareStepOut(1));
     }
 
     private void continueExecution() {
@@ -257,6 +391,30 @@ public class FastRDebugTest {
         run.addLast(() -> suspendedEvent.prepareStepInto(size));
     }
 
+    private void assertIdentifiers(boolean includeAncestors, String... identifiers) {
+        run.addLast(() -> {
+
+            final DebugStackFrame frame = suspendedEvent.getTopStackFrame();
+            DebugScope scope = frame.getScope();
+
+            Set<String> actualIdentifiers = new HashSet<>();
+            do {
+                scope.getDeclaredValues().forEach((x) -> actualIdentifiers.add(x.getName()));
+            } while (includeAncestors && scope != null && !REnvironment.baseEnv().getName().equals(scope.getName()));
+
+            Set<String> expected = new HashSet<>();
+            for (String s : identifiers) {
+                expected.add(s);
+            }
+
+            assertEquals(expected, actualIdentifiers);
+
+            if (!run.isEmpty()) {
+                run.removeFirst().run();
+            }
+        });
+    }
+
     private void assertLocation(final int line, final String code, final Object... expectedFrame) {
         run.addLast(() -> {
             try {
@@ -265,31 +423,33 @@ public class FastRDebugTest {
                 assertEquals(line, currentLine);
                 final String currentCode = suspendedEvent.getSourceSection().getCode().trim();
                 assertEquals(code, currentCode);
-                final DebugStackFrame frame = suspendedEvent.getTopStackFrame();
+                compareScope(line, code, false, true, expectedFrame);
+            } catch (RuntimeException | Error e) {
 
-                final AtomicInteger numFrameVars = new AtomicInteger(0);
+                final DebugStackFrame frame = suspendedEvent.getTopStackFrame();
                 frame.forEach(var -> {
-                    // skip synthetic slots
-                    for (RFrameSlot slot : RFrameSlot.values()) {
-                        if (slot.toString().equals(var.getName())) {
-                            return;
-                        }
-                    }
-                    numFrameVars.incrementAndGet();
+                    System.out.println(var);
                 });
-                assertEquals(line + ": " + code, expectedFrame.length / 2, numFrameVars.get());
-
-                for (int i = 0; i < expectedFrame.length; i = i + 2) {
-                    String expectedIdentifier = (String) expectedFrame[i];
-                    Object expectedValue = expectedFrame[i + 1];
-                    String expectedValueStr = (expectedValue != null) ? expectedValue.toString() : null;
-                    DebugValue value = frame.getValue(expectedIdentifier);
-                    assertNotNull(value);
-                    String valueStr = value.as(String.class);
-                    assertEquals(expectedValueStr, valueStr);
-                }
+                throw e;
+            }
+        });
+    }
 
-                run.removeFirst().run();
+    /**
+     * Ensure that the scope at a certain program position contains an expected set of key-value
+     * pairs.
+     *
+     * @param line line number
+     * @param code the code snippet of the program location
+     * @param includeAncestors Include current scope's ancestors for the identifier lookup.
+     * @param completeMatch {@code true} if the defined key-value pairs should be the only pairs in
+     *            the scope.
+     * @param expectedFrame the key-value pairs (e.g. {@code "id0", 1, "id1", "strValue"})
+     */
+    private void assertScope(final int line, final String code, boolean includeAncestors, boolean completeMatch, final Object... expectedFrame) {
+        run.addLast(() -> {
+            try {
+                compareScope(line, code, includeAncestors, completeMatch, expectedFrame);
             } catch (RuntimeException | Error e) {
 
                 final DebugStackFrame frame = suspendedEvent.getTopStackFrame();
@@ -301,6 +461,43 @@ public class FastRDebugTest {
         });
     }
 
+    private void compareScope(final int line, final String code, boolean includeAncestors, boolean completeMatch, final Object[] expectedFrame) {
+        final DebugStackFrame frame = suspendedEvent.getTopStackFrame();
+
+        final AtomicInteger numFrameVars = new AtomicInteger(0);
+        frame.forEach(var -> {
+            // skip synthetic slots
+            for (RFrameSlot slot : RFrameSlot.values()) {
+                if (slot.toString().equals(var.getName())) {
+                    return;
+                }
+            }
+            numFrameVars.incrementAndGet();
+        });
+        if (completeMatch) {
+            assertEquals(line + ": " + code, expectedFrame.length / 2, numFrameVars.get());
+        }
+
+        for (int i = 0; i < expectedFrame.length; i = i + 2) {
+            String expectedIdentifier = (String) expectedFrame[i];
+            Object expectedValue = expectedFrame[i + 1];
+            String expectedValueStr = (expectedValue != null) ? expectedValue.toString() : null;
+            DebugScope scope = frame.getScope();
+            DebugValue value;
+            do {
+                value = scope.getDeclaredValue(expectedIdentifier);
+                scope = scope.getParent();
+            } while (includeAncestors && value == null && scope != null && !REnvironment.baseEnv().getName().equals(scope.getName()));
+            assertNotNull("identifier \"" + expectedIdentifier + "\" not found", value);
+            String valueStr = value.as(String.class);
+            assertEquals(expectedValueStr, valueStr);
+        }
+
+        if (!run.isEmpty()) {
+            run.removeFirst().run();
+        }
+    }
+
     Object getRValue(Object value) {
         // This will only work in simple cases
         if (value instanceof EagerPromise) {

mx.fastr/suite.py

@@ -29,7 +29,7 @@ suite = {
             {
                "name" : "truffle",
                "subdir" : True,
-               "version" : "7d960d6682ef3636cc7455e28132c1e537ea81f0",
+               "version" : "acbe9ec935090e0824372e508563c122b0e46682",
                "urls" : [
                     {"url" : "https://github.com/graalvm/graal", "kind" : "git"},
                     {"url" : "https://curio.ssw.jku.at/nexus/content/repositories/snapshots", "kind" : "binary"},