Enable dev-tools when lock dir is enabled

Author: Leonidas-from-XIV

bin/ocaml/utop.ml

@@ -51,11 +51,9 @@ let term =
         | true ->
           let* () = Build_system.build_file utop_exe in
           let* () = lock_utop_if_dev_tool_enabled () in
-          let* utop_dev_tool_lock_dir_exists =
-            Memo.Lazy.force Utop.utop_dev_tool_lock_dir_exists
-          in
+          let* lock_dir_enabled = Dune_rules.Lock_dir.enabled in
           let* () =
-            if utop_dev_tool_lock_dir_exists
+            if lock_dir_enabled
             then
               (* Generate the custom findlib.conf file needed when utop is run
                  as a dev tool. *)
@@ -80,7 +78,7 @@ let term =
                  ~init:env
           in
           let env =
-            if utop_dev_tool_lock_dir_exists
+            if lock_dir_enabled
             then
               (* If there's a utop lockdir then dune will have built utop as a
                  dev tool. In order for it to run correctly dune needed to

bin/pkg/pkg_enabled.ml

@@ -7,7 +7,7 @@ let term =
     Memo.run
     @@
     let open Memo.O in
-    let+ workspace = Workspace.workspace () in
+    let* workspace = Workspace.workspace () in
     let lock_dir_paths =
       Pkg_common.Lock_dirs_arg.lock_dirs_of_workspace
         Pkg_common.Lock_dirs_arg.all
@@ -19,7 +19,8 @@ let term =
     in
     (* CR-Leonidas-from-XIV: change this logic when we stop detecting lock
        directories in the source tree *)
-    let enabled = any_lockdir_exists || workspace.config.pkg_enabled in
+    let+ lock_dir_enabled = Dune_rules.Lock_dir.enabled in
+    let enabled = any_lockdir_exists || lock_dir_enabled in
     match enabled with
     | true -> ()
     | false -> exit 1)

src/dune_pkg/lock_dir.ml

@@ -1087,21 +1087,12 @@ let create_latest_version
 let dev_tool_locks_name = "dev-tools.locks"
 let dev_tools_path = Path.Build.(relative root dev_tool_locks_name)
 
-(* CR-Leonidas-from-XIV: remove once obsoleted *)
-let dev_tools_source_path = Path.Source.(relative root dev_tool_locks_name)
-
 let dev_tool_lock_dir_path dev_tool =
   Path.Build.relative
     dev_tools_path
     (Package_name.to_string (Dev_tool.package_name dev_tool))
 ;;
 
-let dev_tool_lock_dir_source_path dev_tool =
-  Path.Source.relative
-    dev_tools_source_path
-    (Package_name.to_string (Dev_tool.package_name dev_tool))
-;;
-
 let default_path = Path.Build.(relative root "dune.lock")
 let metadata_filename = "lock.dune"
 

src/dune_pkg/lock_dir.mli

@@ -137,7 +137,7 @@ val dev_tool_lock_dir_path : Dev_tool.t -> Path.Build.t
 (** Temporary hack to get the path of a dev tool lock directory in the source
     tree. Future versions will probably handle this differently and this
     function should be removed *)
-val dev_tool_lock_dir_source_path : Dev_tool.t -> Path.Source.t
+(* val dev_tool_lock_dir_source_path : Dev_tool.t -> Path.Source.t *)
 
 module Metadata : Dune_sexp.Versioned_file.S with type data := unit
 

src/dune_rules/fetch_rules.ml

@@ -188,11 +188,7 @@ let find_checksum, find_url =
           Dune_pkg.Dev_tool.all
           ~init:(Checksum.Map.empty, Digest.Map.empty)
           ~f:(fun acc dev_tool ->
-            Fs_memo.dir_exists
-              (In_source_dir (Dune_pkg.Lock_dir.dev_tool_lock_dir_source_path dev_tool))
-            >>= function
-            | false -> Memo.return acc
-            | true -> Lock_dir.of_dev_tool dev_tool >>| add_checksums_and_urls acc)
+            Lock_dir.of_dev_tool dev_tool >>| add_checksums_and_urls acc)
       in
       Per_context.list ()
       >>= Memo.parallel_map ~f:Lock_dir.get

src/dune_rules/lock_dir.ml

@@ -143,6 +143,11 @@ let select_lock_dir lock_dir_selection =
   Workspace.Lock_dir_selection.eval lock_dir_selection ~dir:Path.Build.root ~f:expander
 ;;
 
+let enabled =
+  let+ workspace = Workspace.workspace () in
+  workspace.config.pkg_enabled
+;;
+
 let get_path ctx =
   let* workspace = Workspace.workspace () in
   match
