cleanup

Author: 0101

src/Compiler/Driver/GraphChecking/Graph.fs

@@ -75,48 +75,6 @@ module internal Graph =
         |> readOnlyDict
         |> addIfMissing originalGraph.Keys
 
-    /// Returns leaves of the graph and the remaining graph without the leaves.
-    let cutLeaves (graph: Graph<'Node>) =
-        let notLeaves =
-            set
-                [
-                    for (KeyValue (node, deps)) in graph do
-                        if deps.Length > 0 then
-                            node
-                ]
-
-        let leaves =
-            set
-                [
-                    for (KeyValue (node, deps)) in graph do
-                        if deps.Length = 0 then
-                            node
-
-                        yield! deps |> Array.filter (notLeaves.Contains >> not)
-                ]
-
-        leaves,
-        seq {
-            for (KeyValue (node, deps)) in graph do
-                if deps.Length > 0 then
-                    node, deps |> Array.filter (leaves.Contains >> not)
-        }
-        |> make
-
-    /// Returns layers of leaves repeatedly removed from the graph until there's nothing left
-    let leafSequence (graph: Graph<'Node>) =
-        let rec loop (graph: Graph<'Node>) acc =
-            match graph |> cutLeaves with
-            | leaves, _ when leaves.IsEmpty -> acc
-            | leaves, graph ->
-                seq {
-                    yield! acc
-                    leaves
-                }
-                |> loop graph
-
-        loop graph Seq.empty
-
     let printCustom (graph: Graph<'Node>) (nodePrinter: 'Node -> string) : unit =
         printfn "Graph:"
         let join (xs: string[]) = System.String.Join(", ", xs)

src/Compiler/Driver/GraphChecking/Graph.fsi

@@ -19,8 +19,6 @@ module internal Graph =
     val subGraphFor: node: 'Node -> graph: Graph<'Node> -> Graph<'Node> when 'Node: equality
     /// Create a reverse of the graph.
     val reverse<'Node when 'Node: equality> : originalGraph: Graph<'Node> -> Graph<'Node>
-    /// Returns layers of leaves repeatedly removed from the graph until there's nothing left
-    val leafSequence: graph: Graph<'Node> -> Set<'Node> seq
     /// Print the contents of the graph to the standard output.
     val print: graph: Graph<'Node> -> unit
     /// Create a simple Mermaid graph

src/Compiler/Driver/GraphChecking/GraphProcessing.fs

@@ -232,11 +232,13 @@ let processGraphAsync<'Item, 'Result when 'Item: equality and 'Item: comparison>
 
         let raiseExn (item, ex: exn) =
             localCts.Cancel()
-            match ex with 
-            | :? OperationCanceledException ->
-                completionSignal.TrySetCanceled()
-            | _ -> 
-                completionSignal.TrySetException(GraphProcessingException($"[*] Encountered exception when processing item '{item}': {ex.Message}", ex))
+
+            match ex with
+            | :? OperationCanceledException -> completionSignal.TrySetCanceled()
+            | _ ->
+                completionSignal.TrySetException(
+                    GraphProcessingException($"[*] Encountered exception when processing item '{item}': {ex.Message}", ex)
+                )
             |> ignore
 
         let incrementProcessedNodesCount () =
@@ -280,8 +282,8 @@ let processGraphAsync<'Item, 'Result when 'Item: equality and 'Item: comparison>
         leaves |> Array.iter queueNode
 
         // Wait for end of processing, an exception, or an external cancellation request.
-        do! completionSignal.Task |> Async.AwaitTask 
-        
+        do! completionSignal.Task |> Async.AwaitTask
+
         // All calculations succeeded - extract the results and sort in input order.
         return
             nodes.Values