Add test to show lib name collision in contexts

bin/ocaml/top.ml

@@ -165,16 +165,19 @@ module Module = struct
       in
       let pps () =
         let module Merlin = Dune_rules.Merlin in
-        let pps = Merlin.pp_config merlin ctx ~expander in
-        let+ pps, _ = Action_builder.evaluate_and_collect_facts pps in
-        let pp = Dune_rules.Module_name.Per_item.get pps module_name in
-        match pp with
-        | None -> None, None
-        | Some pp_flags ->
-          let args = Merlin.Processed.pp_args pp_flags in
-          (match Merlin.Processed.pp_kind pp_flags with
-           | Pp -> Some args, None
-           | Ppx -> None, Some args)
+        match merlin with
+        | None -> Memo.return (None, None)
+        | Some merlin ->
+          let pps = Merlin.pp_config merlin ctx ~expander in
+          let+ pps, _ = Action_builder.evaluate_and_collect_facts pps in
+          let pp = Dune_rules.Module_name.Per_item.get pps module_name in
+          (match pp with
+           | None -> None, None
+           | Some pp_flags ->
+             let args = Merlin.Processed.pp_args pp_flags in
+             (match Merlin.Processed.pp_kind pp_flags with
+              | Pp -> Some args, None
+              | Ppx -> None, Some args))
       in
       let+ (pp, ppx), files_to_load = Memo.fork_and_join pps files_to_load in
       let code =

src/dune_rules/gen_rules.ml

@@ -112,14 +112,11 @@ end = struct
       let+ () = toplevel_setup ~sctx ~dir ~toplevel in
       empty_none
     | Library.T lib ->
-      let* enabled_if = Lib.DB.available (Scope.libs scope) (Library.best_name lib) in
-      if_available_buildable
-        ~loc:lib.buildable.loc
-        (fun () ->
-          let+ () = Odoc.setup_private_library_doc_alias sctx ~scope ~dir:ctx_dir lib
-          and+ rules = Lib_rules.rules lib ~sctx ~dir ~scope ~dir_contents ~expander in
-          rules)
-        enabled_if
+      let* available = Lib_rules.rules lib ~sctx ~dir ~scope ~dir_contents ~expander in
+      (match available with
+       | None -> Memo.return empty_none
+       | Some (cctx, merlin) ->
+         Memo.return { empty_none with merlin; cctx = Some (lib.buildable.loc, cctx) })
     | Foreign.Library.T lib ->
       Expander.eval_blang expander lib.enabled_if
       >>= if_available (fun () ->

src/dune_rules/lib.ml

@@ -132,6 +132,18 @@ module Error = struct
       ]
   ;;
 
+  let duplicated ~loc ~name ~dir_a ~dir_b =
+    User_error.make
+      ~loc
+      [ Pp.textf
+          "A library with name %S is defined in two folders: %s and %s. Either change \
+           one of the names, or enable them conditionally using the 'enabled_if' field."
+          (Lib_name.to_string name)
+          (Path.to_string_maybe_quoted dir_a)
+          (Path.to_string_maybe_quoted dir_b)
+      ]
+  ;;
+
   (* diml: it is not very clear what a "default implementation cycle" is *)
   let default_implementation_cycle cycle =
     make
@@ -406,7 +418,7 @@ type db =
 
 and resolve_result =
   | Not_found
-  | Found of Lib_info.external_
+  | Found of Lib_info.external_ list
   | Hidden of Lib_info.external_ Hidden.t
   | Invalid of User_message.t
   | Ignore
@@ -1125,19 +1137,53 @@ end = struct
     | Hidden h -> Hidden.error h ~loc ~name >>| Option.some
   ;;
 
+  let find_in_parent ~db ~name =
+    let open Memo.O in
+    let+ res =
+      match db.parent with
+      | None -> Memo.return Status.Not_found
+      | Some db -> find_internal db name
+    in
+    res
+  ;;
+
+  let to_status ~db ~name = function
+    | [] -> find_in_parent ~db ~name
+    | info :: [] -> instantiate db name info ~hidden:None
+    | a :: b :: _ ->
+      let loc = Lib_info.loc b in
+      let dir_a = Lib_info.src_dir a in
+      let dir_b = Lib_info.src_dir b in
+      Memo.return (Status.Invalid (Error.duplicated ~loc ~name ~dir_a ~dir_b))
+  ;;
+
   let resolve_name db name =
     let open Memo.O in
     db.resolve name
     >>= function
     | Ignore -> Memo.return Status.Ignore
     | Redirect_in_the_same_db (_, name') -> find_internal db name'
     | Redirect (db', (_, name')) -> find_internal db' name'
