Python list initializers & equal initializer syntax

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

@@ -915,9 +915,7 @@ class LinguaFrancaSynthesis extends AbstractDiagramSynthesis<Model> {
 		if (!t.nullOrEmpty) {
 			b.append(":").append(t)
 		}
-		if (!param.init.nullOrEmpty) {
-		    b.append("(").append(param.init.join(", ", [it.toText])).append(")")
-		}
+		b.append(ASTUtils.toText(param.init))
 		return b.toString()
 	}
 

org.lflang.diagram/src/org/lflang/diagram/synthesis/util/UtilityExtensions.xtend

@@ -28,26 +28,7 @@ import org.lflang.lf.Value
 class UtilityExtensions extends AbstractSynthesisExtensions {
 
 	extension KGraphFactory = KGraphFactory.eINSTANCE
-
-	/**
-	 * Converts a timing value into readable text
-	 */
-	def String toText(Value value) {
-		if (value !== null) {
-			if (value.parameter !== null) {
-                return value.parameter.name
-            } else if (value.time !== null) {
-                return value.time.interval +
-                        value.time.unit.toString
-            } else if (value.literal !== null) {
-                return value.literal
-            } else if (value.code !== null) {
-                ASTUtils.toText(value.code)
-            }
-		}
-		return ""
-	}
-
+
 	/**
 	 * Converts a host value into readable text
 	 */

org.lflang.tests/src/org/lflang/tests/LFParsingTest.java

@@ -27,7 +27,7 @@ public class LFParsingTest {
 
 
     @Test
-    public void testLexingEmptyTargetProperties() throws Exception {
+    public void testParsingEmptyTargetProperties() throws Exception {
         assertNoParsingErrorsIn("target C { };      \nreactor Foo {}");
         assertNoParsingErrorsIn("target C {a:b,};   \nreactor Foo {}");
         expectParsingErrorIn("target C {,};      \nreactor Foo {}");
@@ -38,6 +38,61 @@ public void testLexingEmptyTargetProperties() throws Exception {
         // assertNoParsingErrorsIn("target C {x:[,]};  \nreactor Foo {}");
     }
 
+    @Test
+    public void testParsingListLiterals() throws Exception {
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p([1,])) {}");
+        // [,] is not an ok list literal
+        expectParsingErrorIn("target Python;      \nreactor Foo(p([,])) {}");
+    }
+
+    @Test
+    public void testParsingInitializers() throws Exception {
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p = [1,]) {}");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p = (1,)) {}");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p = ())   {}");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p = [])   {}");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p = 1)    {}");
+
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = [1,] }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = (1,) }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = ()   }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = []   }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = 1    }");
+
+
+        // [,] is not an ok list literal
+        expectParsingErrorIn("target Python;      \nreactor Foo(p = [,]) {}");
+    }
+
+    @Test
+    public void testParsingParenInitializers() throws Exception {
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p ([1,])) {}");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p ((1,))) {}");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p (()))   {}");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p ([]))   {}");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo(p (1))    {}");
+
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p([1,]) }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p((1,)) }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p(())   }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p([])   }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p(1)    }");
+
+
+        // [,] is not an ok list literal
+        expectParsingErrorIn("target Python;      \nreactor Foo(p([,])) {}");
+    }
+
+    @Test
+    public void testParsingParentheses() throws Exception {
+        // unnecessary parentheses are allowed
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = ((1)) }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = (1) }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = (1,) }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = (1,2) }");
+        assertNoParsingErrorsIn("target Python;   \nreactor Foo{ state p = (1,2,) }");
+    }
+
     @Test
     public void testLexingLifetimeAnnots() throws Exception {
         assertNoParsingErrorsIn(makeLfTargetCode("Rust",

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

@@ -37,6 +37,8 @@ import org.lflang.lf.Instantiation
 import org.lflang.lf.Model
 import org.lflang.lf.Parameter
 import org.lflang.lf.StateVar
+import org.lflang.lf.Value
+import org.lflang.lf.Literal
 import org.lflang.tests.LFInjectorProvider
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
@@ -183,28 +185,28 @@ class LinguaFrancaASTUtilsTest {
         for (parameter : model.eAllContents.filter(Parameter).toList) {
             if (parameter.name == 'x') {
                 var values = ASTUtils.initialValue(parameter, null);
-                Assertions.assertEquals(values.get(0).literal, "1");
+                assertIsLiteral(values.get(0), "1");
 
                 values = ASTUtils.initialValue(parameter, list_a1);
-                Assertions.assertEquals(values.get(0).literal, "2");
+                assertIsLiteral(values.get(0), "2");
 
                 values = ASTUtils.initialValue(parameter, list_a2);
-                Assertions.assertEquals(values.get(0).literal, "-1");
+                assertIsLiteral(values.get(0), "-1");
 
                 values = ASTUtils.initialValue(parameter, list_a1b1);
-                Assertions.assertEquals(values.get(0).literal, "3");
+                assertIsLiteral(values.get(0), "3");
 
                 values = ASTUtils.initialValue(parameter, list_a2b1);
-                Assertions.assertEquals(values.get(0).literal, "-1");
+                assertIsLiteral(values.get(0), "-1");
 
                 values = ASTUtils.initialValue(parameter, list_a1b2);
-                Assertions.assertEquals(values.get(0).literal, "-2");
+                assertIsLiteral(values.get(0), "-2");
 
                 values = ASTUtils.initialValue(parameter, list_a2b2);
-                Assertions.assertEquals(values.get(0).literal, "-1");
+                assertIsLiteral(values.get(0), "-1");
             } else if (parameter.name == 'y') {
                 var values = ASTUtils.initialValue(parameter, null);
-                Assertions.assertEquals(values.get(0).literal, "2");
+                assertIsLiteral(values.get(0), "2");
 
                 try {
                     values = ASTUtils.initialValue(parameter, list_a1);
@@ -213,11 +215,16 @@ class LinguaFrancaASTUtilsTest {
                 }
 
                 values = ASTUtils.initialValue(parameter, list_b1);
-                Assertions.assertEquals(values.get(0).literal, "3");
+                assertIsLiteral(values.get(0), "3");
 
                 values = ASTUtils.initialValue(parameter, list_b2);
-                Assertions.assertEquals(values.get(0).literal, "-2");
+                assertIsLiteral(values.get(0), "-2");
             }
         }
      }
-}
+
+     def static assertIsLiteral(Value v, String literalValue) {
+        Assertions.assertTrue(v instanceof Literal, "Expected a literal, got " + v);
+        Assertions.assertEquals((v as Literal).literal, literalValue);
+     }
+}

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

@@ -283,7 +283,7 @@ class LinguaFrancaValidationTest {
             reactor Foo {
                 output out:int;
             }
-            main reactor Bar {
+            main reactor {
                 output out:int;
                 x = new Foo();
                 x.out -> out;
@@ -495,7 +495,7 @@ class LinguaFrancaValidationTest {
                       printf("Hello World.\n");
                   =}
              }
-        ''').assertError(LfPackage::eINSTANCE.value,
+        ''').assertError(LfPackage::eINSTANCE.timer,
             null, "Missing time units. Should be one of " +
             TimeUnit.VALUES.filter[it != TimeUnit.NONE])
     }    
@@ -513,8 +513,8 @@ class LinguaFrancaValidationTest {
                       printf("Hello World.\n");
                   =}
              }
-        ''').assertError(LfPackage::eINSTANCE.value,
-            null, 'Parameter is not of time type')
+        ''').assertError(LfPackage::eINSTANCE.timer,
+            null, 'Referenced parameter does not have time type.')
 
     }
 
