Initial Rust support

.github/workflows/build.yml

@@ -213,7 +213,28 @@ jobs:
       - name: Run Python tests;
         run: |
           ./gradlew test --tests org.lflang.tests.runtime.PythonTest.*
-
+
+  rust-tests:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest, windows-latest]
+        rust: [nightly]
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - name: Setup Java JDK
+        uses: actions/setup-java@v1.4.3
+        with:
+          java-version: 11
+      - name: Setup Rust
+        uses: ATiltedTree/setup-rust@v1
+        with:
+          rust-version: ${{ matrix.rust }}
+          components: clippy
+      - uses: actions/checkout@v2
+      - name: Run Rust tests
+        run: |
+          ./gradlew test --tests org.lflang.tests.runtime.RustTest.*
+
   benchmark-tests:
     runs-on: ubuntu-latest
     steps:

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "xtext/org.icyphy.linguafranca/src/lib/TS/reactor-ts"]
 	path = org.lflang/src/lib/TS/reactor-ts
-	url = https://github.com/icyphy/reactor-ts.git
+	url = https://github.com/lf-lang/reactor-ts.git

bin/update-rust-runtime.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# This script updates the version of the Rust runtime used by
+# LFC and tested in CI. See README.md in Rust code generator
+# directory.
+
+cd "$LOCAL_RUST_REACTOR_RT" || (echo "Set LOCAL_RUST_REACTOR_RT properly plz" && exit 1)
+revision_no="$(git rev-parse HEAD)"
+cd -
+
+# the directory of the script (LF_ROOT/bin)
+script_dir="$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+
+
+echo "$revision_no" > "$script_dir/../org.lflang/src/org/lflang/generator/rust/rust-runtime-version.txt"
+
+echo "updated to $revision_no"

org.lflang.diagram/.classpath

@@ -3,6 +3,7 @@
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="build/xtend/main"/>
 	<classpathentry kind="src" path="xtend-gen"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

org.lflang.lfc/src/org/lflang/lfc/Main.java

@@ -61,7 +61,7 @@ public class Main {
     private static String MAIN_PATH_IN_JAR = String.join("/",
                                                          new String[] {"!", "org", "lflang", "lfc", "Main.class"});
 
-    
+
     /**
      * Object for interpreting command line arguments.
      */
@@ -497,11 +497,11 @@ private void exitIfCollectedErrors() {
             reporter.printFatalErrorAndExit("Aborting due to " + cause);
         }
     }
-    
+
     /**
      * Given a path, obtain a resource and validate it. If issues arise during validation,
      * these are recorded using the issue collector.
-     * 
+     *
      * @param path Path to the resource to validate.
      * @return A validated resource
      */
@@ -517,7 +517,7 @@ private Resource getValidatedResource(Path path) {
         }
 
         List<Issue> issues = this.validator.validate(resource, CheckMode.ALL, CancelIndicator.NullImpl);
-        
+
         for (Issue issue : issues) {
             URI uri = issue.getUriToProblem(); // Issues may also relate to imported resources.
             try {

org.lflang.tests/src/org/lflang/tests/RunSingleTestMain.java

@@ -32,7 +32,12 @@
 import java.util.regex.Pattern;
 
 import org.lflang.Target;
+import org.lflang.tests.runtime.CTest;
+import org.lflang.tests.runtime.CppTest;
+import org.lflang.tests.runtime.PythonTest;
+import org.lflang.tests.runtime.RustTest;
 import org.lflang.tests.runtime.TestBase;
+import org.lflang.tests.runtime.TypeScriptTest;
 
 /**
  * Execute a single test case. Use it with the gradle task
@@ -43,7 +48,7 @@
 public class RunSingleTestMain {
 
 
-    private static final Pattern TEST_FILE_PATTERN = Pattern.compile("(test/(\\w+)/src)/([^/]++/)*(\\w+.lf)");
+    private static final Pattern TEST_FILE_PATTERN = Pattern.compile("(test/(\\w+))/src/([^/]++/)*(\\w+.lf)");
 
     public static void main(String[] args) throws FileNotFoundException {
         if (args.length != 1) {
@@ -62,6 +67,28 @@ public static void main(String[] args) throws FileNotFoundException {
         Path packageRoot = Paths.get(matcher.group(1)).toAbsolutePath();
         Target target = Target.forName(matcher.group(2)).get();
 
-        TestBase.runSingleTestAndPrintResults(new LFTest(target, path.toAbsolutePath(), packageRoot));
+        Class<? extends TestBase> testClass = getTestInstance(target);
+
+        LFTest testCase = new LFTest(target, path.toAbsolutePath(), packageRoot);
+
+        TestBase.runSingleTestAndPrintResults(testCase, testClass);
+    }
+
+    private static Class<? extends TestBase> getTestInstance(Target target) {
+        switch (target) {
+        case C:
+        case CCPP: // todo CCpp
+            return CTest.class;
+        case CPP:
+            return CppTest.class;
+        case TS:
+            return TypeScriptTest.class;
+        case Python:
+            return PythonTest.class;
+        case Rust:
+            return RustTest.class;
+        default:
+            throw new IllegalArgumentException();
+        }
     }
 }

org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.xtend

@@ -841,6 +841,11 @@ class LinguaFrancaValidationTest {
      * name, and the type that it should be.
      */
     val compositeTypeToKnownBad = #{
+        ArrayType.STRING_ARRAY -> #[
+            #["[1 msec]", "[0]", PrimitiveType.STRING],
+            #["[foo, {bar: baz}]", "[1]", PrimitiveType.STRING],
+            #["{bar: baz}", "", ArrayType.STRING_ARRAY]
+        ],
         UnionType.STRING_OR_STRING_ARRAY -> #[
             #["[1 msec]", "[0]", PrimitiveType.STRING],
             #["[foo, {bar: baz}]", "[1]", PrimitiveType.STRING],

org.lflang.tests/src/org/lflang/tests/runtime/CppTest.java

@@ -41,7 +41,7 @@
  */
 public class CppTest extends ThreadedBase {
 
-    CppTest() {
+    public CppTest() {
         this.target = Target.CPP;
     }
 

org.lflang.tests/src/org/lflang/tests/runtime/PythonTest.java

@@ -41,7 +41,7 @@
  */
 public class PythonTest extends TestBase {
 
-    PythonTest() {
+    public PythonTest() {
         this.target = Target.Python;
     }
 

org.lflang.tests/src/org/lflang/tests/runtime/RustTest.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2021, TU Dresden.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.lflang.tests.runtime;
+
+import java.util.Properties;
+
+import org.eclipse.xtext.xbase.lib.InputOutput;
+import org.junit.jupiter.api.Test;
+
+import org.lflang.Target;
+
+/**
+ *
+ */
+public class RustTest extends TestBase {
+
+    public RustTest() {
+        super.target = Target.Rust;
+    }
+
+
+    @Override
+    public void runAsFederated() {
+        this.printTestHeader(TestBase.RUN_AS_FEDERATED_DESC);
+        InputOutput.println("N/A");
+    }
+
+
+    @Override
+    protected void addExtraLfcArgs(Properties args) {
+        // Set this environment variable if you develop the crate locally,
+        // it's more convenient. You'll have to delete test/Rust/src-gen/*
+        // to make a change (and checkout the Cargo.toml back).
+        String path = System.getenv("LOCAL_RUST_REACTOR_RT");
+        if (path != null) {
+            args.setProperty("external-runtime-path", path);
+        }
+    }
+
+
+    @Test
+    @Override
+    public void runGenericTests() {
+        super.runGenericTests();
+    }
+}

org.lflang.tests/src/org/lflang/tests/runtime/TestBase.java

@@ -4,6 +4,8 @@
 
 import java.io.IOException;
 import java.io.PrintStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 import java.nio.file.Files;
 import java.util.Arrays;
 import java.util.EnumSet;
@@ -29,6 +31,7 @@
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.lflang.ASTUtils;
+import org.lflang.CommonExtensionsKt;
 import org.lflang.DefaultErrorReporter;
 import org.lflang.FileConfig;
 import org.lflang.LFRuntimeModule;
@@ -234,9 +237,25 @@ protected final void runTestsAndPrintResults(Target target, Predicate<TestCatego
         }
     }
 
-    public static void runSingleTestAndPrintResults(LFTest test) {
+    /**
+     * Run a test, print results on stderr.
+     *
+     * @param test      Test case.
+     * @param testClass The test class that will execute the test. This is target-specific,
+     *                  it may provide some target-specific configuration. We pass a class
+     *                  and not a new instance because this method needs to ensure the object
+     *                  is properly injected, and so, it needs to control its entire lifecycle.
+     */
+    public static void runSingleTestAndPrintResults(LFTest test, Class<? extends TestBase> testClass) {
         Injector injector = new LFStandaloneSetup(new LFRuntimeModule()).createInjectorAndDoEMFRegistration();
-        TestBase runner = new TestBase(false) {};
+        TestBase runner;
+        try {
+            @SuppressWarnings("unchecked")
+            Constructor<? extends TestBase> constructor = (Constructor<? extends TestBase>) testClass.getConstructors()[0];
+            runner = constructor.newInstance();
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+            throw new IllegalStateException(e);
+        }
         injector.injectMembers(runner);
 
         Set<LFTest> tests = Set.of(test);
@@ -387,12 +406,17 @@ private void execute(LFTest test) {
         switch (test.target) {
         case C:
         case CPP:
+        case Rust:
         case CCPP: {
             var binPath = test.fileConfig.binPath;
             var binaryName = nameOnly;
+            if (test.target == Target.Rust) {
+                // rust binaries uses snake_case
+                binaryName = CommonExtensionsKt.camelToSnakeCase(binaryName);
+            }
             // Adjust binary extension if running on Window
             if (System.getProperty("os.name").startsWith("Windows")) {
-                binaryName = nameOnly + ".exe";
+                binaryName += ".exe";
             }
 
             var fullPath = binPath.resolve(binaryName);

org.lflang.tests/src/org/lflang/tests/runtime/TypeScriptTest.java

@@ -15,7 +15,7 @@
  */
 
 public class TypeScriptTest extends TestBase {
-    TypeScriptTest() {
+    public TypeScriptTest() {
         this.target = Target.TS;
     }
 

org.lflang.ui/.classpath

@@ -3,6 +3,7 @@
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="build/xtend/main"/>
 	<classpathentry kind="src" path="src-gen"/>
 	<classpathentry kind="src" path="xtend-gen"/>
 	<classpathentry kind="output" path="bin"/>

org.lflang/src/org/lflang/ASTUtils.xtend

@@ -1228,7 +1228,7 @@ class ASTUtils {
      * If the value of the parameter is a list of integers,
      * return the sum of value in the list.
      * The instantiations parameter is as in 
-     * {@link initialValue(Parameter, List<Instantiation>}.
+     * {@link initialValue(Parameter, List<Instantiation>)}.
      * 
      * @param parameter The parameter.
      * @param instantiations The (optional) list of instantiations.
@@ -1506,7 +1506,7 @@ class ASTUtils {
      * state variable.
      * @return The inferred type, or "undefined" if none could be inferred.
      */    
-    protected static def InferredType getInferredType(EList<Value> initList) {
+    static def InferredType getInferredType(List<Value> initList) {
         if (initList.size == 1) {
         	// If there is a single element in the list, and it is a proper
         	// time value with units, we infer the type "time".