melange: use --mel-* flags for the (melange 1.0) extension version (ocaml#12081)

Signed-off-by: Antonio Nuno Monteiro <[email protected]>

Author: anmonteiro

src/dune_rules/lib_rules.ml

@@ -510,10 +510,10 @@ let cctx (lib : Library.t) ~sctx ~source_modules ~dir ~expander ~scope ~compile_
   let package = Library.package lib in
   let js_of_ocaml = Js_of_ocaml.In_context.make ~dir lib.buildable.js_of_ocaml in
   (* XXX(anmonteiro): `melange_package_name` is used to derive Melange's
-     `--bs-package-name` argument. We only use the library name for public
+     `--mel-package-name` argument. We only use the library name for public
      libraries / private libraries with `(package ..)` because we need Melange
      to preserve relative paths for private libs (i.e. not pass the
-     `--bs-package-name` arg). *)
+     `--mel-package-name` arg). *)
   let melange_package_name =
     match lib.visibility with
     | Public p -> Some (Public_lib.name p)

src/dune_rules/melange/melange_rules.ml

@@ -214,6 +214,7 @@ let js_targets_of_libs ~sctx ~scope ~module_systems ~target_dir libs =
 let build_js
       ~loc
       ~dir
+      ~scope
       ~pkg_name
       ~mode
       ~module_systems
@@ -225,6 +226,11 @@ let build_js
       ~local_modules_and_obj_dir
       m
   =
+  let melange_extension_version =
+    let project = Scope.project scope in
+    Dune_project.find_extension_version project Dune_lang.Melange.syntax
+    |> Option.value_exn
+  in
   let* compiler = Melange_binary.melc sctx ~loc:(Some loc) ~dir in
   Memo.parallel_iter module_systems ~f:(fun (module_system, js_ext) ->
     let build =
@@ -234,12 +240,19 @@ let build_js
         let obj_dir = [ Command.Args.A "-I"; Path (Obj_dir.melange_dir obj_dir) ] in
         let melange_package_args =
           let pkg_name_args =
-            match pkg_name with
-            | None -> []
-            | Some pkg_name -> [ "--bs-package-name"; Package.Name.to_string pkg_name ]
+            match pkg_name, melange_extension_version with
+            | None, _ -> []
+            | Some pkg_name, (0, 1) ->
+              [ "--bs-package-name"; Package.Name.to_string pkg_name ]
+            | Some pkg_name, _ ->
+              [ "--mel-package-name"; Package.Name.to_string pkg_name ]
           in
           let js_modules_str = Melange.Module_system.to_string module_system in
-          "--bs-module-type" :: js_modules_str :: pkg_name_args
+          (if melange_extension_version >= (1, 0)
+           then "--mel-module-type"
+           else "--bs-module-type")
+          :: js_modules_str
+          :: pkg_name_args
         in
         Command.run
           ~dir:(Super_context.context sctx |> Context.build_dir |> Path.build)
@@ -530,8 +543,9 @@ let setup_entries_js
   in
   Memo.parallel_iter modules_for_js ~f:(fun m ->
     build_js
-      ~dir
       ~loc
+      ~dir
+      ~scope
       ~pkg_name
       ~mode
       ~module_systems
@@ -561,7 +575,7 @@ let setup_js_rules_libraries =
     Memo.parallel_iter source_modules ~f:(build_js ~local_modules_and_obj_dir)
   in
   fun ~dir ~scope ~target_dir ~sctx ~requires_link ~mode (mel : Melange_stanzas.Emit.t) ->
-    let build_js = build_js ~sctx ~mode ~module_systems:mel.module_systems in
+    let build_js = build_js ~sctx ~scope ~mode ~module_systems:mel.module_systems in
     let with_vlib_implementations =
       let vlib_implementations =
         (* vlib_name => concrete_impl *)

src/dune_rules/module_compilation.ml

@@ -64,7 +64,13 @@ let melange_args (cctx : Compilation_context.t) (cm_kind : Lib_mode.Cm_kind.t) m
   match cm_kind with
   | Ocaml (Cmi | Cmo | Cmx) | Melange Cmi -> []
   | Melange Cmj ->
-    let bs_package_name, bs_package_output =
+    let melange_extension_version =
+      let scope = Compilation_context.scope cctx in
+      let dune_project = Scope.project scope in
+      Dune_project.find_extension_version dune_project Dune_lang.Melange.syntax
+      |> Option.value_exn
+    in
+    let mel_package_name, mel_package_output =
       let package_output =
         Module.file ~ml_kind:Impl module_ |> Option.value_exn |> Path.parent_exn
       in
@@ -84,15 +90,29 @@ let melange_args (cctx : Compilation_context.t) (cm_kind : Lib_mode.Cm_kind.t) m
           |> Path.Local.to_string
           |> Path.Build.relative build_dir
         in
-        ( [ Command.Args.A "--bs-package-name"; A (Lib_name.to_string lib_name) ]
+        ( [ Command.Args.A
+              (if melange_extension_version >= (1, 0)
+               then "--mel-package-name"
+               else "--bs-package-name")
+          ; A (Lib_name.to_string lib_name)
+          ]
         , Path.build dir )
     in
-    Command.Args.A "--bs-stop-after-cmj"
-    :: A "--bs-package-output"
-    :: Command.Args.Path bs_package_output
-    :: A "--bs-module-name"
-    :: A (Melange.js_basename module_)
-    :: bs_package_name
+    if melange_extension_version >= (1, 0)
+    then
+      Command.Args.A "--mel-stop-after-cmj"
+      :: A "--mel-package-output"
+      :: Command.Args.Path mel_package_output
+      :: A "--mel-module-name"
+      :: A (Melange.js_basename module_)
+      :: mel_package_name
+    else
+      Command.Args.A "--bs-stop-after-cmj"
+      :: A "--bs-package-output"
+      :: Command.Args.Path mel_package_output
+      :: A "--bs-module-name"
+      :: A (Melange.js_basename module_)
+      :: mel_package_name
 ;;
 
 let build_cm

test/blackbox-tests/test-cases/melange/melange-stanza-version.t

@@ -0,0 +1,42 @@
+Test Melange extension stanza versioning
+
+  $ cat > dune-project <<EOF
+  > (lang dune 3.8)
+  > (using melange 1.0)
+  > (package (name pkg))
+  > EOF
+
+  $ mkdir app
+  $ cat > app/dune <<EOF
+  > (library
+  >  (public_name pkg)
+  >  (modes melange))
+  > EOF
+  $ cat > app/app.ml <<EOF
+  > let x = "hello"
+  > EOF
+
+Only supported after Dune 3.20
+  $ dune rules app/.pkg.objs/melange/pkg__App.cmj
+  File "dune-project", line 2, characters 15-18:
+  2 | (using melange 1.0)
+                     ^^^
+  Error: Version 1.0 of the Melange extension is not supported until version
+  3.20 of the dune language.
+  Supported versions of this extension in version 3.8 of the dune language:
+  - 0.1
+  [1]
+
+  $ cat > dune-project <<EOF
+  > (lang dune 3.20)
+  > (using melange 1.0)
+  > (package (name pkg))
+  > EOF
+
+Cmj rules should include --mel-package-output
+  $ dune rules app/.pkg.objs/melange/pkg__App.cmj |
+  > grep -e "--mel-package-name" --after-context=1
+      --mel-package-name
+      pkg
+
+