[Libguestfs] [libnbd PATCH v5 10/12] rust: async: Use the modifies_fd flag to exclude calls

[Tage Johansson]

All handle calls which has the modifies_fd flag set to true will be
excluded from AsyncHandle (the asynchronous handle in the rust
bindings). This is a better approach then listing all calls that should
be excluded in Rust.ml explicetly.
---
 generator/Rust.ml | 60 +++++++++++++++++++++--------------------------
 1 file changed, 27 insertions(+), 33 deletions(-)

diff --git a/generator/Rust.ml b/generator/Rust.ml
index f6016d4..fad991a 100644
--- a/generator/Rust.ml
+++ b/generator/Rust.ml
@@ -568,18 +568,17 @@ let generate_rust_bindings () =
 
 let excluded_handle_calls : NameSet.t =
   NameSet.of_list
-    [
-      "aio_get_fd";
-      "aio_get_direction";
-      "aio_notify_read";
-      "aio_notify_write";
-      "clear_debug_callback";
-      "get_debug";
-      "poll";
-      "poll2";
-      "set_debug";
-      "set_debug_callback";
-    ]
+  @@ [
+       "aio_get_fd";
+       "aio_get_direction";
+       "clear_debug_callback";
+       "get_debug";
+       "set_debug";
+       "set_debug_callback";
+     ]
+  @ (handle_calls
+    |> List.filter (fun (_, { modifies_fd }) -> modifies_fd)
+    |> List.map (fun (name, _) -> name))
 
 (* A mapping with names as keys. *)
 module NameMap = Map.Make (String)
@@ -590,16 +589,16 @@ let strip_aio name : string =
     String.sub name 4 (String.length name - 4)
   else failwithf "Asynchronous call %s must begin with aio_" name
 
-(* A map with all asynchronous handle calls. The keys are names with "aio_"
-   stripped, the values are a tuple with the actual name (with "aio_"), the
-   [call] and the [async_kind]. *)
+(* A map with all asynchronous handle calls. The keys are names, the values
+   are tuples of: the name with "aio_" stripped, the [call] and the
+   [async_kind]. *)
 let async_handle_calls : ((string * call) * async_kind) NameMap.t =
   handle_calls
   |> List.filter (fun (n, _) -> not (NameSet.mem n excluded_handle_calls))
   |> List.filter_map (fun (name, call) ->
          call.async_kind
          |> Option.map (fun async_kind ->
-                (strip_aio name, ((name, call), async_kind))))
+                (name, ((strip_aio name, call), async_kind))))
   |> List.to_seq |> NameMap.of_seq
 
 (* A mapping with all synchronous (not asynchronous) handle calls. Excluded
@@ -609,11 +608,7 @@ let async_handle_calls : ((string * call) * async_kind) NameMap.t =
 let sync_handle_calls : call NameMap.t =
   handle_calls
   |> List.filter (fun (n, _) -> not (NameSet.mem n excluded_handle_calls))
-  |> List.filter (fun (name, _) ->
-         (not (NameMap.mem name async_handle_calls))
-         && not
-              (String.starts_with ~prefix:"aio_" name
-              && NameMap.mem (strip_aio name) async_handle_calls))
+  |> List.filter (fun (n, _) -> not (NameMap.mem n async_handle_calls))
   |> List.to_seq |> NameMap.of_seq
 
 (* Get the Rust type for an argument in the asynchronous API. Like
@@ -658,7 +653,7 @@ let print_rust_sync_handle_call name call =
 (* Print the Rust function for an asynchronous handle call with a completion
    callback. (Note that "callback" might be abbreviated with "cb" in the
    following code. *)
-let print_rust_async_handle_call_with_completion_cb name (aio_name, call) =
+let print_rust_async_handle_call_with_completion_cb aio_name (name, call) =
   (* An array of all optional arguments. Useful because we need to deel with
      the index of the completion callback. *)
   let optargs = Array.of_list call.optargs in
@@ -738,7 +733,7 @@ let print_rust_async_handle_call_with_completion_cb name (aio_name, call) =
    completion by changing state. The predicate is a call like
    "aio_is_connecting" which should get the value (like false) for the call to
    be complete. *)
-let print_rust_async_handle_call_changing_state name (aio_name, call)
+let print_rust_async_handle_call_changing_state aio_name (name, call)
     (predicate, value) =
   let value = if value then "true" else "false" in
   print_rust_handle_call_comment call;
@@ -767,16 +762,15 @@ let print_rust_async_handle_call_changing_state name (aio_name, call)
 (* Print an impl with all handle calls. *)
 let print_rust_async_handle_impls () =
   pr "impl AsyncHandle {\n";
-  NameMap.iter print_rust_sync_handle_call sync_handle_calls;
-  NameMap.iter
-    (fun name (call, async_kind) ->
-      match async_kind with
-      | WithCompletionCallback ->
-          print_rust_async_handle_call_with_completion_cb name call
-      | ChangesState (predicate, value) ->
-          print_rust_async_handle_call_changing_state name call
-            (predicate, value))
-    async_handle_calls;
+  sync_handle_calls |> NameMap.iter print_rust_sync_handle_call;
+  async_handle_calls
+  |> NameMap.iter (fun name (call, async_kind) ->
+         match async_kind with
+         | WithCompletionCallback ->
+             print_rust_async_handle_call_with_completion_cb name call
+         | ChangesState (predicate, value) ->
+             print_rust_async_handle_call_changing_state name call
+               (predicate, value));
   pr "}\n\n"
 
 let print_rust_async_imports () =
-- 
2.41.0