FavourStaticEmptyFields: made function tail-recursive

Made recursive function that processes expressions tail-recursive.

Author: webwarrior-ws

src/FSharpLint.Core/Rules/Conventions/FavourStaticEmptyFields.fs

@@ -38,51 +38,56 @@ let private generateError (fileContents: string) (range:FSharp.Compiler.Text.Ran
           SuggestedFix = Some suggestedFix
           TypeChecks = List.Empty }
 
-let rec private processExpression (args: AstNodeRuleParams) (expression: SynExpr) =
-    match expression with
-    | SynExpr.Const(SynConst.String ("", _, range), _) -> 
-        generateError args.FileContent range EmptyStringLiteral
-    | SynExpr.DotIndexedGet(_, indexArgs, _ , _) ->
-        processExpression args indexArgs
-    | SynExpr.DotIndexedSet(_, indexArgs, _ , _, _, _) ->
-        processExpression args indexArgs
-    | SynExpr.Paren(expr, _, _, _) ->
-        processExpression args expr
-    | SynExpr.Tuple(_, expressions, _, _) ->
-        expressions
-        |> List.map (processExpression args)
-        |> Array.concat
-    | SynExpr.ArrayOrList(isArray, [], range) ->
+[<TailCall>]
+let rec private processExpressions (errorsSoFar: array<WarningDetails>) (args: AstNodeRuleParams) (expressions: list<SynExpr>) =
+    match expressions with
+    | SynExpr.Const(SynConst.String ("", _, range), _) :: tail -> 
+        let errors =
+            Array.append
+                errorsSoFar
+                (generateError args.FileContent range EmptyStringLiteral)
+        processExpressions errors args tail
+    | SynExpr.DotIndexedGet(_, indexArgs, _ , _) :: tail ->
+        processExpressions errorsSoFar args (indexArgs :: tail)
+    | SynExpr.DotIndexedSet(_, indexArgs, _ , _, _, _) :: tail ->
+        processExpressions errorsSoFar args (indexArgs :: tail)
+    | SynExpr.Paren(expr, _, _, _) :: tail ->
+        processExpressions errorsSoFar args (expr :: tail)
+    | SynExpr.Tuple(_, expressions, _, _) :: tail ->
+        processExpressions errorsSoFar args (List.append expressions tail)
+    | SynExpr.ArrayOrList(isArray, [], range) :: tail ->
         let emptyLiteralType =
             if isArray then EmptyArrayLiteral else EmptyListLiteral
-        generateError args.FileContent range emptyLiteralType
-    | SynExpr.ArrayOrListComputed(_, expr, _) ->
-        processExpression args expr
-    | SynExpr.App(_, _, funcExpr, argExpr, _) ->
-        Array.append
-            (processExpression args funcExpr)
-            (processExpression args argExpr)
-    | SynExpr.AnonRecd(_, _, recordFields, _, _) ->
-        recordFields
-        |> List.map (fun (_, _, expr) -> processExpression args expr)
-        |> Array.concat
-    | SynExpr.Record(_, _, synExprRecordFields, _) ->
+        let errors =
+            Array.append
+                errorsSoFar
+                (generateError args.FileContent range emptyLiteralType)
+        processExpressions errors args tail
+    | SynExpr.ArrayOrListComputed(_, expr, _) :: tail ->
+        processExpressions errorsSoFar args (expr :: tail)
+    | SynExpr.App(_, _, funcExpr, argExpr, _) :: tail ->
+        processExpressions errorsSoFar args (List.append [ funcExpr; argExpr ] tail)
+    | SynExpr.AnonRecd(_, _, recordFields, _, _) :: tail ->
+        let fieldExpressions = 
+            recordFields
+            |> List.map (fun (_, _, expr) ->  expr)
+        processExpressions errorsSoFar args (List.append fieldExpressions tail)
+    | SynExpr.Record(_, _, synExprRecordFields, _) :: tail ->
         let mapping =
             function
-            | SynExprRecordField(_, _, expr, _) ->
-                match expr with
-                | Some innerExpression ->
-                    processExpression args innerExpression
-                | _ -> Array.empty
-        synExprRecordFields
-        |> List.map mapping
-        |> Array.concat
-    | _ -> Array.empty
+            | SynExprRecordField(_, _, expr, _) -> expr
+        let fieldExpressions = 
+            synExprRecordFields
+            |> List.choose mapping
+        processExpressions errorsSoFar args (List.append fieldExpressions tail)
+    | _ :: tail ->
+        processExpressions errorsSoFar args tail
+    | [] -> errorsSoFar
 
 let private runner (args: AstNodeRuleParams) =
     match args.AstNode with
     | AstNode.Expression(expr) -> 
-        processExpression args expr
+        processExpressions Array.empty args (List.singleton expr)
     | _ -> Array.empty