Python list initializers & equal initializer syntax

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

@@ -611,7 +611,29 @@ class LinguaFrancaValidationTest {
             }
         }
     }
-
+
+    @Test
+    def void forbidListLiterals() {
+        parseWithoutError('''
+            target C;
+            reactor Contained {
+                state x: int[]([1, 2]);
+            }
+        ''').assertError(LfPackage::eINSTANCE.listLiteral,
+            null, 'Target C does not support LF list literals')
+    }
+
+
+    @Test
+    def void allowListLiteralsInPython() {
+        parseWithoutError('''
+            target Python;
+            reactor Contained {
+                state x([1, 2]);
+            }
+        ''').assertNoErrors()
+    }
+
 
     /**
      * Tests for state and parameter declarations, including native lists.

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

@@ -323,7 +323,7 @@ Expr :
 // If it is a constant, the validator should check that if the value
 // is non-zero, it is accompanied by a unit.
 Value:
-    (parameter=[Parameter] | time=Time | literal=Literal | code=Code);
+    (parameter=[Parameter] | time=Time | literal=Literal | list=ListLiteral | code=Code);
 
 
 Time:
@@ -341,10 +341,10 @@ Type:
 ;
 
 ArraySpec:
-    ofVariableLength?='[]' | '[' length=INT ']';
+    '[' ( ofVariableLength?=']' | length=INT ']' );
 
 WidthSpec:
-    ofVariableLength?='[]' | '[' (terms+=WidthTerm) ('+' terms+=WidthTerm)* ']';
+    '[' ( ofVariableLength?=']' | (terms+=WidthTerm) ('+' terms+=WidthTerm)* ']' );
 
 WidthTerm:
     width=INT 
@@ -385,6 +385,16 @@ SignedInt:
     INT | NEGINT
 ;
 
+// List literals support even empty lists, and a trailing comma.
+
+// Note: this expansion is weirdly written, but without the
+// emptyList property, Xtext fails to push a ListLiteral node
+// when the list is empty... Another bug of Xtext.
+ListLiteral:
+    '[' (items+=Value (',' items+=Value)* ','? ']'
+        | ','? emptyList?=']')
+;
+
 Literal:
     STRING | CHAR_LIT | SignedFloat | SignedInt | Boolean;
 
@@ -522,7 +532,7 @@ Token:
     // Braces
     '(' | ')' | '{' | '}' |
     // Brackets
-    '[' | ']' | '<' | '>' | '[]' |
+    '[' | ']' | '<' | '>' |
     // Punctuation
     ':' | ';' | ',' | '.' | '::' |
     // Slashes

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

@@ -397,6 +397,14 @@ public enum Target {
         this(description, requiresTypes, "N/A", "N/A", keywords);
     }
 
+    /**
+     * Returns true if the target supports list literals in LF syntax.
+     * If not, list literals produce validator errors.
+     */
+    public boolean supportsLfListLiterals() {
+        return this == Python;
+    }
+
 
     /**
      * Return the target that matches the given string.

org.lflang/src/org/lflang/generator/PythonGenerator.xtend

@@ -29,7 +29,6 @@ package org.lflang.generator
 import java.io.File
 import java.util.ArrayList
 import java.util.LinkedHashSet
-import java.util.LinkedList
 import java.util.List
 import java.util.regex.Pattern
 import org.eclipse.emf.ecore.resource.Resource
@@ -48,12 +47,10 @@ import org.lflang.lf.Input
 import org.lflang.lf.Instantiation
 import org.lflang.lf.Model
 import org.lflang.lf.Output
-import org.lflang.lf.Parameter
 import org.lflang.lf.Port
 import org.lflang.lf.Reaction
 import org.lflang.lf.Reactor
 import org.lflang.lf.ReactorDecl
-import org.lflang.lf.StateVar
 import org.lflang.lf.TriggerRef
 import org.lflang.lf.Value
 import org.lflang.lf.VarRef
@@ -182,99 +179,35 @@ class PythonGenerator extends CGenerator {
      * @param v A value
      * @return A value string in the target language
      */
