Refactor and simplification of expression AST builder

 * Removed most recursive collections of functions
 * Removed 2 modes of parsing (recursive descent, LL2)
 * Replaced with LL2, but with similar performance to recursive descent (tests run 5ish% faster)
    * only tail recursion (except for parentheses)
    * max recursion depth = 2 with parentheses
    * better precedence processing means that inner items tend to be processed first
	* LL2 where: if a node is unable to be processed, the system can continue to process later nodes
	    * unprocessed node can lock nodes around it to prevent incorrect precedence
 * Removed 20% of code

TestDynamo/Model/Compiler.AstNode.fs

@@ -50,7 +50,7 @@ type SyntheticAst =
 and AstNode =
     | Accessor of AccessorType
     | ExpressionAttrValue of string
-    | Call of struct (string * AstNode voption)
+    | Call of struct (string * AstNode)
     | Between of struct (AstNode * struct (AstNode * AstNode))
     | BinaryOperator of struct (BinaryOpToken * struct(AstNode * AstNode))
     | UnaryOperator of struct (UnaryOpToken * AstNode)
@@ -65,8 +65,7 @@ and AstNode =
         | Accessor x -> x.ToString()
         | Synthetic x -> x.ToString()
         | ExpressionAttrValue x -> x
-        | Call (name, ValueNone) -> $"{name}()"
-        | Call (name, ValueSome node) -> $"{name}({node})"
+        | Call (name, node) -> $"{name}({node})"
         | Between (x, (low, high)) -> $"{x} BETWEEN {low} AND {high}"
         | BinaryOperator (Multi Comma, (l, r)) -> $"{l}, {r}"
         | BinaryOperator (token, (l, r)) -> $"{l} {token} {r}"
@@ -124,8 +123,8 @@ type ParserSettings =
 module AstNode =
 
     [<ExcludeFromCodeCoverage>]
-    let inline private addAcc struct (f, ast) acc = struct (f, acc, ast)  
-
+    let inline private addAcc struct (f, ast) acc = struct (f, acc, ast)
+    
     /// <summary>
     /// Apply function with an accumulator to each node in the tree
     /// If the function returns None, do not process any more children
@@ -138,7 +137,6 @@ module AstNode =
 
             // no children
             | f, (AstNode.EmptyParenthesis & head, depth)::tail, acc
-            | f, (AstNode.Call (_, ValueNone) & head, depth)::tail, acc
             | f, (AstNode.ExpressionAttrValue _ & head, depth)::tail, acc
             | f, (AstNode.Synthetic (AccessorPath _) & head, depth)::tail, acc
             | f, (AstNode.Accessor (AccessorType.ExpressionAttrName _) & head, depth)::tail, acc
@@ -150,7 +148,7 @@ module AstNode =
                 | ValueSome acc' -> find struct (f, tail, acc')
 
             // 1 child
-            | f, (AstNode.Call (_, ValueSome next) & head, depth)::tail, acc
+            | f, (AstNode.Call (_, next) & head, depth)::tail, acc
             | f, (AstNode.Update (_, next) & head, depth)::tail, acc
             | f, (AstNode.Synthetic (IndividualRemoveUpdate next) & head, depth)::tail, acc
             | f, (AstNode.Synthetic (Projections next) & head, depth)::tail, acc
@@ -206,12 +204,18 @@ module AstNode =
         | [] -> ValueNone
         | head::tail -> struct (head, tail) |> toCsv' |> ValueSome
 
-    let rec private expand' xs = 
-        Collection.foldBackL (fun s -> function
-            | BinaryOperator (Multi Comma, (l, r)) -> expand' [l] @ expand' [r] @ s
-            | x -> x::s) [] xs
+    let rec private expandIntoMutableList (list: MList<_>) xs =
+        for x in xs do
+            match x with
+            | BinaryOperator (Multi Comma, (l, r)) ->
+                expandIntoMutableList list [l]
+                expandIntoMutableList list [r]
+            | x -> list.Add(x)
 
     /// <summary>
     /// Recursively expand a csv node
     /// </summary>
-    let expand x = expand' [x]
+    let expand x =
+        let l = MList()
+        expandIntoMutableList l [x]
+        List.ofSeq l

TestDynamo/Model/Compiler.AstOps.fs

@@ -620,7 +620,7 @@ module Updates =
 
         let private asSynthetic = function
             | AstNode.BinaryOperator (Single WhiteSpace, (l, r) & lr) -> IndividualAddUpdate lr |> Ok
-            | _ -> invalid1
+            | x -> invalid1
 
         let compiler =
             AggregatedUpdate.compiler (ValueSome Add) asSynthetic
@@ -631,7 +631,7 @@ module Updates =
             function
             | ResolvedPath path & x when ValidatedPath.length path = 1 -> Resolved x |> Ok
             | ResolvedPath _ & x -> notARootAttribute
-            | _ -> invalid2
+            | x -> invalid2
 
         let private validateRhs = function
             | ResolvedPath _

TestDynamo/Model/Compiler.ExpressionCompiler.fs

@@ -158,19 +158,18 @@ module ExpressionCompiler =
         static member reader x = x.asReader
 
     module private Build =
-        let private expandOpt = ValueOption.map AstNode.expand >> ValueOption.defaultValue []
-
+
         let private compilePart = ExpressionPartCompiler.compile
         let rec private generateCode' (compiler: MutableContainer<ExpressionCompilers>): AstCompiler =
             function
-            | AstNode.Call ("size", args) -> compilePart (expandOpt args) compiler.value.size
-            | AstNode.Call ("contains", args) -> compilePart (expandOpt args) compiler.value.contains
-            | AstNode.Call ("begins_with", args) -> compilePart (expandOpt args) compiler.value.begins_with
-            | AstNode.Call ("list_append", args) -> compilePart (expandOpt args) compiler.value.list_append
-            | AstNode.Call ("if_not_exists", args) -> compilePart (expandOpt args) compiler.value.if_not_exists
-            | AstNode.Call ("attribute_type", args) -> compilePart (expandOpt args) compiler.value.attribute_type
-            | AstNode.Call ("attribute_exists", args) -> compilePart (expandOpt args) compiler.value.attribute_exists
-            | AstNode.Call ("attribute_not_exists", args) -> compilePart (expandOpt args) compiler.value.attribute_not_exists
+            | AstNode.Call ("size", args) -> compilePart (AstNode.expand args) compiler.value.size
+            | AstNode.Call ("contains", args) -> compilePart (AstNode.expand args) compiler.value.contains
+            | AstNode.Call ("begins_with", args) -> compilePart (AstNode.expand args) compiler.value.begins_with
+            | AstNode.Call ("list_append", args) -> compilePart (AstNode.expand args) compiler.value.list_append
+            | AstNode.Call ("if_not_exists", args) -> compilePart (AstNode.expand args) compiler.value.if_not_exists
+            | AstNode.Call ("attribute_type", args) -> compilePart (AstNode.expand args) compiler.value.attribute_type
+            | AstNode.Call ("attribute_exists", args) -> compilePart (AstNode.expand args) compiler.value.attribute_exists
+            | AstNode.Call ("attribute_not_exists", args) -> compilePart (AstNode.expand args) compiler.value.attribute_not_exists
             | AstNode.Call (name, _) -> compiler.value.invalidFunction name
             | AstNode.Update (Add, updates) -> compilePart (AstNode.expand updates) compiler.value.add
             | AstNode.Update (Delete, updates) -> compilePart (AstNode.expand updates) compiler.value.delete