@@ -531,7 +531,7 @@ class LinguaFrancaValidationTest {
                     printf("Hello World.\n");
                 =}
             }
-        ''').assertError(LfPackage::eINSTANCE.value,
+        ''').assertError(LfPackage::eINSTANCE.timer,
             null, 'Invalid time literal')
     }  
 
@@ -667,8 +667,96 @@ class LinguaFrancaValidationTest {
             }
         }
     }
-
-
+
+    @Test
+    def void forbidListLiterals() {
+        parseWithoutError('''
+            target C;
+            reactor Contained {
+                state x: int[]([1, 2]);
+                state y: int[] = [1, 2];
+            }
+        ''').assertError(LfPackage::eINSTANCE.listExpr,
+            null, 'Target C does not support list literals.')
+    }
+
+
+    @Test
+    def void forbidTupleLiterals() {
+        parseWithoutError('''
+            target C; // in C
+            reactor Contained {
+                state x: int[] = (1, 2);
+            }
+        ''').assertError(LfPackage::eINSTANCE.tupleExpr,
+            null, 'Target C does not support tuple literals.')
+    }
+
+
+    @Test
+    def void allowListLiteralsInPython() {
+        parseWithoutError('''
+            target Python;
+            reactor Contained {
+                state x([1, 2]);
+            }
+        ''').assertNoErrors()
+    }
+
+
+    @Test
+    def void forbidMalformedArithmetic() {
+        val model = parseWithoutError('''
+            target Python;
+            reactor Contained(p = 2) {
+                state x0 = 1 + 2 sec; // int + time
+                state x1 = 1 + (2,);  // int + tuple
+                state x2 = 1 + [2];   // int + list
+
+                // following should probs be ok, currently aren't
+
+                state x3 = [2] + [3]; // list + list
+            }
+        ''')
+
+        model.assertError(LfPackage::eINSTANCE.addExpr, null, 'Unexpected operand in arithmetic expression.')
+        model.assertError(LfPackage::eINSTANCE.addExpr, null, 'Unexpected operand in arithmetic expression.')
+        model.assertError(LfPackage::eINSTANCE.addExpr, null, 'Unexpected operand in arithmetic expression.')
+        model.assertError(LfPackage::eINSTANCE.addExpr, null, 'Unexpected operand in arithmetic expression.')
+        model.assertError(LfPackage::eINSTANCE.addExpr, null, 'Unexpected operand in arithmetic expression.')
+    }
+
+
+    @Test
+    def void wellFormedArithmetic() {
+        parseWithoutError('''
+            target Python;
+            reactor Contained(p = 2) {
+                state x1 = 1 * 2
+                state x2 = 1 + 2
+                state x3 = 1 + p
+                state x4 = 1 * p
+                state x5 = "a" + "b"
+                state x6 = "a" + p
+                state x7 = p + "a"
+                state x8 = p * "a"
+
+                // following should probs not be ok, currently are
+                state x9 = "a" * "b";
+            }
+        ''').assertNoErrors()
+    }
+
+    @Test
+    def void typeInferenceWithEqAssignment() {
+        parseWithoutError('''
+            target C;
+            reactor Contained(p = 4 sec) {
+                state x1 = p;
+            }
+        ''').assertNoErrors()
+    }
+
     /**
      * Tests for state and parameter declarations, including native lists.
      */