-    private def getPythonTargetValue(Value v) {
-        var String returnValue = "";
-        switch(v.toText) {
-            case "false": returnValue = "False"
-            case "true": returnValue = "True"
-            default: returnValue = super.getTargetValue(v)
-        }
-
+    protected def String getPythonTargetValue(Value v) {
         // Parameters in Python are always prepended with a 'self.'
         // predicate. Therefore, we need to append the returned value
         // if it is a parameter.
         if (v.parameter !== null) {
-            returnValue = "self." + returnValue;
-        }
-
-        return returnValue;
-    }
-
-    /**
-     * Create a list of state initializers in target code.
-     * 
-     * @param state The state variable to create initializers for
-     * @return A list of initializers in target code
-     */
-    protected def List<String> getPythonInitializerList(StateVar state) {
-        if (!state.isInitialized) {
-            return null
+            return "self." + super.getTargetValue(v);
+        } else if (v.list !== null) {
+            return "[" + v.list.items.join(', ', [it.pythonTargetValue]) + "]"
         }
 
-        var list = new LinkedList<String>();
-
-        for (i : state?.init) {
-            if (i.parameter !== null) {
-                list.add(i.parameter.targetReference)
-            } else if (state.isOfTimeType) {
-                list.add(i.targetTime)
-            } else {
-                list.add(i.pythonTargetValue)
-            }
+        switch(v.toText) {
+            case "false": return "False"
+            case "true": return "True"
+            default: return super.getTargetValue(v)
         }
-        return list
-    }
-
-     /**
-     * Create a Python tuple for parameter initialization in target code.
-     * 
-     * @param p The parameter instance to create initializers for
-     * @return Initialization code
-     */
-     protected def String getPythonInitializer(StateVar state) throws Exception {        
-            if (state.init.size > 1) {
-                // state variables are initialized as mutable lists
-                return state.init.join('[', ', ', ']', [it.pythonTargetValue])
-            } else if (state.isInitialized) {
-                return state.init.get(0).getPythonTargetValue
-            } else {
-                return "None"
-            }
-
-    }
-
-     /**
-     * Create a Python list for parameter initialization in target code.
-     * 
-     * @param p The parameter instance to create initializers for
-     * @return Initialization code
-     */
-     protected def String getPythonInitializer(ParameterInstance p) {        
-            if (p.init.size > 1) {
-                // parameters are initialized as immutable tuples
-                return p.init.join('(', ', ', ')', [it.pythonTargetValue])
-            } else {
-                return p.init.get(0).getPythonTargetValue
-            }
-
     }
-
-    /**
-     * Create a Python list for parameter initialization in target code.
-     * 
-     * @param p The parameter to create initializers for
-     * @return Initialization code
-     */
-     protected def String getPythonInitializer(Parameter p) {        
-            if (p.init.size > 1) {
-                // parameters are initialized as immutable tuples
-                return p.init.join('(', ', ', ')', [it.pythonTargetValue])
-            } else {
-                return p.init.get(0).pythonTargetValue
-            }
-
+
+    /** Returns the python initializer corresponding to the given LF init list. */
+    def String getPythonInitializer(List<Value> init) {
+          if (init === null) {
+              return "None"
+          } if (init.size > 1) {
+              // corresponds to a tuple
+              return init.join('(', ', ', ')', [it.pythonTargetValue])
+          } else {
+              return init.get(0).getPythonTargetValue
+          }
     }
-    
+
     /**
      * Generate parameters and their respective initialization code for a reaction function
      * The initialization code is put at the beginning of the reaction before user code
@@ -389,20 +322,6 @@ class PythonGenerator extends CGenerator {
 
     }
 
-    /**
-     * Handle initialization for state variable
-     * @param state a state variable
-     */
-    def String getTargetInitializer(StateVar state) {
-        if(!state.isInitialized)
-        {
-            return '''None'''
-        }
-
-        '''«FOR init : state.pythonInitializerList SEPARATOR ", "»«init»«ENDFOR»'''
-    }
-
-
     /**
      * Wrapper function for the more elaborate generatePythonReactorClass that keeps track
      * of visited reactors to avoid duplicate generation
@@ -522,11 +441,11 @@ class PythonGenerator extends CGenerator {
             if (!param.inferredType.targetType.equals("PyObject*")) {
                 // If type is given, use it
                 temporary_code.
-                    append('''        self._«param.name»:«param.inferredType.pythonType» = «param.pythonInitializer»
+                    append('''        self._«param.name»:«param.inferredType.pythonType» = «param.init.pythonInitializer»
                     ''')
             } else {
                 // If type is not given, just pass along the initialization
-                temporary_code.append('''        self._«param.name» = «param.pythonInitializer»
+                temporary_code.append('''        self._«param.name» = «param.init.pythonInitializer»
                 ''')
 
             }
@@ -547,11 +466,11 @@ class PythonGenerator extends CGenerator {
             if (!stateVar.inferredType.targetType.equals("PyObject*")) {
                 // If type is given, use it
                 temporary_code.
-                    append('''        self.«stateVar.name»:«stateVar.inferredType.pythonType» = «stateVar.pythonInitializer»
+                    append('''        self.«stateVar.name»:«stateVar.inferredType.pythonType» = «stateVar.init.pythonInitializer»
                     ''')
             } else if (stateVar.isInitialized) {
                 // If type is not given, pass along the initialization directly if it is present
-                temporary_code.append('''        self.«stateVar.name» = «stateVar.pythonInitializer»
+                temporary_code.append('''        self.«stateVar.name» = «stateVar.init.pythonInitializer»
                 ''')
             } else {
                 // If neither the type nor the initialization is given, use None
@@ -665,14 +584,14 @@ class PythonGenerator extends CGenerator {
                     «instance.uniqueID»_lf = \
                         [«FOR member : instance.bankMembers SEPARATOR ", \\\n"»\
                             _«className»(bank_index = «member.bankIndex/* bank_index is specially assigned by us*/»,\
-                                «FOR param : member.parameters SEPARATOR ", "»_«param.name»=«param.pythonInitializer»«ENDFOR»)«ENDFOR»]
+                                «FOR param : member.parameters SEPARATOR ", "»_«param.name»=«param.init.pythonInitializer»«ENDFOR»)«ENDFOR»]
                     ''')
                 return
             } else if (instance.bankIndex === -1 && !instance.definition.reactorClass.toDefinition.allReactions.isEmpty) {
                 pythonClassesInstantiation.append('''
                     «instance.uniqueID»_lf = \
                         [_«className»(bank_index = 0«/* bank_index is specially assigned by us*/», \
-                            «FOR param : instance.parameters SEPARATOR ", \\\n"»_«param.name»=«param.pythonInitializer»«ENDFOR»)]
+                            «FOR param : instance.parameters SEPARATOR ", \\\n"»_«param.name»=«param.init.pythonInitializer»«ENDFOR»)]
                 ''')
             }
 

org.lflang/src/org/lflang/validation/LFValidatorImpl.xtend

@@ -64,6 +64,7 @@ import org.lflang.lf.Instantiation
 import org.lflang.lf.KeyValuePair
 import org.lflang.lf.KeyValuePairs
 import org.lflang.lf.LfPackage.Literals
+import org.lflang.lf.ListLiteral
 import org.lflang.lf.Model
 import org.lflang.lf.NamedHost
 import org.lflang.lf.Output
@@ -371,6 +372,13 @@ class LFValidatorImpl extends AbstractLFValidator {
         }
     }
 
+    @Check(FAST)
+    def checkListLiteral(ListLiteral list) {
+        if (!target.supportsLfListLiterals()) {
+            error("Target " + target + " does not support LF list literals", Literals.LIST_LITERAL__ITEMS)
+        }
+    }
+
     @Check(FAST)
     def checkConnection(Connection connection) {
 

test/Python/src/ArrayAsParameter.lf

@@ -1,7 +1,7 @@
 // Source has an array as a parameter, the elements of which it passes
 // to Print.
 target Python;
-reactor Source(sequence(0, 1, 2)) {
+reactor Source(sequence([0, 1, 2])) {
     output out;
     state count(0);
     logical action next;
@@ -31,7 +31,7 @@ reactor Print {
     =}
 }
 main reactor ArrayAsParameter {
-    s = new Source(sequence = (1, 2, 3, 4));
+    s = new Source(sequence = [1, 2, 3, 4]);
     p = new Print();
     s.out -> p._in;
-}
+}

test/Python/src/ListLiterals.lf

@@ -0,0 +1,25 @@
+// This example illustrates state variables and parameters on the wiki.
+// For this test, success is just compiling and running.
+target Python;
+
+
+reactor Sub(seq([1,2])) {
+
+}
+
+main reactor {
+    state l12([1,2]);
+    state empty([]);
+    state empty2([,]);
+
+    sub  = new Sub(seq = [1, 2]);
+    sub2 = new Sub(seq = (1, 2));
+    sub3 = new Sub(seq = ([1, 2]));
+
+    reaction(startup) {=
+        assert self.empty == []
+        assert self.empty2 == []
+        assert self.l12 == [1, 2]
+        print("Success")
+    =}
+}

test/Python/src/MovingAverage.lf

@@ -18,7 +18,7 @@ reactor MASource {
     =}
 }
 reactor MovingAverageImpl {
-    state delay_line(0.0, 0.0, 0.0);
+    state delay_line([0.0, 0.0, 0.0]);
     state index(0);
     input m_in;
     output out;
@@ -46,4 +46,4 @@ main reactor MovingAverage {
     p = new TestDouble(expected=(0.0, 0.25, 0.75, 1.5, 2.5, 3.5));
     s.out -> m.m_in;
     m.out -> p.t_in;
-}
+}