simplify

Signed-off-by: ArthurW <[email protected]>

Author: art-w

src/dune_rules/lib.ml

@@ -374,30 +374,22 @@ module T = struct
     ; pps : t list Resolve.t
     ; resolved_selects : Resolved_select.t list Resolve.t
     ; parameters : t list Resolve.t
-    ; arguments : argument option list
+    ; arguments : t option list
     ; implements : t Resolve.t option
     ; project : Dune_project.t option
     ; (* these fields cannot be forced until the library is instantiated *)
       default_implementation : t Resolve.t Memo.Lazy.t option
     ; sub_systems : Sub_system0.Instance.t Memo.Lazy.t Sub_system_name.Map.t
     }
 
-  and argument =
-    { arg : t
-    ; param_name : Module_name.t
-    ; arg_name : Module_name.t
-    ; loc : Loc.t
-    }
-
   let rec compare (x : t) (y : t) =
     match Id.compare x.unique_id y.unique_id with
     | (Lt | Gt) as cmp -> cmp
     | Eq -> compare_arguments x y
 
   and compare_arguments a b =
-    List.compare a.arguments b.arguments ~compare:(Option.compare compare_argument)
-
-  and compare_argument x y = compare x.arg y.arg
+    List.compare a.arguments b.arguments ~compare:(Option.compare compare)
+  ;;
 
   let to_dyn t =
     Dyn.record
@@ -518,34 +510,27 @@ let resolve_main_module_name t =
 let main_module_name t = Memo.return (resolve_main_module_name t)
 
 module Parameterised = struct
-  type nonrec argument = argument =
-    { arg : t
-    ; param_name : Module_name.t
-    ; arg_name : Module_name.t
-    ; loc : Loc.t
-    }
-
   type status =
     | Not_parameterised
     | Partial
     | Complete
 
   let status t =
-    if List.for_all t.arguments ~f:Option.is_none
-    then Not_parameterised
-    else (
+    match t.arguments with
+    | [] -> Not_parameterised
+    | _ ->
       let rec check_instantiate lib =
         List.for_all lib.arguments ~f:(function
           | None -> false
-          | Some arg -> check_instantiate arg.arg)
+          | Some arg -> check_instantiate arg)
       in
-      if check_instantiate t then Complete else Partial)
+      if check_instantiate t then Complete else Partial
   ;;
 
   let arguments t =
     List.map t.arguments ~f:(function
       | None -> Code_error.raise "expected complete application" [ "lib", to_dyn t ]
-      | Some { arg; _ } -> arg)
+      | Some arg -> arg)
   ;;
 
   let parameterised_arguments t =
@@ -594,19 +579,12 @@ module Parameterised = struct
   let make_argument (loc, arg) =
     let open Resolve.O in
     let* arg = arg in
-    let* param =
+    let+ param =
       match arg.implements with
       | Some param -> param
       | None -> Error.missing_implements ~loc arg.info
     in
-    let+ param_name = resolve_main_module_name param
-    and+ arg_name = resolve_main_module_name arg in
-    ( param
-    , { arg
-      ; param_name = Option.value_exn param_name
-      ; arg_name = Option.value_exn arg_name
-      ; loc
-      } )
+    param, arg
   ;;
 
   let make_arguments arguments =
@@ -644,9 +622,9 @@ module Parameterised = struct
         Resolve.List.map dep.arguments ~f:(fun opt_arg ->
           match opt_arg with
           | None -> Resolve.return None
-          | Some argument ->
-            let+ arg = apply_arguments argument.arg parent_arguments in
-            Some { argument with arg })
+          | Some arg ->
+            let+ arg = apply_arguments arg parent_arguments in
+            Some arg)
       in
       apply_arguments { dep with arguments } parent_arguments
   ;;
@@ -662,11 +640,11 @@ module Parameterised = struct
     let lib_arguments =
       List.filter_map lib.arguments ~f:(function
         | None -> None
-        | Some arg -> Some arg.arg)
+        | Some arg -> Some arg)
     in
     let deps = lib_arguments @ deps in
     let deps =
-      match lib_arguments with
+      match lib.arguments with
       | [] -> deps
       | _ -> remove_arguments lib :: deps
     in
@@ -699,12 +677,12 @@ module Parameterised = struct
 
   let rec for_instance ~build_dir ~ext_lib t =
     match info ~build_dir ~ext_lib t with
-    | None -> { t with arguments = [] }
+    | None -> remove_arguments t
     | Some info ->
       let arguments =
         List.map t.arguments ~f:(function
           | None -> None
-          | Some arg -> Some { arg with arg = for_instance ~build_dir ~ext_lib arg.arg })
+          | Some arg -> Some (for_instance ~build_dir ~ext_lib arg))
       in
       { t with info = Lib_info.of_local info; arguments }
   ;;
@@ -2567,7 +2545,7 @@ let to_dune_lib
             ; arguments =
                 List.filter_map args ~f:(function
                   | None -> None
-                  | Some arg -> Some (arg.loc, mangled_name arg.arg))
+                  | Some arg -> Some (Loc.none, mangled_name arg))
             ; new_name = None
             }))
   in

src/dune_rules/lib.mli

@@ -21,14 +21,6 @@ module Parameterised : sig
     | Complete
 
   val status : t -> status
-
-  type argument = private
-    { arg : t
-    ; param_name : Module_name.t
-    ; arg_name : Module_name.t
-    ; loc : Loc.t
-    }
-
   val arguments : t -> t list
   val applied_modules : t -> Module_name.t Parameterised_name.t list Resolve.t
   val applied_name : t -> Module_name.t Parameterised_name.t Resolve.t