eif: fix name collision in same folder for exes and melange emits

src/dune_rules/artifacts_obj.ml

@@ -12,7 +12,7 @@ let lookup_library { libraries; modules = _ } = Lib_name.Map.find libraries
 
 let make ~dir ~lib_config ~libs ~exes =
   let+ libraries =
-    Memo.List.map libs ~f:(fun ((lib : Library.t), _, _, _) ->
+    Memo.List.map libs ~f:(fun ((lib : Library.t), _, _, _, _) ->
       let+ lib_config = lib_config in
       let name = Lib_name.of_local lib.name in
       let info = Library.to_lib_info lib ~dir ~lib_config in
@@ -28,9 +28,9 @@ let make ~dir ~lib_config ~libs ~exes =
       List.fold_left
         exes
         ~init:Module_name.Map.empty
-        ~f:(fun modules (_, _, m, obj_dir) -> by_name modules obj_dir m)
+        ~f:(fun modules (_, _, m, obj_dir, _) -> by_name modules obj_dir m)
     in
-    List.fold_left libs ~init ~f:(fun modules (_, _, m, obj_dir) ->
+    List.fold_left libs ~init ~f:(fun modules (_, _, m, obj_dir, _) ->
       by_name modules obj_dir m)
   in
   { libraries; modules }

src/dune_rules/artifacts_obj.mli

@@ -7,8 +7,8 @@ val empty : t
 val make
   :  dir:Path.Build.t
   -> lib_config:Lib_config.t Memo.t
-  -> libs:(Library.t * _ * Modules.t * Path.Build.t Obj_dir.t) list
-  -> exes:(_ * _ * Modules.t * Path.Build.t Obj_dir.t) list
+  -> libs:(Library.t * _ * Modules.t * Path.Build.t Obj_dir.t * Toggle.t) list
+  -> exes:(_ * _ * Modules.t * Path.Build.t Obj_dir.t * Toggle.t) list
   -> t Memo.t
 
 val lookup_module : t -> Module_name.t -> (Path.Build.t Obj_dir.t * Module.t) option

src/dune_rules/melange/melange_rules.ml

@@ -581,28 +581,38 @@ let emit_rules sctx { stanza_dir; stanza } =
 ;;
 
 (* Detect if [dir] is under the target directory of a melange.emit stanza. *)
-let rec under_melange_emit_target ~dir =
+let rec under_melange_emit_target ~sctx ~dir =
   match Path.Build.parent dir with
   | None -> Memo.return None
   | Some parent ->
     Dune_load.stanzas_in_dir parent
     >>= (function
-     | None -> under_melange_emit_target ~dir:parent
+     | None -> under_melange_emit_target ~sctx ~dir:parent
      | Some stanzas ->
        Dune_file.find_stanzas stanzas Melange_stanzas.Emit.key
-       >>| List.find_map ~f:(fun mel ->
+       >>= Memo.List.find_map ~f:(fun (mel : Melange_stanzas.Emit.t) ->
+         (* In the case where we have two melange.emit stanzas in the same folder,
+            with one enabled in the current context and one disabled, we want to
+            make sure that we pick the enabled one *)
+         let+ enabled =
+           let* expander =
+             let* sctx = sctx in
+             Super_context.expander sctx ~dir
+           in
+           Expander.eval_blang expander mel.enabled_if
+         in
          let target_dir = Melange_stanzas.Emit.target_dir ~dir:parent mel in
-         Option.some_if (Path.Build.equal target_dir dir) mel)
+         Option.some_if (enabled && Path.Build.equal target_dir dir) mel)
        >>= (function
-        | None -> under_melange_emit_target ~dir:parent
+        | None -> under_melange_emit_target ~sctx ~dir:parent
         | Some stanza -> Memo.return @@ Some { stanza_dir = parent; stanza }))
 ;;
 
 let gen_emit_rules sctx ~dir ({ stanza_dir; stanza } as for_melange) =
   match Path.Build.equal dir (Melange_stanzas.Emit.target_dir ~dir:stanza_dir stanza) with
   | false -> Memo.return None
   | true ->
-    under_melange_emit_target ~dir:stanza_dir
+    under_melange_emit_target ~sctx ~dir:stanza_dir
     >>| (function
      | None -> Some (emit_rules sctx for_melange)
      | Some { stanza_dir = parent_melange_emit_dir; stanza = parent_stanza } ->
@@ -640,7 +650,7 @@ let gen_emit_rules sctx ~dir ({ stanza_dir; stanza } as for_melange) =
 module Gen_rules = Import.Build_config.Gen_rules
 
 let setup_emit_js_rules sctx ~dir =
-  under_melange_emit_target ~dir
+  under_melange_emit_target ~sctx ~dir
   >>= function
   | Some melange ->
     gen_emit_rules sctx ~dir melange

src/dune_rules/ml_sources.ml

@@ -45,107 +45,118 @@ module Modules = struct
     * (Loc.t * Module.Source.t) Module_trie.t
     * Modules_group.t
     * Path.Build.t Obj_dir.t
+    * Toggle.t
 
   type groups =
     { libraries : Library.t group_part list
     ; executables : Executables.t group_part list
     ; melange_emits : Melange_stanzas.Emit.t group_part list
     }
 
-  let make { libraries = libs; executables = exes; melange_emits = emits } =
-    let libraries =
-      match
-        Lib_name.Map.of_list_map libs ~f:(fun (lib, _, m, obj_dir) ->
-          Library.best_name lib, (m, obj_dir))
-      with
-      | Ok x -> x
-      | Error (name, _, (lib2, _, _, _)) ->
-        User_error.raise
-          ~loc:lib2.buildable.loc
-          [ Pp.textf
-              "Library %S appears for the second time in this directory"
-              (Lib_name.to_string name)
-          ]
+  let make =
+    let keep_enabled t =
+      List.filter t ~f:(fun (_, _, _, _, enabled) -> Toggle.enabled enabled)
     in
-    let executables =
-      match
-        String.Map.of_list_map exes ~f:(fun ((exes : Executables.t), _, m, obj_dir) ->
-          snd (List.hd exes.names), (m, obj_dir))
-      with
-      | Ok x -> x
-      | Error (name, _, (exes2, _, _, _)) ->
-        User_error.raise
-          ~loc:exes2.buildable.loc
-          [ Pp.textf "Executable %S appears for the second time in this directory" name ]
-    in
-    let melange_emits =
-      match
-        String.Map.of_list_map emits ~f:(fun (mel, _, m, obj_dir) ->
-          mel.target, (m, obj_dir))
-      with
-      | Ok x -> x
-      | Error (name, _, (mel, _, _, _)) ->
-        User_error.raise
-          ~loc:mel.loc
-          [ Pp.textf "Target %S appears for the second time in this directory" name ]
-    in
-    let rev_map =
-      let modules =
-        let by_path (origin : Origin.t) trie =
-          Module_trie.fold trie ~init:[] ~f:(fun (_loc, m) acc ->
-            (Module.Source.path m, origin) :: acc)
-        in
-        List.concat
-          [ List.concat_map libs ~f:(fun (l, m, _, _) -> by_path (Library l) m)
-          ; List.concat_map exes ~f:(fun (e, m, _, _) -> by_path (Executables e) m)
-          ; List.concat_map emits ~f:(fun (l, m, _, _) -> by_path (Melange l) m)
-          ]
+    fun { libraries = libs; executables = exes; melange_emits = emits } ->
+      let libs = keep_enabled libs in
+      let exes = keep_enabled exes in
+      let emits = keep_enabled emits in
+      let libraries =
+        match
+          Lib_name.Map.of_list_map libs ~f:(fun (lib, _, m, obj_dir, _) ->
+            Library.best_name lib, (m, obj_dir))
+        with
+        | Ok x -> x
+        | Error (name, _, (lib2, _, _, _, _)) ->
+          User_error.raise
+            ~loc:lib2.buildable.loc
+            [ Pp.textf
+                "Library %S appears for the second time in this directory"
+                (Lib_name.to_string name)
+            ]
       in
-      match Module_name.Path.Map.of_list modules with
-      | Ok x -> x
-      | Error (path, _, _) ->
-        let locs =
-          List.filter_map modules ~f:(fun (n, origin) ->
-            Option.some_if
-              (Ordering.is_eq (Module_name.Path.compare n path))
-              (Origin.loc origin))
-          |> List.sort ~compare:Loc.compare
-        in
-        let main_message =
-          Pp.textf
-            "Module %S is used in several stanzas:"
-            (Module_name.Path.to_string path)
-        in
-        let loc, related_locs =
-          match locs with
-          | [] ->
-            (* duplicates imply at least at one module with this location *)
-            assert false
-          | loc :: related_locs -> loc, related_locs
-        in
-        let annots =
-          let main = User_message.make ~loc [ main_message ] in
-          let related =
-            List.map related_locs ~f:(fun loc ->
-              User_message.make ~loc [ Pp.text "Used in this stanza" ])
+      let executables =
+        match
+          String.Map.of_list_map
+            exes
+            ~f:(fun ((exes : Executables.t), _, m, obj_dir, _) ->
+              snd (List.hd exes.names), (m, obj_dir))
+        with
+        | Ok x -> x
+        | Error (name, _, (exes2, _, _, _, _)) ->
+          User_error.raise
+            ~loc:exes2.buildable.loc
+            [ Pp.textf "Executable %S appears for the second time in this directory" name
+            ]
+      in
+      let melange_emits =
+        match
+          String.Map.of_list_map emits ~f:(fun (mel, _, m, obj_dir, _) ->
+            mel.target, (m, obj_dir))
+        with
+        | Ok x -> x
+        | Error (name, _, (mel, _, _, _, _)) ->
+          User_error.raise
+            ~loc:mel.loc
+            [ Pp.textf "Target %S appears for the second time in this directory" name ]
+      in
+      let rev_map =
+        let modules =
+          let by_path (origin : Origin.t) trie =
+            Module_trie.fold trie ~init:[] ~f:(fun (_loc, m) acc ->
+              (Module.Source.path m, origin) :: acc)
           in
-          User_message.Annots.singleton
-            Compound_user_error.annot
-            [ Compound_user_error.make ~main ~related ]
+          List.concat
+            [ List.concat_map libs ~f:(fun (l, m, _, _, _) -> by_path (Library l) m)
+            ; List.concat_map exes ~f:(fun (e, m, _, _, _) -> by_path (Executables e) m)
+            ; List.concat_map emits ~f:(fun (l, m, _, _, _) -> by_path (Melange l) m)
+            ]
         in
-        User_error.raise
-          ~annots
-          ~loc:(Loc.drop_position loc)
-          [ main_message
-          ; Pp.enumerate locs ~f:(fun loc -> Pp.verbatim (Loc.to_file_colon_line loc))
-          ; Pp.text
-              "To fix this error, you must specify an explicit \"modules\" field in \
-               every library, executable, and executables stanzas in this dune file. \
-               Note that each module cannot appear in more than one \"modules\" field - \
-               it must belong to a single library or executable."
-          ]
-    in
-    { libraries; executables; melange_emits; rev_map }
+        match Module_name.Path.Map.of_list modules with
+        | Ok x -> x
+        | Error (path, _, _) ->
+          let locs =
+            List.filter_map modules ~f:(fun (n, origin) ->
+              Option.some_if
+                (Ordering.is_eq (Module_name.Path.compare n path))
+                (Origin.loc origin))
+            |> List.sort ~compare:Loc.compare
+          in
+          let main_message =
+            Pp.textf
+              "Module %S is used in several stanzas:"
+              (Module_name.Path.to_string path)
+          in
+          let loc, related_locs =
+            match locs with
+            | [] ->
+              (* duplicates imply at least at one module with this location *)
+              assert false
+            | loc :: related_locs -> loc, related_locs
+          in
+          let annots =
+            let main = User_message.make ~loc [ main_message ] in
+            let related =
+              List.map related_locs ~f:(fun loc ->
+                User_message.make ~loc [ Pp.text "Used in this stanza" ])
+            in
+            User_message.Annots.singleton
+              Compound_user_error.annot
+              [ Compound_user_error.make ~main ~related ]
+          in
+          User_error.raise
+            ~annots
+            ~loc:(Loc.drop_position loc)
+            [ main_message
+            ; Pp.enumerate locs ~f:(fun loc -> Pp.verbatim (Loc.to_file_colon_line loc))
+            ; Pp.text
+                "To fix this error, you must specify an explicit \"modules\" field in \
+                 every library, executable, and executables stanzas in this dune file. \
+                 Note that each module cannot appear in more than one \"modules\" field \
+                 - it must belong to a single library or executable."
+            ]
+      in
+      { libraries; executables; melange_emits; rev_map }
   ;;
 end
 
@@ -393,6 +404,7 @@ let modules_of_stanzas =
     Memo.parallel_map stanzas ~f:(fun stanza ->
       match Stanza.repr stanza with
       | Library.T lib ->
+        let* enabled = Expander.eval_blang expander lib.enabled_if >>| Toggle.of_bool in
         (* jeremiedimino: this [Resolve.get] means that if the user writes an
            invalid [implements] field, we will get an error immediately even if
            the library is not built. We should change this to carry the
@@ -411,9 +423,10 @@ let modules_of_stanzas =
           >>= Resolve.read_memo
         in
         let obj_dir = Library.obj_dir lib ~dir in
-        `Library (lib, sources, modules, obj_dir)
+        `Library (lib, sources, modules, obj_dir, enabled)
       | Executables.T exes | Tests.T { exes; _ } ->
         let obj_dir = Executables.obj_dir ~dir exes in
+        let* enabled = Expander.eval_blang expander exes.enabled_if >>| Toggle.of_bool in
         let+ sources, modules =
           let { Buildable.loc = stanza_loc; modules = modules_settings; _ } =
             exes.buildable
@@ -434,9 +447,10 @@ let modules_of_stanzas =
           then Modules_group.make_wrapped ~obj_dir ~modules `Exe
           else Modules_group.exe_unwrapped modules ~obj_dir
         in
-        `Executables (exes, sources, modules, obj_dir)
+        `Executables (exes, sources, modules, obj_dir, enabled)
       | Melange_stanzas.Emit.T mel ->
         let obj_dir = Obj_dir.make_melange_emit ~dir ~name:mel.target in
+        let* enabled = Expander.eval_blang expander mel.enabled_if >>| Toggle.of_bool in
         let+ sources, modules =
           Modules_field_evaluator.eval
             ~expander
@@ -451,7 +465,7 @@ let modules_of_stanzas =
         let modules =
           Modules_group.make_wrapped ~obj_dir:(Obj_dir.obj_dir obj_dir) ~modules `Melange
         in
-        `Melange_emit (mel, sources, modules, obj_dir)
+        `Melange_emit (mel, sources, modules, obj_dir, enabled)
       | _ -> Memo.return `Skip)
     >>| filter_partition_map
 ;;

test/blackbox-tests/test-cases/enabled_if/eif-exe-name-collision-same-folder.t

@@ -27,9 +27,3 @@ in the same dune file
   > EOF
 
   $ dune build
-  File "dune", line 4, characters 0-72:
-  4 | (executable
-  5 |  (name foo)
-  6 |  (enabled_if (= %{context_name} "alt-context")))
-  Error: Executable "foo" appears for the second time in this directory
-  [1]

test/blackbox-tests/test-cases/enabled_if/eif-melange-emit-name-collision-same-folder.t

@@ -28,9 +28,3 @@ in the same dune file
   > EOF
 
   $ dune build
-  File "dune", line 4, characters 0-76:
-  4 | (melange.emit
-  5 |  (target foo)
-  6 |  (enabled_if (= %{context_name} "alt-context")))
-  Error: Target "foo" appears for the second time in this directory
-  [1]

test/blackbox-tests/test-cases/melange/enabled_if.t

@@ -34,7 +34,13 @@
   > EOF
 
   $ dune build @melange --display short
+  Error: Alias "melange" specified on the command line is empty.
+  It is not defined in . or any of its descendants.
+  [1]
 
 No rules attached to the alias
 
   $ dune rules @melange
+  Error: Alias "melange" specified on the command line is empty.
+  It is not defined in . or any of its descendants.
+  [1]

test/blackbox-tests/test-cases/test-build-if/feature.t

@@ -1,4 +1,4 @@
-enabled_if has a limitation: it attempts building even if enabled_if evaluates to false.
+enabled_if and build_if have similar behavior
 
   $ cat > dune-project << EOF
   > (lang dune 3.9)
@@ -39,7 +39,7 @@ We test the various combinations:
 
   $ test_all
   When building @all with ENABLED=unset:
-    build was done: YES
+    build was done: NO
     test did run:   NO
   When building @runtest with ENABLED=unset:
     build was done: NO