Python list initializers & equal initializer syntax

build.gradle

@@ -12,6 +12,7 @@ plugins {
     id "com.github.johnrengelman.shadow" version "${shadowJarVersion}"
     id 'java'
     id 'jacoco'
+    id 'org.jetbrains.kotlin.jvm' version "${kotlinVersion}"
 }
 
 subprojects {

gradle.properties

@@ -10,7 +10,7 @@ jupiterVersion=5.8.2
 jUnitPlatformVersion=1.8.2
 jUnitVersion=4.13.2
 kotlinJvmTarget=11
-kotlinVersion=1.4.30
+kotlinVersion=1.5.31
 lsp4jVersion=0.12.0
 mwe2LaunchVersion=2.12.1
 openTest4jVersion=1.2.0

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/TestBase.java

@@ -295,8 +295,12 @@ public static void runSingleTestAndPrintResults(LFTest test, Class<? extends Tes
         Injector injector = new LFStandaloneSetup(new LFRuntimeModule()).createInjectorAndDoEMFRegistration();
         TestBase runner;
         try {
+            Constructor<?>[] ctors = testClass.getConstructors();
+            if (ctors.length == 0) {
+                throw new IllegalStateException("No public constructor in " + testClass);
+            }
             @SuppressWarnings("unchecked")
-            Constructor<? extends TestBase> constructor = (Constructor<? extends TestBase>) testClass.getConstructors()[0];
+            Constructor<? extends TestBase> constructor = (Constructor<? extends TestBase>) ctors[0];
             runner = constructor.newInstance();
         } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
             throw new IllegalStateException(e);

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

@@ -44,9 +44,11 @@
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.lflang.ASTUtils;
 import org.lflang.lf.Instantiation;
+import org.lflang.lf.Literal;
 import org.lflang.lf.Model;
 import org.lflang.lf.Parameter;
 import org.lflang.lf.StateVar;
+import org.lflang.lf.Value;
 import org.lflang.tests.LFInjectorProvider;
 
 /**
@@ -222,34 +224,34 @@ public void initialValue() throws Exception {
                 Parameter parameter = (Parameter)obj;
                 if (parameter.getName() == "x") {
                     var values = ASTUtils.initialValue(parameter, null);
-                    Assertions.assertEquals(values.get(0).getLiteral(), "1");
+                    Assertions.assertEquals(asLiteral(values), "1");
 
                     values = ASTUtils.initialValue(parameter,
                             List.of(map.get("a1")));
-                    Assertions.assertEquals(values.get(0).getLiteral(), "2");
+                    Assertions.assertEquals(asLiteral(values), "2");
 
                     values = ASTUtils.initialValue(parameter,
                             List.of(map.get("a2")));
-                    Assertions.assertEquals(values.get(0).getLiteral(), "-1");
+                    Assertions.assertEquals(asLiteral(values), "-1");
 
                     values = ASTUtils.initialValue(parameter,
                             List.of(map.get("a1"), map.get("b1")));
-                    Assertions.assertEquals(values.get(0).getLiteral(), "3");
+                    Assertions.assertEquals(asLiteral(values), "3");
 
                     values = ASTUtils.initialValue(parameter,
                             List.of(map.get("a2"), map.get("b1")));
-                    Assertions.assertEquals(values.get(0).getLiteral(), "-1");
+                    Assertions.assertEquals(asLiteral(values), "-1");
 
                     values = ASTUtils.initialValue(parameter,
                             List.of(map.get("a1"), map.get("b2")));
-                    Assertions.assertEquals(values.get(0).getLiteral(), "-2");
+                    Assertions.assertEquals(asLiteral(values), "-2");
 
                     values = ASTUtils.initialValue(parameter,
                             List.of(map.get("a2"), map.get("b2")));
-                    Assertions.assertEquals(values.get(0).getLiteral(), "-1");
+                    Assertions.assertEquals(asLiteral(values), "-1");
                 } else if (parameter.getName() == "y") {
                     var values = ASTUtils.initialValue(parameter, null);
-                    Assertions.assertEquals(values.get(0).getLiteral(), "2");
+                    Assertions.assertEquals(asLiteral(values), "2");
 
                     try {
                         values = ASTUtils.initialValue(parameter,
@@ -261,13 +263,17 @@ public void initialValue() throws Exception {
 
                     values = ASTUtils.initialValue(parameter,
                             List.of(map.get("b1")));
-                    Assertions.assertEquals(values.get(0).getLiteral(), "3");
+                    Assertions.assertEquals(asLiteral(values), "3");
 
                     values = ASTUtils.initialValue(parameter,
                             List.of(map.get("b2")));
-                    Assertions.assertEquals(values.get(0).getLiteral(), "-2");
+                    Assertions.assertEquals(asLiteral(values), "-2");
                 }
             }
         });
     }
+
+    private Object asLiteral(List<Value> values) {
+        return ((Literal) values.get(0)).getLiteral();
+    }
 }

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

@@ -906,7 +906,7 @@ public void nonzeroAfterMustHaveUnits() throws Exception {
             "    b = new X()",
             "    a.y -> b.x after 1",
             "}");
-        validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTime(),
+        validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(),
             null, "Missing time unit.");
     }
 
@@ -936,7 +936,7 @@ public void nonZeroTimeValueWithoutUnits() throws Exception {
             "        printf(\"Hello World.\\n\");",
             "    =}",
             "}");
-        validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getValue(), null, "Missing time unit.");
+        validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, "Missing time unit.");
     }    
 
     /**
@@ -963,8 +963,8 @@ public void parameterTypeMismatch() throws Exception {
             "        printf(\"Hello World.\\n\");",
             "    =}",
             "}");
-        validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getValue(),
-            null, "Parameter is not of time type");
+        validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(),
+            null, "Referenced parameter does not have time type.");
     }
 
     /**
@@ -991,7 +991,7 @@ public void targetCodeInTimeArgument() throws Exception {
             "        printf(\"Hello World.\\n\");",
             "    =}",
             "}");
-        validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getValue(),
+        validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(),
             null, "Invalid time literal");
     }  
 
@@ -1095,7 +1095,7 @@ public void overflowingAssignmentC() throws Exception {
         validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAssignment(), null,
             "Time value used to specify a deadline exceeds the maximum of " +
             TimeValue.MAX_LONG_DEADLINE + " nanoseconds.");
-    }  
+    }
 
     /**
      * Report missing trigger.
@@ -1242,20 +1242,19 @@ public void stateAndParameterDeclarationsInC() throws Exception {
 		validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null,
             "Type declaration missing.");
         validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null,
-            "Missing time unit.");
+                              "Uninitialized parameter.");
         validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null,
-            "Invalid time literal.");
+            "Missing time unit.");
         validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null,
-            "Time parameter cannot be initialized using a list.");   
+            "Expected exactly one time value.");
+        validator.assertError(model, LfPackage.eINSTANCE.getStateVar(), null,
+                              "Missing time unit.");
         validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null,
             "Parameter cannot be initialized using parameter.");
+
         validator.assertError(model, LfPackage.eINSTANCE.getStateVar(), null,
-            "Referenced parameter does not denote a time.");
-        validator.assertError(model, LfPackage.eINSTANCE.getStateVar(), null,
-            "Invalid time literal.");
-        validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null,
-            "Uninitialized parameter.");
-       	validator.assertError(model, LfPackage.eINSTANCE.getValue(), null,
+            "Referenced parameter does not have time type.");
+        validator.assertError(model, LfPackage.eINSTANCE.getTimer(), null,
             "Missing time unit.");
     }  
 

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

@@ -1,5 +1,8 @@
 package org.lflang.tests.lsp;
 
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+
 import java.io.Closeable;
 import java.io.IOException;
 import java.io.PrintWriter;
@@ -14,6 +17,7 @@
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import com.google.common.collect.ImmutableList;
@@ -164,8 +168,30 @@ public void insert(String line, Random random) {
             });
         }
 
+        /**
+         * Get the text of the test around the given line,
+         * for error reporting.
+         */
+        public String getLinesAround(int line) {
+            final int LINES_AROUND = 2;
+            int minLine = max(0, line - LINES_AROUND);
+            List<String> linesAround =
+                lines.stream().skip(minLine).limit(2 * LINES_AROUND + 1).collect(Collectors.toList());
+            // prefix each line with its line number
+            ListIterator<String> iter = linesAround.listIterator();
+            int i = 0;
+            while (iter.hasNext()) {
+                String next = iter.next();
+                int lineNo = minLine + i;
+                iter.set(lineNo + "| " + next);
+                i++;
+            }
+            return String.join("\n", linesAround);
+        }
+
         /**
          * Alter the content of this test.
+         *
          * @param alterer A function whose first argument is an iterator over the lines of {@code this}, whose second
          *                argument is the line most recently returned by that iterator, and whose return value is
          *                whether an alteration was successfully performed. This function is only applied within

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

@@ -104,6 +104,9 @@ private void targetLanguageValidationTest(Target target, ErrorInserter errorInse
                         diagnostic -> diagnostic.getRange().getStart().getLine() == badLine
                     );
                     System.out.println(result ? " Success." : " but the expected error could not be found.");
+                    if (!result) {
+                        System.err.println(alteredTest.getLinesAround(badLine));
+                    }
                     return result;
                 }
             )),