Fix: nested spread operator handling (#221)

Author: cesarParra

cirrus.toml

@@ -1,6 +1,6 @@
 [[orgs]]
 name = "Expression"
-definitionFile = "config/dev.json"
+definitionFile = "config/dev-communities.json"
 
 [commands]
 ls = "sf org list --skip-connection-status"
@@ -12,6 +12,7 @@ generate-library-docs = "bun scripts/generate-library-docs.mjs"
 prep-package = "bun scripts/prepare-for-packaging.mjs"
 run-package = "cirrus package create -p Expression -t minor -x -c --promote -w 60"
 post-package = "bun scripts/post-packaging.mjs"
+deploy-conference-community = "sf project deploy start -d unpackaged/examples/expression-conf/main"
 import-data = "sf data import tree -p unpackaged/examples/expression-conf/data/data-plan.json"
 
 [flow.start-dev]
@@ -20,6 +21,7 @@ steps = [
     { type = "create_scratch", org = "Expression" },
     { type = "command", name = "deploy" },
     { type = "command", name = "assign-perms" },
+    { type = "command", name = "deploy-conference-community" },
     { type = "command", name = "import-data" },
 ]
 

expression-src/main/src/interpreter/Interpreter.cls

@@ -1,15 +1,25 @@
 public virtual with sharing class Interpreter implements Visitor {
     private final Environment env;
 
-    private Boolean inListLiteral = false;
-    private Boolean isInMapLiteral = false;
+    private Integer inListLiteralCounter = 0;
+    private Integer inMapLiteralCounter = 0;
+    private final Boolean inListLiteral {
+        get {
+            return inListLiteralCounter > 0;
+        }
+    }
+    private final Boolean isInMapLiteral {
+        get {
+            return inMapLiteralCounter > 0;
+        }
+    }
 
     public Interpreter(Environment env) {
         this.env = env;
     }
 
-    public void setIsInListLiteral(Boolean inListLiteral) {
-        this.inListLiteral = inListLiteral;
+    public void setIsInListLiteral() {
+        this.inListLiteralCounter++;
     }
 
     public Object interpret(Expr expression) {
@@ -351,7 +361,7 @@ public virtual with sharing class Interpreter implements Visitor {
     }
 
     public Object visit(Expr.ListLiteral listLiteral) {
-        inListLiteral = true;
+        inListLiteralCounter++;
         List<Object> resultList = new List<Object>();
         for (Expr expr : listLiteral.elements) {
             Object result = evaluate(expr);
@@ -370,7 +380,7 @@ public virtual with sharing class Interpreter implements Visitor {
                 resultList.add(result);
             }
         }
-        inListLiteral = false;
+        inListLiteralCounter--;
         return resultList;
     }
 
@@ -422,7 +432,7 @@ public virtual with sharing class Interpreter implements Visitor {
     }
 
     public Object visit(Expr.MapLiteral mapLiteral) {
-        isInMapLiteral = true;
+        inMapLiteralCounter++;
         Map<Object, Object> resultMap = new Map<Object, Object>();
         for (Object element : mapLiteral.elements) {
             if (element instanceof Expr.KeyValue) {
@@ -447,7 +457,7 @@ public virtual with sharing class Interpreter implements Visitor {
                 resultMap.put(conditionalKeyValuePair.key, conditionalKeyValuePair.value);
             }
         }
-        isInMapLiteral = false;
+        inMapLiteralCounter--;
         return resultMap;
     }
 

expression-src/main/src/interpreter/std-lib/CollectionFunctions.cls

@@ -66,7 +66,7 @@ public with sharing class CollectionFunctions {
      */
     private class ListFn extends StandardFunction {
         public override Object call(List<Expr> arguments) {
-            interpreter.setIsInListLiteral(true);
+            interpreter.setIsInListLiteral();
 
             List<Object> result = new List<Object>();
             for (Expr argument : arguments) {

expression-src/spec/language/operators/OperatorTest.cls

@@ -215,6 +215,16 @@ private class OperatorTest {
         Assert.areEqual(3, Evaluator.run('SIZE([...LIST(1, 2, 3)])'));
     }
 
+    @IsTest
+    private static void spreadOperatorsCanBeNested() {
+        String formula = '[...[1, 2], ...[3, 4], ...[5, 6]]';
+        List<Object> result = (List<Object>)Evaluator.run(formula);
+        Assert.areEqual(6, result.size());
+        for (Integer i = 0; i < 6; i++) {
+            Assert.areEqual(i + 1, result[i]);
+        }
+    }
+
     @IsTest
     private static void spreadOperatorCanBeUsedInsideOfAListFunction() {
         Assert.areEqual(3, Evaluator.run('SIZE(LIST(...LIST(1, 2, 3)))'));
@@ -223,14 +233,23 @@ private class OperatorTest {
 
     @IsTest
     private static void mapsSupportTheSpreadOperator() {
-        Map<Object, Object> result = (Map<Object, Object>) Evaluator.run('{...{"a": 1, "b": 2}}');
+        Map<Object, Object> result = (Map<Object, Object>)Evaluator.run('{...{"a": 1, "b": 2}}');
+        Assert.areEqual(1, result.get('a'));
+        Assert.areEqual(2, result.get('b'));
+    }
+
+    @IsTest
+    private static void spreadOperatorsInMapsCanBeNested() {
+        Map<Object, Object> result = (Map<Object, Object>)Evaluator.run('{...{"a": 1, "b": 2}, ...{"c": 3, "d": 4}}');
         Assert.areEqual(1, result.get('a'));
         Assert.areEqual(2, result.get('b'));
+        Assert.areEqual(3, result.get('c'));
+        Assert.areEqual(4, result.get('d'));
     }
 
     @IsTest
     private static void spreadOperatorInMapRespectTheRightmostValue() {
-        Map<Object, Object> result = (Map<Object, Object>) Evaluator.run('{...{"a": 1, "b": 2}, "b": 3}');
+        Map<Object, Object> result = (Map<Object, Object>)Evaluator.run('{...{"a": 1, "b": 2}, "b": 3}');
         Assert.areEqual(1, result.get('a'));
         Assert.areEqual(3, result.get('b'));
     }
@@ -248,8 +267,8 @@ private class OperatorTest {
     @IsTest
     private static void canPipeFunctionCallsMultipleTimes() {
         Object result = Evaluator.run('[1, 2, 3, 4, 5, 6] -> WHERE($current > 2) -> WHERE($current < 5)');
-        Assert.areEqual(2, ((List<Object>) result).size());
-        Assert.areEqual(3, ((List<Object>) result)[0]);
-        Assert.areEqual(4, ((List<Object>) result)[1]);
+        Assert.areEqual(2, ((List<Object>)result).size());
+        Assert.areEqual(3, ((List<Object>)result)[0]);
+        Assert.areEqual(4, ((List<Object>)result)[1]);
     }
 }