fix: punt on all the refactoring

Signed-off-by: Rudi Grinberg <me@rgrinberg.com>

Author: rgrinberg

src/dune_lang/lib_mode.ml

@@ -71,7 +71,7 @@ module Cm_kind = struct
 end
 
 let of_cm_kind : Cm_kind.t -> t = function
-  | Ocaml (Cmi | Cmo | Cmt | Cmti) -> Ocaml Byte
+  | Ocaml (Cmi | Cmo) -> Ocaml Byte
   | Ocaml Cmx -> Ocaml Native
   | Melange (Cmi | Cmj) -> Melange
 ;;

src/dune_lang/pform.ml

@@ -219,32 +219,60 @@ end
 module Artifact = struct
   open Ocaml
 
+  type mod_ =
+    | Cm_kind of Ocaml.Cm_kind.t
+    | Cmt
+    | Cmti
+
+  let dyn_of_mod_ =
+    let open Dyn in
+    function
+    | Cm_kind x -> Ocaml.Cm_kind.to_dyn x
+    | Cmt -> variant "Cmt" []
+    | Cmti -> variant "Cmti" []
+  ;;
+
   type t =
-    | Mod of Cm_kind.t
+    | Mod of mod_
     | Lib of Mode.t
 
+  let compare_mod x y =
+    match x, y with
+    | Cm_kind x, Cm_kind y -> Ocaml.Cm_kind.compare x y
+    | Cm_kind _, _ -> Lt
+    | _, Cm_kind _ -> Gt
+    | Cmt, Cmt -> Eq
+    | Cmt, _ -> Lt
+    | _, Cmt -> Gt
+    | Cmti, Cmti -> Eq
+  ;;
+
   let compare x y =
     match x, y with
-    | Mod x, Mod y -> Cm_kind.compare x y
+    | Mod x, Mod y -> compare_mod x y
     | Mod _, _ -> Lt
     | _, Mod _ -> Gt
     | Lib x, Lib y -> Mode.compare x y
   ;;
 
   let ext = function
-    | Mod cm_kind -> Cm_kind.ext cm_kind
+    | Mod Cmt -> ".cmt"
+    | Mod Cmti -> ".cmti"
+    | Mod (Cm_kind cm_kind) -> Cm_kind.ext cm_kind
     | Lib mode -> Mode.compiled_lib_ext mode
   ;;
 
   let all =
-    List.map ~f:(fun kind -> Mod kind) Cm_kind.all
-    @ List.map ~f:(fun mode -> Lib mode) Mode.all
+    Mod Cmt
+    :: Mod Cmti
+    :: (List.map ~f:(fun kind -> Mod (Cm_kind kind)) Cm_kind.all
+        @ List.map ~f:(fun mode -> Lib mode) Mode.all)
   ;;
 
   let to_dyn a =
     let open Dyn in
     match a with
-    | Mod cm_kind -> variant "Mod" [ Cm_kind.to_dyn cm_kind ]
+    | Mod cm_kind -> variant "Mod" [ dyn_of_mod_ cm_kind ]
     | Lib mode -> variant "Lib" [ Mode.to_dyn mode ]
   ;;
 end

src/dune_lang/pform.mli

@@ -101,8 +101,13 @@ module Var : sig
 end
 
 module Artifact : sig
+  type mod_ =
+    | Cm_kind of Ocaml.Cm_kind.t
+    | Cmt
+    | Cmti
+
   type t =
-    | Mod of Ocaml.Cm_kind.t
+    | Mod of mod_
     | Lib of Ocaml.Mode.t
 
   val compare : t -> t -> Ordering.t

src/dune_rules/check_rules.ml

@@ -1,7 +1,7 @@
 open Import
 
 let dev_files =
-  [ Cm_kind.ext Cmt; Cm_kind.ext Cmti; Cm_kind.ext Cmi ]
+  [ Ml_kind.cmt_ext Impl; Ml_kind.cmt_ext Intf; Cm_kind.ext Cmi ]
   |> List.map ~f:(String.drop_prefix_if_exists ~prefix:".")
   |> Glob.matching_extensions
 ;;

src/dune_rules/expander.ml

