WIP

Author: webwarrior-ws

src/FSharpLint.Core/Framework/HintParserUtilities.fs

@@ -275,60 +275,57 @@ module MergeSyntaxTrees =
     let getHints items =
         items |> Seq.map (fun (_, _, _, hint) -> hint) |> Seq.toList
 
-    let mergeHints hints =
-// fsharplint:disable EnsureTailCallDiagnosticsInRecursiveFunctions
-        let rec getEdges transposed =
-            let map =
-                transposed
-                |> List.choose (function
-                    | HintNode(expr, depth, rest) -> Some(getKey expr, expr, depth, rest)
-                    | EndOfHint(_) -> None)
-                |> List.filter (isAnyMatch >> not)
-                |> Seq.groupBy (fun (key, expr, _, _) -> Utilities.hash2 key (getHashCode expr))
-                |> Seq.map (fun (hashcode, items) -> (hashcode, mergeHints (getHints items)))
-                |> Map.ofSeq
-
-            let anyMatches =
-                transposed
-                |> List.choose (function
-                    | HintNode(expr, depth, rest) ->
-                        match (getKey expr, expr) with
-                        | (SyntaxHintNode.Wildcard as key), HintExpr(Expression.Wildcard)
-                        | (SyntaxHintNode.Wildcard as key), HintPat(Pattern.Wildcard)
-                        | (SyntaxHintNode.Variable as key), HintExpr(Expression.Variable(_))
-                        | (SyntaxHintNode.Variable as key), HintPat(Pattern.Variable(_)) -> Some(key, expr, depth, rest)
-                        | _ -> None
-                    | EndOfHint(_) -> None)
-                |> Seq.groupBy (fun (_, expr, _, _) -> expr)
-                |> Seq.choose (fun (expr, items) ->
-                    match expr with
-                    | HintPat(Pattern.Wildcard)
-                    | HintExpr(Expression.Wildcard) -> Some(None, mergeHints (getHints items))
-                    | HintPat(Pattern.Variable(var))
-                    | HintExpr(Expression.Variable(var)) -> Some(Some(var), mergeHints (getHints items))
-                    | _ -> None)
-                |> Seq.toList
-
-            { Lookup = map; AnyMatch = anyMatches }
-
-        and mergeHints hints =
+    [<TailCall>]
+    let rec private getEdges transposed =
+        let mergeHintsInner hints =
             let transposed = transposeHead hints
 
-            let edges = getEdges transposed
-
             let matchedHints =
                 transposed
                 |> Seq.choose (function
                     | HintNode(_) -> None
                     | EndOfHint(hint) -> Some(hint))
                 |> Seq.toList
-
+    
             {
-                Edges = edges
+                Edges = getEdges transposed
                 MatchedHint = matchedHints
             }
-// fsharplint:enable EnsureTailCallDiagnosticsInRecursiveFunctions
 
+        let map = 
+            transposed
+            |> List.choose (function
+                | HintNode(expr, depth, rest) -> Some(getKey expr, expr, depth, rest)
+                | EndOfHint(_) -> None)
+            |> List.filter (isAnyMatch >> not)
+            |> Seq.groupBy (fun (key, expr, _, _) -> Utilities.hash2 key (getHashCode expr))
+            |> Seq.map (fun (hashcode, items) -> (hashcode, mergeHintsInner (getHints items)))
+            |> Map.ofSeq
+
+        let anyMatches =
+            transposed
+            |> List.choose (function
+                | HintNode(expr, depth, rest) ->
+                    match (getKey expr, expr) with
+                    | (SyntaxHintNode.Wildcard as key), HintExpr(Expression.Wildcard)
+                    | (SyntaxHintNode.Wildcard as key), HintPat(Pattern.Wildcard)
+                    | (SyntaxHintNode.Variable as key), HintExpr(Expression.Variable(_))
+                    | (SyntaxHintNode.Variable as key), HintPat(Pattern.Variable(_)) -> Some(key, expr, depth, rest)
+                    | _ -> None
+                | EndOfHint(_) -> None)
+            |> Seq.groupBy (fun (_, expr, _, _) -> expr)
+            |> Seq.choose (fun (expr, items) ->
+                match expr with
+                | HintPat(Pattern.Wildcard)
+                | HintExpr(Expression.Wildcard) -> Some(None, mergeHintsInner (getHints items))
+                | HintPat(Pattern.Variable(var))
+                | HintExpr(Expression.Variable(var)) -> Some(Some(var), mergeHintsInner (getHints items))
+                | _ -> None)
+            |> Seq.toList
+
+        { Lookup = map; AnyMatch = anyMatches }
+
+    let mergeHints hints =
         let transposed = hints |> List.map hintToList |> transposeHead
 
         getEdges transposed