@@ -691,26 +779,15 @@ class LinguaFrancaValidationTest {
 			}
         ''')
 
-		model.assertError(LfPackage::eINSTANCE.parameter, null,
-            "Type declaration missing.")
-        model.assertError(LfPackage::eINSTANCE.parameter, null,
-            "Missing time units. Should be one of " +
-            	TimeUnit.VALUES.filter[it != TimeUnit.NONE])
-        model.assertError(LfPackage::eINSTANCE.parameter, null,
-            "Invalid time literal.")
-        model.assertError(LfPackage::eINSTANCE.parameter, null,
-            "Time parameter cannot be initialized using a list.")    
-        model.assertError(LfPackage::eINSTANCE.parameter, null,
-            "Parameter cannot be initialized using parameter.")
-        model.assertError(LfPackage::eINSTANCE.stateVar, null,
-            "Referenced parameter does not denote a time.")
-        model.assertError(LfPackage::eINSTANCE.stateVar, null,
-            "Invalid time literal.")
-        model.assertError(LfPackage::eINSTANCE.parameter, null,
-            "Uninitialized parameter.")
-       	model.assertError(LfPackage::eINSTANCE.value, null,
-            "Missing time units. Should be one of " +
-            	TimeUnit.VALUES.filter[it != TimeUnit.NONE])
+		model.assertError(LfPackage::eINSTANCE.parameter, null, "Type declaration missing.")
+        model.assertError(LfPackage::eINSTANCE.parameter, null, "Missing time units. Should be one of " + TimeUnit.VALUES.filter[it != TimeUnit.NONE])
+        model.assertError(LfPackage::eINSTANCE.parameter, null, "Invalid time literal.")
+        model.assertError(LfPackage::eINSTANCE.parameter, null, "Expected exactly one time value.")
+        model.assertError(LfPackage::eINSTANCE.parameter, null, "Parameter cannot be initialized using parameter.")
+        model.assertError(LfPackage::eINSTANCE.stateVar, null, "Referenced parameter does not have time type.")
+        model.assertError(LfPackage::eINSTANCE.stateVar, null, "Invalid time literal.")
+        // model.assertError(LfPackage::eINSTANCE.parameter, null, "Uninitialized parameter.")
+       	model.assertError(LfPackage::eINSTANCE.timer, null, "Missing time units. Should be one of " + TimeUnit.VALUES.filter[it != TimeUnit.NONE])
     }