@@ -191,7 +191,12 @@ let expand_artifact ~source t artifact arg =
     (match Artifacts_obj.lookup_module artifacts name with
      | None -> does_not_exist ~what:"Module" (Module_name.to_string name)
      | Some (t, m) ->
-       (match Obj_dir.Module.cm_file t m ~kind:(Ocaml kind) with
+       (match
+          match kind with
+          | Cm_kind kind -> Obj_dir.Module.cm_file t m ~kind:(Ocaml kind)
+          | Cmt -> Obj_dir.Module.cmt_file t m ~cm_kind:(Ocaml Cmi) ~ml_kind:Impl
+          | Cmti -> Some (Obj_dir.Module.cmti_file t m ~cm_kind:(Ocaml Cmi))
+        with
         | None -> Action_builder.return [ Value.String "" ]
         | Some path -> dep (Path.build path)))
   | Lib mode ->

src/dune_rules/module_compilation.ml

@@ -62,7 +62,7 @@ let copy_interface ~sctx ~dir ~obj_dir ~cm_kind m =
 
 let melange_args (cctx : Compilation_context.t) (cm_kind : Lib_mode.Cm_kind.t) module_ =
   match cm_kind with
-  | Ocaml (Cmi | Cmo | Cmx | Cmt | Cmti) | Melange Cmi -> []
+  | Ocaml (Cmi | Cmo | Cmx) | Melange Cmi -> []
   | Melange Cmj ->
     let melange_extension_version =
       let scope = Compilation_context.scope cctx in
@@ -188,15 +188,15 @@ let build_cm
               Command.Args.Hidden_targets
                 [ Obj_dir.Module.cm_file_exn obj_dir m ~kind:cmi_kind ]
           | (Ocaml Cmo | Melange Cmj), None, true
-          | (Ocaml (Cmo | Cmx | Cmt) | Melange Cmj), _, _ ->
+          | (Ocaml (Cmo | Cmx) | Melange Cmj), _, _ ->
             Memo.return (force_read_cmi ~obj_dir ~version:ocaml.version ~cm_kind ~src m)
-          | (Ocaml (Cmi | Cmti) | Melange Cmi), _, _ ->
+          | (Ocaml Cmi | Melange Cmi), _, _ ->
             let+ () = copy_interface ~dir ~obj_dir ~sctx ~cm_kind m in
             Command.Args.empty))
    in
    let other_targets =
      match cm_kind with