@@ -184,16 +189,8 @@ let get ctx = get_with_path ctx >>| Result.map ~f:snd
 let get_exn ctx = get ctx >>| User_error.ok_exn
 
 let of_dev_tool dev_tool =
-  let source_path, path =
-    Dune_pkg.Lock_dir.(
-      dev_tool_lock_dir_source_path dev_tool, dev_tool_lock_dir_path dev_tool)
-  in
-  Fs_memo.dir_exists (In_source_dir source_path)
-  >>= function
-  | true -> Load.load_exn path
-  | false ->
-    User_error.raise
-      [ Pp.textf "%s does not exist" (Path.Build.to_string_maybe_quoted path) ]
+  let path = dev_tool_lock_dir_path dev_tool in
+  Load.load_exn path
 ;;
 
 let lock_dir_active ctx =

src/dune_rules/lock_dir.mli

@@ -9,6 +9,7 @@ val get_exn : Context_name.t -> t Memo.t
 val of_dev_tool : Dune_pkg.Dev_tool.t -> t Memo.t
 val lock_dir_active : Context_name.t -> bool Memo.t
 val get_path : Context_name.t -> Path.Build.t option Memo.t
+val enabled : bool Memo.t
 
 module Sys_vars : sig
   type t =

src/dune_rules/odoc.ml

@@ -254,11 +254,6 @@ let odoc_base_flags quiet build_dir =
   | Nonfatal -> S []
 ;;
 
-let odoc_dev_tool_lock_dir_exists () =
-  let path = Dune_pkg.Lock_dir.dev_tool_lock_dir_source_path Odoc in
-  Fs_memo.dir_exists (Path.Outside_build_dir.In_source_dir path)
-;;
-
 let odoc_dev_tool_exe_path_building_if_necessary () =
   let open Action_builder.O in
   let path = Path.build (Pkg_dev_tool.exe_path Odoc) in
@@ -268,10 +263,8 @@ let odoc_dev_tool_exe_path_building_if_necessary () =
 
 let odoc_program sctx dir =
   let open Action_builder.O in
-  let* odoc_dev_tool_lock_dir_exists =
-    Action_builder.of_memo (odoc_dev_tool_lock_dir_exists ())
-  in
-  match odoc_dev_tool_lock_dir_exists with
+  let* odoc_dev_tool_enabled = Action_builder.of_memo Lock_dir.enabled in
+  match odoc_dev_tool_enabled with
   | true -> odoc_dev_tool_exe_path_building_if_necessary ()
   | false ->
     Super_context.resolve_program

src/dune_rules/utop.ml

@@ -139,12 +139,6 @@ let requires ~loc ~db ~libs =
   >>= Lib.closure ~linking:true
 ;;
 
-let utop_dev_tool_lock_dir_exists =
-  Memo.Lazy.create (fun () ->
-    let path = Dune_pkg.Lock_dir.dev_tool_lock_dir_source_path Utop in
-    Fs_memo.dir_exists (Path.Outside_build_dir.In_source_dir path))
-;;
-
 let utop_findlib_conf = Filename.concat utop_dir_basename "findlib.conf"
 
 (* The lib directory of the utop package and of each of its dependencies within
@@ -161,8 +155,8 @@ let utop_ocamlpath = Memo.Lazy.create (fun () -> Pkg_rules.dev_tool_ocamlpath Ut
    we need to tell findlib where to look for libraries by means of a custom
    findlib.conf file. *)
 let findlib_conf sctx ~dir =
-  let* lock_dir_exists = Memo.Lazy.force utop_dev_tool_lock_dir_exists in
-  match lock_dir_exists with
+  let* lock_dir_enabled = Lock_dir.enabled in
+  match lock_dir_enabled with
   | false ->
     (* If there isn't lockdir don't create the findlib.conf rule. *)
     Memo.return ()
@@ -178,8 +172,8 @@ let findlib_conf sctx ~dir =
 
 let lib_db sctx ~dir =
   let* scope = Scope.DB.find_by_dir dir in
-  let* lock_dir_exists = Memo.Lazy.force utop_dev_tool_lock_dir_exists in
-  match lock_dir_exists with
+  let* lock_dir_enabled = Lock_dir.enabled in
+  match lock_dir_enabled with
   | false -> Memo.return (Scope.libs scope)
   | true ->
     let* ocamlpath = Memo.Lazy.force utop_ocamlpath in

src/dune_rules/utop.mli

@@ -8,7 +8,6 @@ val utop_exe : Filename.t
 
 val utop_dir_basename : Filename.t
 val utop_findlib_conf : Filename.t
-val utop_dev_tool_lock_dir_exists : bool Memo.Lazy.t
 val libs_under_dir : Super_context.t -> db:Lib.DB.t -> dir:Path.t -> Lib.t list Memo.t
 val setup : Super_context.t -> dir:Path.Build.t -> unit Memo.t