Equals initializer syntax

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

@@ -34,7 +34,7 @@ public void testSimple() {
 
     @Test
     public void testAssignments() {
-        assertIsFormatted(
+        assertFormatsTo(
             """
                 target C
 
@@ -43,6 +43,15 @@ public void testAssignments() {
                     input in: int
                     state last_invoked: tag_t({= NEVER_TAG_INITIALIZER =})
                 }
+                """,
+            """
+                target C
+
+                reactor Destination {
+                    input ok: bool
+                    input in: int
+                    state last_invoked: tag_t = {= NEVER_TAG_INITIALIZER =}
+                }
                 """
         );
     }
@@ -56,16 +65,34 @@ public void testState() {
                 reactor Destination {
                     state  one_init: tag_t( {= NEVER_TAG_INITIALIZER =})
                     state no_init:   tag_t
-                     state list_init(1,2)
+                     state list_init(1,2) // this syntax is deprecated
                 }
                 """,
             """
                 target Python
 
+                reactor Destination {
+                    state one_init: tag_t = {= NEVER_TAG_INITIALIZER =}
+                    state no_init: tag_t
+                    state list_init(1, 2)  # this syntax is deprecated
+                }
+                """
+        );
+    }
+
+    @Test
+    public void testCppInits() {
+        assertIsFormatted(
+            """
+                target Cpp
+
                 reactor Destination {
                     state one_init: tag_t({= NEVER_TAG_INITIALIZER =})
                     state no_init: tag_t
-                    state list_init(1, 2)
+                    state assign: int = 0
+                    state paren: int(0)
+                    state brace: std::vector<int>{1, 2}
+                    state paren_list: std::vector<int>(1, 2)
                 }
                 """
         );

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

@@ -101,7 +101,7 @@ public void testLet() throws Exception {
         ));
 
         Assertions.assertNotNull(model);
-        final var ctypes = new CTypes(new DefaultErrorReporter());
+        final var ctypes = CTypes.getInstance();
         final var resource = model.eResource();
         final var transformation = new DelayedConnectionTransformation(new CDelayBodyGenerator(ctypes), ctypes, resource, true, true);
         transformation.applyTransformation(ASTUtils.getAllReactors(resource));

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

@@ -3,6 +3,7 @@
 import static java.util.Collections.emptyList;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.fail;
 
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -28,11 +29,15 @@
 public class RoundTripTests {
 
     @Test
-    public void roundTripTest() throws Exception {
+    public void roundTripTest() {
         for (Target target : Target.values()) {
             for (TestCategory category : TestCategory.values()) {
                 for (LFTest test : TestRegistry.getRegisteredTests(target, category, false)) {
-                    run(test.getSrcPath());
+                    try {
+                        run(test.getSrcPath());
+                    } catch (Throwable thrown) {
+                        fail("Test case " + test.getSrcPath() + " failed", thrown);
+                    }
                 }
             }
         }

org.lflang/src/org/lflang/ASTUtils.java

@@ -251,6 +251,14 @@ public static boolean changeTargetName(Resource resource, String newTargetName)
         return true;
     }
 
+    /**
+     * Return the target of the file in which the given node lives.
+     */
+    public static Target getTarget(EObject object) {
+        TargetDecl targetDecl = targetDecl(object.eResource());
+        return Target.fromDecl(targetDecl);
+    }
+
     /**
      * Add a new target property to the given resource.
      *

org.lflang/src/org/lflang/LinguaFranca.xtext

@@ -139,7 +139,7 @@ TargetDecl:
 Initializer:
       parens?='(' (exprs+=Expression (','  exprs+=Expression)* (trailingComma?=',')?)? ')'
     | braces?='{' (exprs+=Expression (','  exprs+=Expression)* (trailingComma?=',')?)? '}'
-//    | assign?='=' exprs+=Expression // todo later
+    | assign?='=' exprs+=Expression
 ;
 
 
@@ -285,13 +285,15 @@ VarRefOrModeTransition returns VarRef:
 
 Assignment:
     lhs=[Parameter]
-    (equals='=')? rhs=AssignmentInitializer
+    rhs=AssignmentInitializer
 ;
 
-// TODO Only allow = based parameter assignment
 AssignmentInitializer returns Initializer:
-      exprs+=Expression
-    | parens?='(' (exprs+=Expression (','  exprs+=Expression)* (trailingComma?=',')?)? ')'
+      assign?='=' exprs+=Expression
+    // these syntaxes are legacy and now deprecated
+    // todo remove in future version.
+    | '='? parens?='(' (exprs+=Expression (','  exprs+=Expression)* (trailingComma?=',')?)? ')'
+    // note: the previous syntax `= { expr* }` is now parsed as a BracedListExpression
     | braces?='{' (exprs+=Expression (','  exprs+=Expression)* (trailingComma?=',')?)? '}'
 ;
 
@@ -310,6 +312,13 @@ Expression:
     | Time
     | ParameterReference
     | {CodeExpr} code=Code
+    | BracedListExpression
+;
+
+// A list of expressions within braces.
+// In C/C++, this is an array initializer, struct initializer, or std::initializer_list.
+BracedListExpression:
+    '{' ( items+=Expression (',' items+=Expression)* )? ','? '}'
 ;
 
 ParameterReference:

org.lflang/src/org/lflang/Target.java

@@ -486,9 +486,7 @@ public boolean supportsMultiports() {
      * on constants).
      */
     public boolean supportsParameterizedWidths() {
-        return switch (this) {
-            case C, CCPP, CPP, Python, Rust, TS -> true;
-        };
+        return true;
     }
 
     /**
@@ -502,6 +500,20 @@ public boolean buildsUsingDocker() {
         };
     }
 
+    /**
+     * Whether the target requires using an equal sign to assign a defaul value to a parameter,
+     * or initialize a state variable. All targets mandate an equal sign when passing
+     * arguments to a reactor constructor call, regardless of this method.
+     */
+    public boolean mandatesEqualsInitializers() {
+        return this != CPP;
+    }
+
+    /** Allow expressions of the form {@code {a, b, c}}. */
+    public boolean allowsBracedListExpressions() {
+        return this == C || this == CCPP || this == CPP;
+    }
+
     /**
      * Return a string that demarcates the beginning of a single-line comment.
      */

org.lflang/src/org/lflang/ast/IsEqual.java

@@ -415,7 +415,6 @@ public Boolean caseVarRef(VarRef object) {
     public Boolean caseAssignment(Assignment object) {
         return new ComparisonMachine<>(object, Assignment.class)
             .equivalent(Assignment::getLhs)
-            .equalAsObjects(Assignment::getEquals)
             .equivalent(Assignment::getRhs)
             .conclusion;
     }

org.lflang/src/org/lflang/ast/ToLf.java

@@ -21,6 +21,7 @@
 import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
 import org.eclipse.xtext.xbase.lib.StringExtensions;
 import org.lflang.ASTUtils;
+import org.lflang.Target;
 import org.lflang.ast.MalleableString.Builder;
 import org.lflang.ast.MalleableString.Joiner;
 import org.lflang.lf.Action;
@@ -29,6 +30,7 @@
 import org.lflang.lf.Assignment;
 import org.lflang.lf.AttrParm;
 import org.lflang.lf.Attribute;
+import org.lflang.lf.BracedListExpression;
 import org.lflang.lf.BuiltinTriggerRef;
 import org.lflang.lf.Code;
 import org.lflang.lf.CodeExpr;
@@ -46,6 +48,7 @@
 import org.lflang.lf.Instantiation;
 import org.lflang.lf.KeyValuePair;
 import org.lflang.lf.KeyValuePairs;
+import org.lflang.lf.LfFactory;
 import org.lflang.lf.Literal;
 import org.lflang.lf.Method;
 import org.lflang.lf.MethodArgument;
@@ -757,14 +760,26 @@ public MalleableString caseSerializer(Serializer object) {
   @Override
   public MalleableString caseKeyValuePairs(KeyValuePairs object) {
     // {KeyValuePairs} '{' (pairs+=KeyValuePair (',' (pairs+=KeyValuePair))* ','?)? '}'
-    if (object.getPairs().isEmpty()) return MalleableString.anyOf("");
+    if (object.getPairs().isEmpty()) {
+      return MalleableString.anyOf("");
+    }
     return new Builder()
         .append("{\n")
         .append(list(",\n", "", "\n", true, true, object.getPairs()).indent())
         .append("}")
         .get();
   }
 
+  @Override
+  public MalleableString caseBracedListExpression(BracedListExpression object) {
+    if (object.getItems().isEmpty()) {
+      return MalleableString.anyOf("{}");
+    }
+    // Note that this strips the trailing comma. There is no way
+    // to implement trailing commas with the current set of list() methods AFAIU.
+    return list(", ", "{ ", " }", false, false, object.getItems());
+  }
+
   @Override
   public MalleableString caseKeyValuePair(KeyValuePair object) {
     // name=Kebab ':' value=Element
@@ -819,9 +834,6 @@ public MalleableString caseAssignment(Assignment object) {
     // ));
     Builder msb = new Builder();
     msb.append(object.getLhs().getName());
-    if (object.getEquals() != null) {
-      msb.append(" = ");
-    }
     msb.append(initializer(object.getRhs(), false));
     return msb.get();
   }
@@ -831,21 +843,36 @@ public MalleableString caseInitializer(Initializer object) {
     return initializer(object, false);
   }
 
+  private boolean shouldOutputAsAssignment(Initializer init) {
+    return init.isAssign()
+        || init.getExprs().size() == 1 && ASTUtils.getTarget(init).mandatesEqualsInitializers();
+  }
+
   private MalleableString initializer(Initializer init, boolean nothingIfEmpty) {
     if (init == null) {
       return MalleableString.anyOf("");
     }
+    if (shouldOutputAsAssignment(init)) {
+      Expression expr = ASTUtils.asSingleExpr(init);
+      Objects.requireNonNull(expr);
+      return new Builder().append(" = ").append(doSwitch(expr)).get();
+    }
+    if (ASTUtils.getTarget(init) == Target.C) {
+      // This turns C array initializers into a braced expression.
+      // C++ variants are not converted.
+      BracedListExpression list = LfFactory.eINSTANCE.createBracedListExpression();
+      list.getItems().addAll(init.getExprs());
+      return new Builder().append(" = ").append(doSwitch(list)).get();
+    }
     String prefix;
     String suffix;
     if (init.isBraces()) {
       prefix = "{";
       suffix = "}";
-    } else if (init.isParens()) {
+    } else {
+      assert init.isParens();
       prefix = "(";
       suffix = ")";
-    } else {
-      // unparenthesized parameter assignment.
-      prefix = suffix = "";
     }
     return list(", ", prefix, suffix, nothingIfEmpty, false, init.getExprs());
   }

org.lflang/src/org/lflang/ast/ToText.java

@@ -10,6 +10,7 @@
 
 import org.lflang.ASTUtils;
 import org.lflang.lf.ArraySpec;
+import org.lflang.lf.BracedListExpression;
 import org.lflang.lf.Code;
 import org.lflang.lf.CodeExpr;
 import org.lflang.lf.Host;
@@ -78,6 +79,11 @@ public String caseCode(Code code) {
         return "";
     }
 
+    @Override
+    public String caseBracedListExpression(BracedListExpression object) {
+        return ToLf.instance.caseBracedListExpression(object).toString();
+    }
+
     @Override
     public String caseHost(Host host) {
         return ToLf.instance.caseHost(host).toString();

org.lflang/src/org/lflang/cli/Lff.java

@@ -147,7 +147,7 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) {
             if (verbose) {
                 reporter.printInfo("Skipped " + path + ": not an LF file");
             }
-            return; 
+            return;
         }
         validateResource(resource);
 
@@ -163,24 +163,28 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) {
                 FileUtil.writeToFile(formattedFileContents, outputPath, true);
             } catch (IOException e) {
                 if (e instanceof FileAlreadyExistsException) {
-                    // Only happens if a subdirectory is named with 
+                    // Only happens if a subdirectory is named with
                     // ".lf" at the end.
                     reporter.printFatalErrorAndExit(
                         "Error writing to "
                         + outputPath
-                        + ": file already exists. Make sure that no file or" 
+                        + ": file already exists. Make sure that no file or"
                         + " directory within provided input paths have the"
                         + " same relative paths.");
                 }
             }
         }
 
         exitIfCollectedErrors();
-        issueCollector.getAllIssues().forEach(reporter::printIssue);
+        // Only errors are printed. Warnings are not helpful for LFF
+        // and since they don't prevent the file from being formatted,
+        // the position of the issue may be wrong in the formatted file.
+        // issueCollector.getAllIssues().forEach(reporter::printIssue);
         if (verbose) {
             String msg = "Formatted " + io.getWd().relativize(path);
-            if (path != outputPath) msg += 
-                " -> " + io.getWd().relativize(outputPath);
+            if (path != outputPath) {
+              msg += " -> " + io.getWd().relativize(outputPath);
+            }
             reporter.printInfo(msg);
         }
     }

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

@@ -1187,12 +1187,11 @@ private String createParameterLabel(ParameterInstance param) {
         b.append(param.getName());
         String t = param.type.toOriginalText();
         if (!StringExtensions.isNullOrEmpty(t)) {
-            b.append(":").append(t);
+            b.append(": ").append(t);
         }
         if (!IterableExtensions.isNullOrEmpty(param.getInitialValue())) {
-            b.append("(");
+            b.append(" = ");
             b.append(IterableExtensions.join(param.getInitialValue(), ", ", ASTUtils::toOriginalText));
-            b.append(")");
         }
         return b.toString();
     }