[rules] Factor out the calculation of build root directory.

Several plugins need to access this information, so we place it in
`gen_rules` for consistency.

Signed-off-by: Emilio Jesus Gallego Arias <[email protected]>

src/coq_rules.boot.ml

@@ -1,5 +1,5 @@
 module Dir_contents = Dir_contents (* hack for bootstrappign + ocamldep*)
 
-let setup_rules ~sctx:_ ~dir:_ ~dir_contents:_ _ = []
+let setup_rules ~sctx:_ ~build_dir:_ ~dir:_ ~dir_contents:_ _ = []
 let install_rules ~sctx:_ ~dir:_ _ = []
-let coqpp_rules ~sctx:_ ~dir:_ _ = []
+let coqpp_rules ~sctx:_ ~build_dir:_ ~dir:_ _ = []

src/coq_rules.ml

@@ -135,7 +135,7 @@ let setup_ml_deps ~lib_db libs =
 let coqlib_wrapper_name (s : Dune_file.Coq.t) =
   Lib_name.Local.to_string (snd s.name)
 
-let setup_rules ~sctx ~dir ~dir_contents (s : Dune_file.Coq.t) =
+let setup_rules ~sctx ~build_dir:_ ~dir ~dir_contents (s : Dune_file.Coq.t) =
 
   let scope = SC.find_scope_by_dir sctx dir in
 
@@ -203,16 +203,14 @@ let install_rules ~sctx ~dir s =
       None, Install.(Entry.make Section.Lib_root ~dst vofile))
     |> List.rev_append (coq_plugins_install_rules ~scope ~package ~dst_dir s)
 
-let coqpp_rules ~sctx ~dir (s : Dune_file.Coqpp.t) =
+let coqpp_rules ~sctx ~build_dir ~dir (s : Dune_file.Coqpp.t) =
 
-  let scope = SC.find_scope_by_dir sctx dir in
-  let base_dir = Scope.root scope in
   let cc = create_ccoq sctx ~dir in
 
   let mlg_rule m =
     let source = Path.relative dir (m ^ ".mlg") in
     let target = Path.relative dir (m ^ ".ml") in
     let args = Arg_spec.[Dep source; Hidden_targets [target]] in
-    Build.run ~dir:base_dir cc.coqpp args in
+    Build.run ~dir:build_dir cc.coqpp args in
 
   List.map ~f:mlg_rule s.modules

src/coq_rules.mli

@@ -8,6 +8,7 @@ open! Stdune
 
 val setup_rules
   :  sctx:Super_context.t
+  -> build_dir:Path.t
   -> dir:Path.t
   -> dir_contents:Dir_contents.t
   -> Dune_file.Coq.t
@@ -21,6 +22,7 @@ val install_rules
 
 val coqpp_rules
   :  sctx:Super_context.t
+  -> build_dir:Path.t
   -> dir:Path.t
   -> Dune_file.Coqpp.t
   -> (unit, Action.t) Build.t list

src/gen_rules.ml

@@ -70,6 +70,7 @@ module Gen(P : sig val sctx : Super_context.t end) = struct
   let gen_rules dir_contents cctxs
         { Dir_with_dune. src_dir; ctx_dir; data = stanzas
         ; scope; kind = dir_kind ; dune_version = _ } =
+    let build_dir = (SC.context sctx).build_dir in
     let expander = Super_context.expander sctx ~dir:ctx_dir in
     let for_stanza stanza =
       let dir = ctx_dir in
@@ -181,17 +182,14 @@ module Gen(P : sig val sctx : Super_context.t end) = struct
                       produced by this stanza are part of."
                })
         | Some cctx ->
-          Menhir_rules.gen_rules cctx m ~dir:ctx_dir
+          Menhir_rules.gen_rules cctx m ~build_dir ~dir:ctx_dir
         end
       | Coq.T m when Expander.eval_blang expander m.enabled_if ->
-        (* Format.eprintf "[coq] gen_rules called @\n%!"; *)
-        let dir = ctx_dir in
-        let coq_rules = Coq_rules.setup_rules ~sctx ~dir ~dir_contents m in
-        SC.add_rules ~dir:ctx_dir sctx coq_rules
+        Coq_rules.setup_rules ~sctx ~build_dir ~dir:ctx_dir ~dir_contents m
+        |> SC.add_rules ~dir:ctx_dir sctx
       | Coqpp.T m ->
-        let dir = ctx_dir in
-        let coqpp_rules = Coq_rules.coqpp_rules ~sctx ~dir m in
-        SC.add_rules ~dir:ctx_dir sctx coqpp_rules
+        Coq_rules.coqpp_rules ~sctx ~build_dir ~dir:ctx_dir m
+        |> SC.add_rules ~dir:ctx_dir sctx
       | _ -> ());
     let dyn_deps =
       let pred =

src/menhir.boot.ml

@@ -1,4 +1,4 @@
-let gen_rules ~dir _ _ = ()
+let gen_rules ~build_dir:_ ~dir:_ _ _ = ()
 
 let targets _ = []
 

src/menhir.ml

@@ -40,10 +40,9 @@ module type PARAMS = sig
      is of the form [_build/<context>/src], e.g., [_build/default/src]. *)
   val dir : Path.t
 
-  (* [root_dir] is the base directory of the context, usually where
-     the build is invoked from; we run menhir from this directoy to we
-     get correct error paths. *)
-  val root_dir : Path.t
+  (* [build_dir] is the base directory of the context; we run menhir
+     from this directoy to we get correct error paths. *)
+  val build_dir : Path.t
 
   (* [stanza] is the [(menhir ...)] stanza, as found in the [jbuild] file. *)
 
@@ -127,7 +126,7 @@ module Run (P : PARAMS) : sig end = struct
   (* [menhir args] generates a Menhir command line (a build action). *)
 
   let menhir (args : 'a args) : (string list, Action.t) Build.t =
-    Build.run ~dir:root_dir menhir_binary args
+    Build.run ~dir:build_dir menhir_binary args
 
   let rule ?(mode=stanza.mode) : (unit, Action.t) Build.t -> unit =
     SC.add_rule sctx ~dir ~mode ~loc:stanza.loc
@@ -322,12 +321,12 @@ let targets (stanza : Dune_file.Menhir.t) : string list =
 let module_names (stanza : Dune_file.Menhir.t) : Module.Name.t list =
   List.map (modules stanza) ~f:Module.Name.of_string
 
-let gen_rules ~dir cctx stanza =
+let gen_rules ~build_dir ~dir cctx stanza =
   let module R =
     Run (struct
       let cctx = cctx
       let dir = dir
-      let root_dir = Scope.root (Compilation_context.scope cctx)
+      let build_dir = build_dir
       let stanza = stanza
     end) in
   ()

src/menhir.mli

@@ -12,7 +12,8 @@ val module_names : Dune_file.Menhir.t -> Module.Name.t list
 
 (** Generate the rules for a [(menhir ...)] stanza. *)
 val gen_rules
-  :  dir:Path.t
+  :  build_dir:Path.t
+  -> dir:Path.t
   -> Compilation_context.t
   -> Dune_file.Menhir.t
   -> unit