-    | Found info -> instantiate db name info ~hidden:None
+    | Found libs ->
+      (match libs with
+       | [] | _ :: [] ->
+         (* In case we have 0 or 1 results found, convert to [Status.t] directly.
+            This allows to provide better errors later on,
+            e.g. `Library "foo" in _build/default is hidden (unsatisfied 'enabled_if') *)
+         to_status ~db ~name libs
+       | _ :: _ :: _ ->
+         (* If there are multiple results found, we optimistically pre-filter to
+            remove those that are disabled *)
+         let* filtered_libs =
+           Memo.List.filter libs ~f:(fun lib ->
+             let* enabled = Lib_info.enabled lib in
+             match enabled with
+             | Disabled_because_of_enabled_if -> Memo.return false
+             | Normal | Optional -> Memo.return true)
+         in
+         to_status ~db ~name filtered_libs)
     | Invalid e -> Memo.return (Status.Invalid e)
-    | Not_found ->
-      (match db.parent with
-       | None -> Memo.return Status.Not_found
-       | Some db -> find_internal db name)
+    | Not_found -> find_in_parent ~db ~name
     | Hidden { lib = info; reason = hidden; path = _ } ->
       (match db.parent with
        | None -> Memo.return Status.Not_found
@@ -1763,13 +1809,49 @@ module Compile = struct
   ;;
 end
 
+module Local : sig
+  type t = private lib
+
+  val of_lib : lib -> t option
+  val of_lib_exn : lib -> t
+  val to_lib : t -> lib
+  val obj_dir : t -> Path.Build.t Obj_dir.t
+  val info : t -> Path.Build.t Lib_info.t
+  val to_dyn : t -> Dyn.t
+  val equal : t -> t -> bool
+  val hash : t -> int
+
+  include Comparable_intf.S with type key := t
+end = struct
+  type nonrec t = t
+
+  let to_lib t = t
+  let of_lib (t : lib) = Option.some_if (is_local t) t
+
+  let of_lib_exn t =
+    match of_lib t with
+    | Some l -> l
+    | None -> Code_error.raise "Lib.Local.of_lib_exn" [ "l", to_dyn t ]
+  ;;
+
+  let obj_dir t = Obj_dir.as_local_exn (Lib_info.obj_dir t.info)
+  let info t = Lib_info.as_local_exn t.info
+
+  module Set = Set
+  module Map = Map
+
+  let to_dyn = to_dyn
+  let equal = equal
+  let hash = hash
+end
+
 (* Databases *)
 
 module DB = struct
   module Resolve_result = struct
     type t = resolve_result =
       | Not_found
-      | Found of Lib_info.external_
+      | Found of Lib_info.external_ list
       | Hidden of Lib_info.external_ Hidden.t
       | Invalid of User_message.t
       | Ignore
@@ -1786,7 +1868,7 @@ module DB = struct
       match x with
       | Not_found -> variant "Not_found" []
       | Invalid e -> variant "Invalid" [ Dyn.string (User_message.to_string e) ]
-      | Found lib -> variant "Found" [ Lib_info.to_dyn Path.to_dyn lib ]
+      | Found libs -> variant "Found" [ (Dyn.list (Lib_info.to_dyn Path.to_dyn)) libs ]
       | Hidden h -> variant "Hidden" [ Hidden.to_dyn (Lib_info.to_dyn Path.to_dyn) h ]
       | Ignore -> variant "Ignore" []
       | Redirect (_, (_, name)) -> variant "Redirect" [ Lib_name.to_dyn name ]
@@ -1825,7 +1907,7 @@ module DB = struct
           let open Memo.O in
           Findlib.find findlib name
           >>| function
-          | Ok (Library pkg) -> Found (Dune_package.Lib.info pkg)
+          | Ok (Library pkg) -> Found [ Dune_package.Lib.info pkg ]
           | Ok (Deprecated_library_name d) ->
             Redirect_in_the_same_db (d.loc, d.new_public_name)
           | Ok (Hidden_library pkg) -> Hidden (Hidden.unsatisfied_exist_if pkg)
@@ -1894,15 +1976,21 @@ module DB = struct
 
   let available t name = Resolve_names.available_internal t name
 
-  let get_compile_info t ~allow_overlaps name =
+  let get_compile_info t ~allow_overlaps ~dir name =
     let open Memo.O in
-    find_even_when_hidden t name
+    find t name
     >>| function
-    | Some lib -> lib, Compile.for_lib ~allow_overlaps t lib
-    | None ->
-      Code_error.raise
-        "Lib.DB.get_compile_info got library that doesn't exist"
-        [ "name", Lib_name.to_dyn name ]
+    | Some lib ->
+      (match Local.of_lib lib with
+       | None ->
+         Code_error.raise
+           "Lib.DB.get_compile_info got library that is not local"
+           [ "name", Lib_name.to_dyn name ]
+       | Some info ->
+         (match Path.Build.equal dir (Lib_info.src_dir (Local.info info)) with
+          | true -> Some (lib, Compile.for_lib ~allow_overlaps t lib)
+          | false -> None))
+    | None -> None
   ;;
 
   let resolve_user_written_deps
@@ -2092,39 +2180,3 @@ let to_dune_lib
   in
   Dune_package.Lib.of_dune_lib ~info ~main_module_name
 ;;
-
-module Local : sig
-  type t = private lib
-
-  val of_lib : lib -> t option
-  val of_lib_exn : lib -> t
-  val to_lib : t -> lib
-  val obj_dir : t -> Path.Build.t Obj_dir.t
-  val info : t -> Path.Build.t Lib_info.t
-  val to_dyn : t -> Dyn.t
-  val equal : t -> t -> bool
-  val hash : t -> int
-
-  include Comparable_intf.S with type key := t
-end = struct
-  type nonrec t = t
-
-  let to_lib t = t
-  let of_lib (t : lib) = Option.some_if (is_local t) t
-
-  let of_lib_exn t =
-    match of_lib t with
-    | Some l -> l
-    | None -> Code_error.raise "Lib.Local.of_lib_exn" [ "l", to_dyn t ]
-  ;;
-
-  let obj_dir t = Obj_dir.as_local_exn (Lib_info.obj_dir t.info)
-  let info t = Lib_info.as_local_exn t.info
-
-  module Set = Set
-  module Map = Map
-
-  let to_dyn = to_dyn
-  let equal = equal
-  let hash = hash
-end

src/dune_rules/lib.mli

@@ -100,7 +100,7 @@ module DB : sig
     type t
 
     val not_found : t
-    val found : Lib_info.external_ -> t
+    val found : Lib_info.external_ list -> t
     val to_dyn : t Dyn.builder
     val redirect : db -> Loc.t * Lib_name.t -> t
     val redirect_in_the_same_db : Loc.t * Lib_name.t -> t
@@ -124,15 +124,19 @@ module DB : sig
 
   val find : t -> Lib_name.t -> lib option Memo.t
   val find_even_when_hidden : t -> Lib_name.t -> lib option Memo.t
+
+  (** [available db lib_name] returns [true] if there is any library available
+      in the database with name [lib_name], regardless if it is enabled or not. *)
   val available : t -> Lib_name.t -> bool Memo.t
 
-  (** Retrieve the compile information for the given library. Works for
-      libraries that are optional and not available as well. *)
+  (** [get_compile_info db ~allow_overlaps ~dir lib_name] retrieves the compile
+      information for the given library, if it exists. Otherwise returns [None]. *)
   val get_compile_info
     :  t
     -> allow_overlaps:bool
+    -> dir:Path.Build.t
     -> Lib_name.t
-    -> (lib * Compile.t) Memo.t
+    -> (lib * Compile.t) option Memo.t
 
   val resolve : t -> Loc.t * Lib_name.t -> lib Resolve.Memo.t