-     | Ocaml (Cmi | Cmo | Cmt | Cmti) | Melange (Cmi | Cmj) -> Command.Args.empty
+     | Ocaml (Cmi | Cmo) | Melange (Cmi | Cmj) -> Command.Args.empty
      | Ocaml Cmx ->
        (match phase with
         | Some Compile ->
@@ -215,7 +215,6 @@ let build_cm
    let cmt_args =
      match cm_kind with
      | Ocaml Cmx -> Command.Args.empty
-     | Ocaml (Cmt | Cmti) -> As [ "-bin-annot" ]
      | Ocaml (Cmi | Cmo) | Melange (Cmi | Cmj) ->
        if Compilation_context.bin_annot cctx
        then (

src/dune_rules/obj_dir.ml

@@ -90,7 +90,7 @@ module External = struct
     | Ocaml Cmi, Public, _ -> public_cmi_ocaml_dir t
     | Melange Cmi, Public, _ -> public_cmi_melange_dir t
     | Melange Cmj, _, _ -> t.melange_dir
-    | Ocaml (Cmo | Cmx | Cmt | Cmti), _, _ -> t.public_dir
+    | Ocaml (Cmo | Cmx), _, _ -> t.public_dir
   ;;
 
   let encode
@@ -165,7 +165,7 @@ module External = struct
   let cm_public_dir t (cm_kind : Lib_mode.Cm_kind.t) =
     match cm_kind with
     | Ocaml Cmx -> native_dir t
-    | Ocaml (Cmo | Cmt | Cmti) -> byte_dir t
+    | Ocaml Cmo -> byte_dir t
     | Ocaml Cmi -> public_cmi_ocaml_dir t
     | Melange Cmj -> melange_dir t
     | Melange Cmi -> public_cmi_melange_dir t
@@ -321,14 +321,14 @@ module Local = struct
   let cm_dir t (cm_kind : Lib_mode.Cm_kind.t) _ =
     match cm_kind with
     | Ocaml Cmx -> native_dir t
-    | Ocaml (Cmo | Cmi | Cmt | Cmti) -> byte_dir t
+    | Ocaml (Cmo | Cmi) -> byte_dir t
     | Melange (Cmj | Cmi) -> melange_dir t
   ;;
 
   let cm_public_dir t (cm_kind : Lib_mode.Cm_kind.t) =
     match cm_kind with
     | Ocaml Cmx -> native_dir t
-    | Ocaml (Cmo | Cmt | Cmti) -> byte_dir t
+    | Ocaml Cmo -> byte_dir t
     | Ocaml Cmi -> public_cmi_ocaml_dir t
     | Melange Cmj -> melange_dir t
     | Melange Cmi -> public_cmi_melange_dir t
@@ -513,8 +513,7 @@ module Module = struct
 
   let has_impl_if_needed m ~(kind : Lib_mode.Cm_kind.t) =
     match kind with
-    | Ocaml (Cmo | Cmx | Cmt) | Melange Cmj -> Module.has m ~ml_kind:Impl
-    | Ocaml Cmti -> Module.has m ~ml_kind:Intf
+    | Ocaml (Cmo | Cmx) | Melange Cmj -> Module.has m ~ml_kind:Impl
     | Ocaml Cmi | Melange Cmi -> true
   ;;
 
@@ -576,20 +575,17 @@ module Module = struct
 
   let cmt_file t m ~(ml_kind : Ml_kind.t) ~cm_kind =
     let file = Module.file m ~ml_kind in
-    let ext =
-      match ml_kind with
-      | Impl -> Cm_kind.ext Cmt
-      | Intf -> Cm_kind.ext Cmti
-    in
+    let ext = Ml_kind.cmt_ext ml_kind in
     let cmi_kind = Lib_mode.Cm_kind.cmi cm_kind in
     Option.map file ~f:(fun _ -> obj_file t m ~kind:cmi_kind ~ext)
   ;;
 
   let cmti_file t m ~cm_kind =
     let ext =
-      match Module.file m ~ml_kind:Intf with
-      | None -> Cm_kind.ext Cmt
-      | Some _ -> Cm_kind.ext Cmti
+      Ml_kind.cmt_ext
+        (match Module.file m ~ml_kind:Intf with
+         | None -> Impl
+         | Some _ -> Intf)
     in
     let cmi_kind = Lib_mode.Cm_kind.cmi cm_kind in
     obj_file t m ~kind:cmi_kind ~ext

src/ocaml/cm_kind.ml

@@ -4,8 +4,6 @@ type t =
   | Cmi
   | Cmo
   | Cmx
-  | Cmt
-  | Cmti
 
 let compare x y : Ordering.t =
   match x, y with
@@ -16,35 +14,25 @@ let compare x y : Ordering.t =
   | Cmo, _ -> Lt
   | _, Cmo -> Gt
   | Cmx, Cmx -> Eq
-  | Cmx, _ -> Lt
-  | _, Cmx -> Gt
-  | Cmt, Cmt -> Eq
-  | Cmt, _ -> Lt
-  | _, Cmt -> Gt
-  | Cmti, Cmti -> Eq
 ;;
 
-let all = [ Cmi; Cmo; Cmx; Cmt; Cmti ]
+let all = [ Cmi; Cmo; Cmx ]
 
-let choose cmi cmo cmx cmt cmti = function
+let choose cmi cmo cmx = function
   | Cmi -> cmi
   | Cmo -> cmo
   | Cmx -> cmx
-  | Cmt -> cmt
-  | Cmti -> cmti
 ;;
 
-let ext = choose ".cmi" ".cmo" ".cmx" ".cmt" ".cmti"
-let source = choose Ml_kind.Intf Impl Impl Impl Intf
+let ext = choose ".cmi" ".cmo" ".cmx"
+let source = choose Ml_kind.Intf Impl Impl
 
 let to_dyn =
   let open Dyn in
   function
   | Cmi -> variant "cmi" []
   | Cmo -> variant "cmo" []
   | Cmx -> variant "cmx" []
-  | Cmt -> variant "cmt" []
-  | Cmti -> variant "cmti" []
 ;;
 
 module Dict = struct
@@ -58,10 +46,6 @@ module Dict = struct
     | Cmi -> t.cmi
     | Cmo -> t.cmo
     | Cmx -> t.cmx
-    | (Cmt | Cmti) as cm_kind ->
-      Code_error.raise
-        "Cm_kind.Dict.get doesnt support this case"
-        [ "cm_kind", to_dyn cm_kind ]
   ;;
 
   let of_func f = { cmi = f ~cm_kind:Cmi; cmo = f ~cm_kind:Cmo; cmx = f ~cm_kind:Cmx }

src/ocaml/cm_kind.mli

@@ -4,8 +4,6 @@ type t =
   | Cmi
   | Cmo
   | Cmx
-  | Cmt
-  | Cmti
 
 val compare : t -> t -> Ordering.t
 val all : t list

src/ocaml/ml_kind.ml

@@ -15,6 +15,11 @@ let choose t ~impl ~intf =
 let to_string = choose ~impl:"impl" ~intf:"intf"
 let to_dyn t = Dyn.String (to_string t)
 
+let cmt_ext = function
+  | Impl -> ".cmt"
+  | Intf -> ".cmti"
+;;
+
 module Dict = struct
   type 'a t =
     { impl : 'a