Restructuring of mechanism for compiling federated programs

.gitignore

@@ -12,6 +12,7 @@
 **/build/
 **/test-bin/
 **/src-gen/
+**/fed-gen/
 **/xtend-gen/
 # Created by https://www.toptal.com/developers/gitignore/api/intellij,gradle,eclipse,maven,visualstudiocode
 # Edit at https://www.toptal.com/developers/gitignore?templates=intellij,gradle,eclipse,maven,visualstudiocode

org.lflang.cli/src/org/lflang/cli/ReportingUtil.kt

@@ -211,7 +211,7 @@ class ReportingBackend constructor(
         val severity = issue.severity
         val filePath = issue.file?.normalize()
 
-        val header = severity.name.toLowerCase(Locale.ROOT)
+        val header = severity.name.lowercase(Locale.ROOT)
 
         var fullMessage: String = this.header + colors.severityColors(header, severity) + colors.bold(": " + issue.message) + System.lineSeparator()
         val snippet: String? = filePath?.let { formatIssue(issue, filePath) }

org.lflang.diagram/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java

@@ -280,7 +280,7 @@ public KNode transform(final Model model) {
                 List<KNode> reactorNodes = new ArrayList<>();
                 for (Reactor reactor : model.getReactors()) {
                     if (reactor == main) continue;
-                    ReactorInstance reactorInstance = new ReactorInstance(reactor, new SynthesisErrorReporter(), new HashSet<>());
+                    ReactorInstance reactorInstance = new ReactorInstance(reactor, new SynthesisErrorReporter());
                     reactorNodes.addAll(createReactorNode(reactorInstance, main == null, 
                             HashBasedTable.<ReactorInstance, PortInstance, KPort>create(), 
                             HashBasedTable.<ReactorInstance, PortInstance, KPort>create(), 

org.lflang.tests/src/org/lflang/tests/TestRegistry.java

@@ -78,7 +78,7 @@ public Set<LFTest> getTests(Target t, TestCategory c) {
      * test file that has a directory in its path that matches an entry in this
      * array will not be discovered.
      */
-    public static final String[] IGNORED_DIRECTORIES = {"failing", "knownfailed", "failed"};
+    public static final String[] IGNORED_DIRECTORIES = {"failing", "knownfailed", "failed", "fed-gen"};
 
     /**
      * Path to the root of the repository.

org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaParsingTest.java

@@ -24,18 +24,18 @@
 ***************/
 package org.lflang.tests.compiler;
 
-import com.google.inject.Inject;
 import org.eclipse.xtext.testing.InjectWith;
 import org.eclipse.xtext.testing.extensions.InjectionExtension;
 import org.eclipse.xtext.testing.util.ParseHelper;
-
-import org.lflang.lf.LfPackage;
-import org.lflang.lf.Model;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+
+import org.lflang.lf.Model;
 import org.lflang.tests.LFInjectorProvider;
 
+import com.google.inject.Inject;
+
 /**
  * Test harness for ensuring that grammar captures
  * all corner cases.

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

@@ -45,6 +45,7 @@
 import org.lflang.TargetProperty.DictionaryElement;
 import org.lflang.TargetProperty.DictionaryType;
 import org.lflang.TargetProperty.PrimitiveType;
+import org.lflang.TargetProperty.StringDictionaryType;
 import org.lflang.TargetProperty.TargetPropertyType;
 import org.lflang.TargetProperty.UnionType;
 import org.lflang.TimeValue;
@@ -1629,6 +1630,25 @@ private List<String> synthesizeExamples(DictionaryType type, boolean correct) {
         }
         return examples;
     }
+
+    private List<String> synthesizeExamples(StringDictionaryType type, boolean correct) {
+        List<String> examples = new LinkedList<>();
+        // Produce a set of singleton dictionaries.
+        // If incorrect examples are wanted, use non-strings for values.
+        List<String> goodStrs = synthesizeExamples(PrimitiveType.STRING, true);
+        List<String> badStrs = synthesizeExamples(PrimitiveType.STRING, false);
+        List<String> goodIDs = List.of("foo", "Bar", "__ab0_9fC", "f1o_O2B_a3r");
+        if (correct) {
+            for (String gs : goodStrs) {
+                goodIDs.forEach(it -> examples.add("{" + it + ": " + gs + "}"));
+            }
+        } else {
+            for (String bs : badStrs) {
+                goodIDs.forEach(it -> examples.add("{" + it + ": " + bs + "}"));
+            }
+        }
+        return examples;
+    }
 
     /**
      * Synthesize a list of values that either conform to the given type or
@@ -1656,6 +1676,8 @@ private List<String> synthesizeExamples(TargetPropertyType type, boolean correct
                 return synthesizeExamples((ArrayType) type, correct);
             } else if (type instanceof DictionaryType) {
                 return synthesizeExamples((DictionaryType) type, correct);
+            } else if (type instanceof StringDictionaryType) {
+                return synthesizeExamples((StringDictionaryType) type, correct);
             } else {
                 Assertions.fail("Encountered an unknown type: " + type);
             }
@@ -1729,9 +1751,15 @@ public void checkTargetProperties() throws Exception {
             List<String> knownIncorrect = synthesizeExamples(prop.type, false);
             if (!(knownIncorrect == null || knownIncorrect.isEmpty())) {
                 for (String it : knownIncorrect) {
-                    validator.assertError(createModel(prop, it), 
-                        LfPackage.eINSTANCE.getKeyValuePair(), null, 
-                        String.format("Target property '%s' is required to be %s.", prop.toString(), prop.type));
+                    if (prop.type instanceof StringDictionaryType) {
+                        validator.assertError(createModel(prop, it),
+                                              LfPackage.eINSTANCE.getKeyValuePair(), null,
+                                              String.format("Target property '%s.", prop), "' is required to be a string.");
+                    } else {
+                        validator.assertError(createModel(prop, it),
+                                              LfPackage.eINSTANCE.getKeyValuePair(), null,
+                                              String.format("Target property '%s' is required to be %s.", prop.toString(), prop.type));
+                    }
                 }
             } else {
                 // No type was synthesized. It must be a composite type.
@@ -2265,6 +2293,28 @@ public void testWrongParamType() throws Exception {
             "Incorrect type: \"value\" should have type String.");
     }
 
+    @Test
+    public void testLanguageAttribute() throws Exception {
+        String testCase = """
+                target Python;
+                main reactor {
+                    @language(value = "C")
+                    reaction(startup) {= =}
+                }
+            """;
+        validator.assertNoIssues(parseWithoutError(testCase));
+
+        testCase = """
+                target Python;
+                main reactor {
+                    @language(value = "Foo")
+                    reaction(startup) {= =}
+                }
+            """;
+        validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAttribute(), null,
+                               "Incorrect language: value should be a supported language");
+    }
+
     @Test
     public void testInitialMode() throws Exception {
         String testCase = """

org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java

@@ -17,7 +17,7 @@ public MockReportProgress() {
 
     @Override
     public void apply(String message, Integer percentage) {
-        System.out.println(message);
+        System.out.printf("%s [%d -> %d]%n", message, previousPercentProgress, percentage);
         if (percentage == null) return;
         if (percentage < previousPercentProgress || percentage < 0 || percentage > 100) failed = true;
         previousPercentProgress = percentage;