28906

Committed 03 Nov 2024 03:55PM UTC coverage: 6.917% (+0.005%) from 6.912%

Build # 28906

Build Type

push

github

Committed by

web-flow

Commit Message

refactor: remove a bunch of useless "let open Memo.O in" (#11086)

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

Run Details

0 of 6 new or added lines in 3 files covered. (0.0%)

66 existing lines in 40 files now uncovered.

2933 of 42401 relevant lines covered (6.92%)

26866.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.85

/src/dune_rules/compilation_context.ml

open Import
open Memo.O

module Includes = struct
  type t = Command.Args.without_targets Command.Args.t Lib_mode.Cm_kind.Map.t

  let make ~project ~opaque ~direct_requires ~hidden_requires : _ Lib_mode.Cm_kind.Map.t =
    (* TODO : some of the requires can filtered out using [ocamldep] info *)
    let open Resolve.Memo.O in
    let iflags direct_libs hidden_libs mode =
      Lib_flags.L.include_flags ~project ~direct_libs ~hidden_libs mode
    in
    let make_includes_args ~mode groups =
      Command.Args.memo
        (Resolve.Memo.args
           (let+ direct_libs = direct_requires
            and+ hidden_libs = hidden_requires in
            Command.Args.S
              [ iflags direct_libs hidden_libs mode
              ; Hidden_deps (Lib_file_deps.deps (direct_libs @ hidden_libs) ~groups)
              ]))
    in
    let cmi_includes = make_includes_args ~mode:(Ocaml Byte) [ Ocaml Cmi ] in
    let cmx_includes =
      Command.Args.memo
        (Resolve.Memo.args
           (let+ direct_libs = direct_requires
            and+ hidden_libs = hidden_requires in
            Command.Args.S
              [ iflags direct_libs hidden_libs (Ocaml Native)
              ; Hidden_deps
                  (if opaque
                   then
                     List.map (direct_libs @ hidden_libs) ~f:(fun lib ->
                       ( lib
                       , if Lib.is_local lib
                         then [ Lib_file_deps.Group.Ocaml Cmi ]
                         else [ Ocaml Cmi; Ocaml Cmx ] ))
                     |> Lib_file_deps.deps_with_exts
                   else
                     Lib_file_deps.deps
                       (direct_libs @ hidden_libs)
                       ~groups:[ Lib_file_deps.Group.Ocaml Cmi; Ocaml Cmx ])
              ]))
    in
    let melange_cmi_includes = make_includes_args ~mode:Melange [ Melange Cmi ] in
    let melange_cmj_includes =
      make_includes_args ~mode:Melange [ Melange Cmi; Melange Cmj ]
    in
    { ocaml = { cmi = cmi_includes; cmo = cmi_includes; cmx = cmx_includes }
    ; melange = { cmi = melange_cmi_includes; cmj = melange_cmj_includes }
    }
  ;;

  let empty = Lib_mode.Cm_kind.Map.make_all Command.Args.empty
end

type opaque =
  | Explicit of bool
  | Inherit_from_settings

let eval_opaque (ocaml : Ocaml_toolchain.t) profile = function
  | Explicit b -> b
  | Inherit_from_settings ->
    Profile.is_dev profile && Ocaml.Version.supports_opaque_for_mli ocaml.version
;;

type modules =
  { modules : Modules.With_vlib.t
  ; dep_graphs : Dep_graph.t Ml_kind.Dict.t
  }

let singleton_modules m =
  { modules = Modules.With_vlib.singleton m; dep_graphs = Dep_graph.Ml_kind.dummy m }
;;

type t =
  { super_context : Super_context.t
  ; scope : Scope.t
  ; obj_dir : Path.Build.t Obj_dir.t
  ; modules : modules
  ; flags : Ocaml_flags.t
  ; requires_compile : Lib.t list Resolve.Memo.t
  ; requires_hidden : Lib.t list Resolve.Memo.t
  ; requires_link : Lib.t list Resolve.t Memo.Lazy.t
  ; includes : Includes.t
  ; preprocessing : Pp_spec.t
  ; opaque : bool
  ; stdlib : Ocaml_stdlib.t option
  ; js_of_ocaml : Js_of_ocaml.In_context.t option
  ; sandbox : Sandbox_config.t
  ; package : Package.t option
  ; vimpl : Vimpl.t option
  ; melange_package_name : Lib_name.t option
  ; modes : Lib_mode.Map.Set.t
  ; bin_annot : bool
  ; ocamldep_modules_data : Ocamldep.Modules_data.t
  ; loc : Loc.t option
  ; ocaml : Ocaml_toolchain.t
  }

let loc t = t.loc
let super_context t = t.super_context
let scope t = t.scope
let dir t = Obj_dir.dir t.obj_dir
let obj_dir t = t.obj_dir
let modules t = t.modules.modules
let flags t = t.flags
let requires_compile t = t.requires_compile
let requires_hidden t = t.requires_hidden
let requires_link t = Memo.Lazy.force t.requires_link
let includes t = t.includes
let preprocessing t = t.preprocessing
let opaque t = t.opaque
let stdlib t = t.stdlib
let js_of_ocaml t = t.js_of_ocaml
let sandbox t = t.sandbox
let set_sandbox t sandbox = { t with sandbox }
let package t = t.package
let melange_package_name t = t.melange_package_name
let vimpl t = t.vimpl
let modes t = t.modes
let bin_annot t = t.bin_annot
let context t = Super_context.context t.super_context
let ocamldep_modules_data t = t.ocamldep_modules_data
let dep_graphs t = t.modules.dep_graphs
let ocaml t = t.ocaml

let create
  ~super_context
  ~scope
  ~obj_dir
  ~modules
  ~flags
  ~requires_compile
  ~requires_link
  ?(preprocessing = Pp_spec.dummy)
  ~opaque
  ?stdlib
  ~js_of_ocaml
  ~package
  ~melange_package_name
  ?vimpl
  ?modes
  ?bin_annot
  ?loc
  ()
  =
  let project = Scope.project scope in
  let context = Super_context.context super_context in
  let* ocaml = Context.ocaml context in
  let direct_requires, hidden_requires =
    if Dune_project.implicit_transitive_deps project
    then Memo.Lazy.force requires_link, Resolve.Memo.return []
    else if Version.supports_hidden_includes ocaml.version
            && Dune_project.dune_version project >= (3, 17)
    then (
      let requires_hidden =
        let open Resolve.Memo.O in
        let+ requires_compile = requires_compile
        and+ requires_link = Memo.Lazy.force requires_link in
        let requires_table = Table.create (module Lib) 5 in
        List.iter ~f:(fun lib -> Table.set requires_table lib ()) requires_compile;
        List.filter requires_link ~f:(fun l -> not (Table.mem requires_table l))
      in
      requires_compile, requires_hidden)
    else requires_compile, Resolve.Memo.return []
  in
  let sandbox = Sandbox_config.no_special_requirements in
  let modes =
    let default =
      { Lib_mode.Map.ocaml = Mode.Dict.make_both (Some Mode_conf.Kind.Inherited)
      ; melange = None
      }
    in
    Option.value ~default modes |> Lib_mode.Map.map ~f:Option.is_some
  in
  let opaque =
    let profile = Context.profile context in
    eval_opaque ocaml profile opaque
  in
  let ocamldep_modules_data : Ocamldep.Modules_data.t =
    { dir = Obj_dir.dir obj_dir
    ; sandbox
    ; obj_dir
    ; sctx = super_context
    ; vimpl
    ; modules
    ; stdlib
    }
  in
  let+ dep_graphs = Dep_rules.rules ocamldep_modules_data
  and+ bin_annot =
    match bin_annot with
    | Some b -> Memo.return b
    | None -> Env_stanza_db.bin_annot ~dir:(Obj_dir.dir obj_dir)
  in
  { super_context
  ; scope
  ; obj_dir
  ; modules = { modules; dep_graphs }
  ; flags
  ; requires_compile = direct_requires
  ; requires_hidden = hidden_requires
  ; requires_link
  ; includes = Includes.make ~project ~opaque ~direct_requires ~hidden_requires
  ; preprocessing
  ; opaque
  ; stdlib
  ; js_of_ocaml
  ; sandbox
  ; package
  ; vimpl
  ; melange_package_name
  ; modes
  ; bin_annot
  ; ocamldep_modules_data
  ; loc
  ; ocaml
  }
;;

let alias_and_root_module_flags =
  let extra = [ "-w"; "-49"; "-nopervasives"; "-nostdlib" ] in
  fun base -> Ocaml_flags.append_common base extra
;;

let for_alias_module t alias_module =
  let keep_flags = Modules.With_vlib.is_stdlib_alias (modules t) alias_module in
  let flags =
    if keep_flags
    then (* in the case of stdlib, these flags can be written by the user *)
      t.flags
    else (
      let project = Scope.project t.scope in
      let dune_version = Dune_project.dune_version project in
      let profile = Super_context.context t.super_context |> Context.profile in
      Ocaml_flags.default ~dune_version ~profile)
  in
  let sandbox =
    (* If the compiler reads the cmi for module alias even with [-w -49
       -no-alias-deps], we must sandbox the build of the alias module since the
       modules it references are built after. *)
    if Ocaml.Version.always_reads_alias_cmi t.ocaml.version
    then Sandbox_config.needs_sandboxing
    else Sandbox_config.no_special_requirements
  in
  let (modules, includes) : modules * Includes.t =
    match Modules.With_vlib.is_stdlib_alias t.modules.modules alias_module with
    | false -> singleton_modules alias_module, Includes.empty
    | true ->
      (* The stdlib alias module is different from the alias modules usually
         produced by Dune: it contains code and depends on a few other
         [CamlinnternalXXX] modules from the stdlib, so we need the full set of
         modules to compile it. *)
      t.modules, t.includes
  in
  { t with
    flags = alias_and_root_module_flags flags
  ; includes
  ; stdlib = None
  ; sandbox
  ; modules
  }
;;

let for_root_module t root_module =
  let flags =
    let project = Scope.project t.scope in
    let dune_version = Dune_project.dune_version project in
    let profile = Super_context.context t.super_context |> Context.profile in
    Ocaml_flags.default ~profile ~dune_version
  in
  { t with
    flags = alias_and_root_module_flags flags
  ; stdlib = None
  ; modules = singleton_modules root_module
  }
;;

let for_module_generated_at_link_time cctx ~requires ~module_ =
  let opaque =
    (* Cmi's of link time generated modules are compiled with -opaque, hence
       their implementation must also be compiled with -opaque *)
    Ocaml.Version.supports_opaque_for_mli cctx.ocaml.version
  in
  let direct_requires = requires in
  let hidden_requires = Resolve.Memo.return [] in
  let modules = singleton_modules module_ in
  let includes =
    Includes.make
      ~project:(Scope.project cctx.scope)
      ~opaque
      ~direct_requires
      ~hidden_requires
  in
  { cctx with
    opaque
  ; flags = Ocaml_flags.empty
  ; requires_link = Memo.lazy_ (fun () -> requires)
  ; requires_compile = requires
  ; includes
  ; modules
  }
;;

let for_wrapped_compat t =
  (* See #10689 *)
  let flags = Ocaml_flags.append_common t.flags [ "-w"; "-53" ] in
  { t with includes = Includes.empty; stdlib = None; flags }
;;

let for_plugin_executable t ~embed_in_plugin_libraries =
  let libs = Scope.libs t.scope in
  let requires_link =
    Memo.lazy_ (fun () ->
      Resolve.Memo.List.map ~f:(Lib.DB.resolve libs) embed_in_plugin_libraries)
  in
  { t with requires_link }
;;

let without_bin_annot t = { t with bin_annot = false }

let entry_module_names sctx t =
  match Lib_info.entry_modules (Lib.info t) with
  | External d -> Resolve.Memo.of_result d
  | Local ->
    let+ modules = Dir_contents.modules_of_lib sctx t in
    let modules = Option.value_exn modules in
    Resolve.return (Modules.With_vlib.entry_modules modules |> List.map ~f:Module.name)
;;

let root_module_entries t =
  let open Action_builder.O in
  let* requires = Resolve.Memo.read t.requires_compile in
  let* l =
    Action_builder.List.map requires ~f:(fun lib ->
      Action_builder.of_memo (entry_module_names t.super_context lib) >>= Resolve.read)
  in
  Action_builder.return (List.concat l)
;;

let set_obj_dir t obj_dir = { t with obj_dir }
let set_modes t ~modes = { t with modes }

1	open Import
2	open Memo.O
3
4	module Includes = struct
5	type t = Command.Args.without_targets Command.Args.t Lib_mode.Cm_kind.Map.t
6
7	let make ~project ~opaque ~direct_requires ~hidden_requires : _ Lib_mode.Cm_kind.Map.t =
8	(* TODO : some of the requires can filtered out using [ocamldep] info *)
9	let open Resolve.Memo.O in	×
10	let iflags direct_libs hidden_libs mode =
11	Lib_flags.L.include_flags ~project ~direct_libs ~hidden_libs mode	×
12	in
13	let make_includes_args ~mode groups =
14	Command.Args.memo	×
15	(Resolve.Memo.args	×
16	(let+ direct_libs = direct_requires
17	and+ hidden_libs = hidden_requires in
18	Command.Args.S	×
19	[ iflags direct_libs hidden_libs mode	×
20	; Hidden_deps (Lib_file_deps.deps (direct_libs @ hidden_libs) ~groups)	×
21	]))
22	in
23	let cmi_includes = make_includes_args ~mode:(Ocaml Byte) [ Ocaml Cmi ] in
24	let cmx_includes =	×
25	Command.Args.memo
26	(Resolve.Memo.args	×
27	(let+ direct_libs = direct_requires
28	and+ hidden_libs = hidden_requires in
29	Command.Args.S	×
30	[ iflags direct_libs hidden_libs (Ocaml Native)	×
31	; Hidden_deps
32	(if opaque
33	then
34	List.map (direct_libs @ hidden_libs) ~f:(fun lib ->
35	( lib	×
36	, if Lib.is_local lib
37	then [ Lib_file_deps.Group.Ocaml Cmi ]	×
38	else [ Ocaml Cmi; Ocaml Cmx ] ))	×
39	\|> Lib_file_deps.deps_with_exts	×
40	else
41	Lib_file_deps.deps	×
42	(direct_libs @ hidden_libs)
43	~groups:[ Lib_file_deps.Group.Ocaml Cmi; Ocaml Cmx ])
44	]))
45	in
46	let melange_cmi_includes = make_includes_args ~mode:Melange [ Melange Cmi ] in	×
47	let melange_cmj_includes =	×
48	make_includes_args ~mode:Melange [ Melange Cmi; Melange Cmj ]
49	in
50	{ ocaml = { cmi = cmi_includes; cmo = cmi_includes; cmx = cmx_includes }	×
51	; melange = { cmi = melange_cmi_includes; cmj = melange_cmj_includes }
52	}
53	;;
54
55	let empty = Lib_mode.Cm_kind.Map.make_all Command.Args.empty	38✔
56	end
57
58	type opaque =
59	\| Explicit of bool
60	\| Inherit_from_settings
61
62	let eval_opaque (ocaml : Ocaml_toolchain.t) profile = function
63	\| Explicit b -> b	×
64	\| Inherit_from_settings ->	×
65	Profile.is_dev profile && Ocaml.Version.supports_opaque_for_mli ocaml.version	×
66	;;
67
68	type modules =
69	{ modules : Modules.With_vlib.t
70	; dep_graphs : Dep_graph.t Ml_kind.Dict.t
71	}
72
73	let singleton_modules m =
74	{ modules = Modules.With_vlib.singleton m; dep_graphs = Dep_graph.Ml_kind.dummy m }	×
75	;;
76
77	type t =
78	{ super_context : Super_context.t
79	; scope : Scope.t
80	; obj_dir : Path.Build.t Obj_dir.t
81	; modules : modules
82	; flags : Ocaml_flags.t
83	; requires_compile : Lib.t list Resolve.Memo.t
84	; requires_hidden : Lib.t list Resolve.Memo.t
85	; requires_link : Lib.t list Resolve.t Memo.Lazy.t
86	; includes : Includes.t
87	; preprocessing : Pp_spec.t
88	; opaque : bool
89	; stdlib : Ocaml_stdlib.t option
90	; js_of_ocaml : Js_of_ocaml.In_context.t option
91	; sandbox : Sandbox_config.t
92	; package : Package.t option
93	; vimpl : Vimpl.t option
94	; melange_package_name : Lib_name.t option
95	; modes : Lib_mode.Map.Set.t
96	; bin_annot : bool
97	; ocamldep_modules_data : Ocamldep.Modules_data.t
98	; loc : Loc.t option
99	; ocaml : Ocaml_toolchain.t
100	}
101
102	let loc t = t.loc	×
103	let super_context t = t.super_context	×
104	let scope t = t.scope	×
105	let dir t = Obj_dir.dir t.obj_dir	×
106	let obj_dir t = t.obj_dir	×
107	let modules t = t.modules.modules	×
108	let flags t = t.flags	×
109	let requires_compile t = t.requires_compile	×
110	let requires_hidden t = t.requires_hidden	×
111	let requires_link t = Memo.Lazy.force t.requires_link	×
112	let includes t = t.includes	×
113	let preprocessing t = t.preprocessing	×
114	let opaque t = t.opaque	×
115	let stdlib t = t.stdlib	×
116	let js_of_ocaml t = t.js_of_ocaml	×
117	let sandbox t = t.sandbox	×
118	let set_sandbox t sandbox = { t with sandbox }	×
119	let package t = t.package	×
120	let melange_package_name t = t.melange_package_name	×
121	let vimpl t = t.vimpl	×
122	let modes t = t.modes	×
123	let bin_annot t = t.bin_annot	×
124	let context t = Super_context.context t.super_context	×
125	let ocamldep_modules_data t = t.ocamldep_modules_data	×
126	let dep_graphs t = t.modules.dep_graphs	×
127	let ocaml t = t.ocaml	×
128
129	let create
130	~super_context
131	~scope
132	~obj_dir
133	~modules
134	~flags
135	~requires_compile
136	~requires_link
137	?(preprocessing = Pp_spec.dummy)	×
138	~opaque
139	?stdlib
140	~js_of_ocaml
141	~package
142	~melange_package_name
143	?vimpl
144	?modes
145	?bin_annot
146	?loc
147	()
148	=
149	let project = Scope.project scope in	×
UNCOV 150	let context = Super_context.context super_context in	×
151	let* ocaml = Context.ocaml context in	×
152	let direct_requires, hidden_requires =	×
153	if Dune_project.implicit_transitive_deps project
154	then Memo.Lazy.force requires_link, Resolve.Memo.return []	×
155	else if Version.supports_hidden_includes ocaml.version	×
156	&& Dune_project.dune_version project >= (3, 17)	×
157	then (	×
158	let requires_hidden =
159	let open Resolve.Memo.O in
160	let+ requires_compile = requires_compile
161	and+ requires_link = Memo.Lazy.force requires_link in	×
162	let requires_table = Table.create (module Lib) 5 in	×
163	List.iter ~f:(fun lib -> Table.set requires_table lib ()) requires_compile;	×
164	List.filter requires_link ~f:(fun l -> not (Table.mem requires_table l))	×
165	in
166	requires_compile, requires_hidden)
167	else requires_compile, Resolve.Memo.return []	×
168	in
169	let sandbox = Sandbox_config.no_special_requirements in
170	let modes =
171	let default =
172	{ Lib_mode.Map.ocaml = Mode.Dict.make_both (Some Mode_conf.Kind.Inherited)	×
173	; melange = None
174	}
175	in
176	Option.value ~default modes \|> Lib_mode.Map.map ~f:Option.is_some	×
177	in
178	let opaque =
179	let profile = Context.profile context in
180	eval_opaque ocaml profile opaque	×
181	in
182	let ocamldep_modules_data : Ocamldep.Modules_data.t =
183	{ dir = Obj_dir.dir obj_dir	×
184	; sandbox
185	; obj_dir
186	; sctx = super_context
187	; vimpl
188	; modules
189	; stdlib
190	}
191	in
192	let+ dep_graphs = Dep_rules.rules ocamldep_modules_data	×
193	and+ bin_annot =
194	match bin_annot with
195	\| Some b -> Memo.return b	×
196	\| None -> Env_stanza_db.bin_annot ~dir:(Obj_dir.dir obj_dir)	×
197	in
198	{ super_context	×
199	; scope
200	; obj_dir
201	; modules = { modules; dep_graphs }
202	; flags
203	; requires_compile = direct_requires
204	; requires_hidden = hidden_requires
205	; requires_link
206	; includes = Includes.make ~project ~opaque ~direct_requires ~hidden_requires
207	; preprocessing
208	; opaque
209	; stdlib
210	; js_of_ocaml
211	; sandbox
212	; package
213	; vimpl
214	; melange_package_name
215	; modes
216	; bin_annot
217	; ocamldep_modules_data
218	; loc
219	; ocaml
220	}
221	;;
222
223	let alias_and_root_module_flags =
224	let extra = [ "-w"; "-49"; "-nopervasives"; "-nostdlib" ] in
225	fun base -> Ocaml_flags.append_common base extra	×
226	;;
227
228	let for_alias_module t alias_module =
229	let keep_flags = Modules.With_vlib.is_stdlib_alias (modules t) alias_module in	×
230	let flags =	×
231	if keep_flags
232	then (* in the case of stdlib, these flags can be written by the user *)
233	t.flags	×
234	else (	×
235	let project = Scope.project t.scope in
236	let dune_version = Dune_project.dune_version project in	×
237	let profile = Super_context.context t.super_context \|> Context.profile in	×
238	Ocaml_flags.default ~dune_version ~profile)	×
239	in
240	let sandbox =
241	(* If the compiler reads the cmi for module alias even with [-w -49
242	-no-alias-deps], we must sandbox the build of the alias module since the
243	modules it references are built after. *)
244	if Ocaml.Version.always_reads_alias_cmi t.ocaml.version
245	then Sandbox_config.needs_sandboxing	×
246	else Sandbox_config.no_special_requirements	×
247	in
248	let (modules, includes) : modules * Includes.t =
249	match Modules.With_vlib.is_stdlib_alias t.modules.modules alias_module with
250	\| false -> singleton_modules alias_module, Includes.empty	×
251	\| true ->	×
252	(* The stdlib alias module is different from the alias modules usually
253	produced by Dune: it contains code and depends on a few other
254	[CamlinnternalXXX] modules from the stdlib, so we need the full set of
255	modules to compile it. *)
256	t.modules, t.includes
257	in
258	{ t with
259	flags = alias_and_root_module_flags flags	×
260	; includes
261	; stdlib = None
262	; sandbox
263	; modules
264	}
265	;;
266
267	let for_root_module t root_module =
268	let flags =	×
269	let project = Scope.project t.scope in
270	let dune_version = Dune_project.dune_version project in	×
271	let profile = Super_context.context t.super_context \|> Context.profile in	×
272	Ocaml_flags.default ~profile ~dune_version	×
273	in
274	{ t with
275	flags = alias_and_root_module_flags flags	×
276	; stdlib = None
277	; modules = singleton_modules root_module	×
278	}
279	;;
280
281	let for_module_generated_at_link_time cctx ~requires ~module_ =
282	let opaque =	×
283	(* Cmi's of link time generated modules are compiled with -opaque, hence
284	their implementation must also be compiled with -opaque *)
285	Ocaml.Version.supports_opaque_for_mli cctx.ocaml.version
286	in
287	let direct_requires = requires in	×
288	let hidden_requires = Resolve.Memo.return [] in
289	let modules = singleton_modules module_ in	×
290	let includes =	×
291	Includes.make
292	~project:(Scope.project cctx.scope)	×
293	~opaque
294	~direct_requires
295	~hidden_requires
296	in
297	{ cctx with
298	opaque
299	; flags = Ocaml_flags.empty
300	; requires_link = Memo.lazy_ (fun () -> requires)	×
301	; requires_compile = requires
302	; includes
303	; modules
304	}
305	;;
306
307	let for_wrapped_compat t =
308	(* See #10689 *)
309	let flags = Ocaml_flags.append_common t.flags [ "-w"; "-53" ] in	×
310	{ t with includes = Includes.empty; stdlib = None; flags }	×
311	;;
312
313	let for_plugin_executable t ~embed_in_plugin_libraries =
314	let libs = Scope.libs t.scope in	×
315	let requires_link =	×
316	Memo.lazy_ (fun () ->
317	Resolve.Memo.List.map ~f:(Lib.DB.resolve libs) embed_in_plugin_libraries)	×
318	in
319	{ t with requires_link }	×
320	;;
321
322	let without_bin_annot t = { t with bin_annot = false }	×
323
324	let entry_module_names sctx t =
325	match Lib_info.entry_modules (Lib.info t) with	×
326	\| External d -> Resolve.Memo.of_result d	×
327	\| Local ->	×
UNCOV 328	let+ modules = Dir_contents.modules_of_lib sctx t in	×
329	let modules = Option.value_exn modules in	×
330	Resolve.return (Modules.With_vlib.entry_modules modules \|> List.map ~f:Module.name)	×
331	;;
332
333	let root_module_entries t =
334	let open Action_builder.O in	×
335	let* requires = Resolve.Memo.read t.requires_compile in	×
336	let* l =	×
337	Action_builder.List.map requires ~f:(fun lib ->	×
338	Action_builder.of_memo (entry_module_names t.super_context lib) >>= Resolve.read)	×
339	in
340	Action_builder.return (List.concat l)	×
341	;;
342
343	let set_obj_dir t obj_dir = { t with obj_dir }	×
344	let set_modes t ~modes = { t with modes }	×

ocaml / dune / 28906

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous