The unpac monorepo manager self-hosting as a monorepo using unpac
Remove exn bailout in completion mode (close #215)
This allows for context sensitive completion to happen
regardless of position.
+158
-137
+4
-1
vendor/opam/cmdliner/src/cmdliner.mli
+4
-1
vendor/opam/cmdliner/src/cmdliner.mli
···
705
705
Given an optional context determined from a partial command
706
706
line parse and a token to complete it returns a list of
707
707
completion directives or an error which is reported to
708
-
end-users by using a protocol {!message}. *)
708
+
end-users by using a protocol {!message}.
709
+
710
+
The context is [None] if no context was given to {!make} or if
711
+
the context failed to parse on the current command line. *)
709
712
710
713
type 'a complete =
711
714
| Complete : 'ctx Term.t option * ('ctx, 'a) func -> 'a complete (** *)
+129
-103
vendor/opam/cmdliner/src/cmdliner_cline.ml
+129
-103
vendor/opam/cmdliner/src/cmdliner_cline.ml
···
29
29
if not for_completion || not (has_complete_prefix s) then None else
30
30
Some (get_token_to_complete s)
31
31
32
-
exception Completion_requested of Cmdliner_def.Complete.t
33
-
34
-
let comp_request ?after_dashdash cline ~token kind =
35
-
let comp = Cmdliner_def.Complete.make ?after_dashdash cline ~token kind in
36
-
raise (Completion_requested comp)
37
-
38
32
(* Command lines *)
39
33
40
34
let err_multi_opt_name_def name arg_info arg_info' =
···
44
38
let arg_info_indexes arg_infos =
45
39
(* from [args] returns a trie mapping the names of optional arguments to
46
40
their arg_info, a list with all arg_info for positional arguments and
47
-
a cmdline mapping each arg_info to an empty [arg]. *)
41
+
a Cmdliner_def.Cline.t mapping each arg_info to an empty [arg]. *)
48
42
let rec loop optidx posidx cline = function
49
43
| [] -> optidx, posidx, cline
50
44
| arg_info :: l ->
···
73
67
option we could try to avoid mentioning names that have already be
74
68
mentioned and that are not repeatable. Sometimes not being able to
75
69
complete what we know exists ends up being more confusing than
76
-
enlightening so we don't do that for now. *)
70
+
enlightening so we don't do that for now.
71
+
72
+
Also the code is quite messy, perhaps we should cleanly separate
73
+
parsing for completion and parsing for evaluation. *)
77
74
78
75
let is_opt s = String.length s > 1 && s.[0] = '-'
79
76
let is_short_opt s = String.length s = 2 && s.[0] = '-'
···
111
108
| true, l -> if List.mem short_opt l then l else short_opt :: l
112
109
113
110
let parse_opt_value ~for_completion cline arg_info name value args =
114
-
(* Either we got a value glued in [value] or we need to get one in args *)
111
+
(* Either we got a value glued in [value] or we need to get one in [args]
112
+
in this case we need to take care of a possible completion token *)
115
113
match Cmdliner_def.Arg_info.opt_kind arg_info with
116
114
| Flag -> (* Flags have no values but we may get dash sharing in [value] *)
117
115
begin match value with
118
-
| None -> value, args
116
+
| None -> None, None, args
119
117
| Some v when is_short_opt name -> (* short flag dash sharing *)
120
-
None, ("-" ^ v) :: args
118
+
None, None, ("-" ^ v) :: args
121
119
| Some _ -> (* an error but this is reported during typed parsing *)
122
-
value, args
120
+
None, value, args
123
121
end
124
122
| _ ->
125
123
match value with
126
-
| Some _ -> value, args
124
+
| Some _ -> None, value, args
127
125
| None -> (* Get it from the next argument. *)
128
126
match args with
129
-
| [] -> None, args
127
+
| [] -> None, None, args
130
128
| v :: rest when for_completion && has_complete_prefix v ->
131
129
let v = get_token_to_complete v in
132
-
if is_opt v then (* not an option value *) None, args else
133
-
comp_request cline ~token:v (Opt_value arg_info)
130
+
if is_opt v then (* not an option value *) None, None, args else
131
+
let comp =
132
+
Cmdliner_def.Complete.make ~token:v (Opt_value arg_info)
133
+
in
134
+
Some comp, None, rest
134
135
| v :: rest ->
135
-
if is_opt v then None, args else Some v, rest
136
+
if is_opt v then None, None, args else None, Some v, rest
136
137
137
138
let try_complete_opt_value cline arg_info name value args =
138
139
(* At that point we found a matching option name so this should be mostly
···
143
144
| Some v when is_short_opt name ->
144
145
(* short flag dash sharing, push the completion *)
145
146
let args = (complete_prefix ^ "-" ^ v) :: args in
146
-
None, args
147
+
None, None, args
147
148
| Some v ->
148
149
(* This is actually a parse error, flags have no value. We
149
150
make it an option completion but the completions will
150
151
eventually be empty (the prefix won't match) *)
151
-
comp_request cline ~token:(name ^ v) Opt_name
152
+
Some (Cmdliner_def.Complete.make ~token:(name ^ v) Opt_name),
153
+
None, args
152
154
| None ->
153
155
(* We have in fact a fully completed flag turn it into an
154
156
option completion. *)
155
-
comp_request cline ~token:name Opt_name
157
+
Some (Cmdliner_def.Complete.make ~token:name Opt_name), None, args
156
158
end
157
159
| _ ->
158
160
begin match value with
159
-
| Some token -> comp_request cline ~token (Opt_value arg_info)
161
+
| Some token ->
162
+
Some (Cmdliner_def.Complete.make ~token (Opt_value arg_info)), None,
163
+
args
160
164
| None ->
161
165
(* We have a fully completed option name, we don't try to
162
166
lookup what happens in the next argument which should
163
167
hold the value if any, we just turn it into an option
164
168
completion. *)
165
-
comp_request cline ~token:name Opt_name
169
+
Some (Cmdliner_def.Complete.make ~token:name Opt_name), None, args
166
170
end
167
171
168
172
let parse_opt_args
169
173
~peek_opts ~legacy_prefixes ~for_completion optidx cline args
170
174
=
171
-
(* returns an updated [cl] cmdline according to the options found in [args]
175
+
(* returns an updated [cline] cmdline according to the options found in [args]
172
176
with the trie index [optidx]. Positional arguments are returned in order
173
177
in a list. *)
174
-
let rec loop errs k cline pargs = function
175
-
| [] -> List.rev errs, cline, false, List.rev pargs
176
-
| "--" :: args -> List.rev errs, cline, true, (List.rev_append pargs args)
178
+
let rec loop errs k comp cline pargs = function
179
+
| [] -> List.rev errs, comp, cline, false, List.rev pargs
180
+
| "--" :: args ->
181
+
List.rev errs, comp, cline, true, (List.rev_append pargs args)
177
182
| s :: args ->
178
183
let do_parse =
179
184
is_opt s &&
···
181
186
if not (has_complete_prefix s) then true else
182
187
is_opt_to_complete s)
183
188
in
184
-
if not do_parse then loop errs (k + 1) cline (s :: pargs) args else
189
+
if not do_parse then loop errs (k + 1) comp cline (s :: pargs) args else
185
190
let name, value, is_completion = parse_opt_arg s in
186
191
match Cmdliner_trie.find ~legacy_prefixes optidx name with
187
192
| Ok arg_info ->
188
-
let value, args =
193
+
let acomp, value, args =
189
194
if is_completion
190
195
then try_complete_opt_value cline arg_info name value args
191
196
else parse_opt_value ~for_completion cline arg_info name value args
192
197
in
198
+
let comp = match acomp with Some _ -> acomp | None -> comp in
193
199
let arg : Cmdliner_def.Cline.arg =
194
200
O ((k, name, value) ::
195
201
Cmdliner_def.Cline.get_opt_arg cline arg_info)
196
202
in
197
203
let cline = Cmdliner_def.Cline.add arg_info arg cline in
198
-
loop errs (k + 1) cline pargs args
204
+
loop errs (k + 1) comp cline pargs args
199
205
| Error `Not_found when for_completion ->
200
-
if not is_completion
201
-
(* Drop the data, if the user thought this was an opt with
202
-
an argument this may confuse positional args but there's
203
-
not much we can do. *)
204
-
then loop errs (k + 1) cline pargs args else
206
+
if not is_completion then
207
+
(* Drop the data, if the user thought this was an opt with
208
+
an argument this may confuse positional args but there's
209
+
not much we can do. *)
210
+
loop errs (k + 1) comp cline pargs args
211
+
else
205
212
let token = name ^ Option.value ~default:"" value in
206
-
comp_request cline ~token Opt_name
213
+
let comp = Some (Cmdliner_def.Complete.make ~token Opt_name) in
214
+
loop errs (k + 1) comp cline pargs args
207
215
| Error `Not_found when peek_opts ->
208
-
loop errs (k + 1) cline pargs args
216
+
loop errs (k + 1) comp cline pargs args
209
217
| Error `Not_found ->
210
218
let hints = hint_matching_opt optidx s in
211
219
let err = Cmdliner_base.err_unknown ~kind:"option" ~hints name in
212
-
loop (err :: errs) (k + 1) cline pargs args
220
+
loop (err :: errs) (k + 1) comp cline pargs args
213
221
| Error `Ambiguous (* Only on legacy prefixes *) ->
214
222
let ambs = Cmdliner_trie.ambiguities optidx name in
215
223
let ambs = List.sort compare ambs in
216
224
let err = Cmdliner_base.err_ambiguous ~kind:"option" name ~ambs in
217
-
loop (err :: errs) (k + 1) cline pargs args
225
+
loop (err :: errs) (k + 1) comp cline pargs args
218
226
in
219
-
let errs, cline, has_dashdash, pargs = loop [] 0 cline [] args in
220
-
if errs = [] then Ok (cline, has_dashdash, pargs) else
221
-
let err = String.concat "\n" errs in
222
-
Error (err, cline, has_dashdash, pargs)
227
+
let errs, comp, cline, has_dashdash, pargs = loop [] 0 None cline [] args in
228
+
if errs = [] then Ok (comp, cline, has_dashdash, pargs) else
229
+
match comp with
230
+
| Some _ -> Ok (comp, cline, has_dashdash, pargs)
231
+
| None ->
232
+
let err = String.concat "\n" errs in
233
+
Error (err, cline, has_dashdash, pargs)
234
+
235
+
(* Positional argument parsing *)
223
236
224
237
let take_range ~for_completion start stop l =
225
-
let rec loop i acc = function
226
-
| [] -> `Range (List.rev acc)
238
+
let rec loop i comp acc = function
239
+
| [] -> comp, (List.rev acc)
227
240
| v :: vs ->
228
-
if i < start then loop (i + 1) acc vs else
241
+
if i < start then loop (i + 1) comp acc vs else
229
242
if i <= stop then match maybe_token_to_complete ~for_completion v with
230
-
| Some prefix -> `Complete prefix
231
-
| None -> loop (i + 1) (v :: acc) vs
232
-
else `Range (List.rev acc)
243
+
| Some _ as comp -> loop (i + 1) comp (v :: acc) vs
244
+
| None -> loop (i + 1) comp (v :: acc) vs
245
+
else comp, List.rev acc
233
246
in
234
-
loop 0 [] l
247
+
loop 0 None [] l
235
248
236
-
let process_pos_args ~for_completion posidx cline ~has_dashdash pargs =
237
-
(* returns an updated [cl] cmdline in which each positional arg mentioned
238
-
in the list index posidx, is given a value according the list
249
+
let parse_pos_args ~for_completion posidx comp cline ~has_dashdash pargs =
250
+
(* returns an updated [cline] cmdline in which each positional arg mentioned
251
+
in the list index [posidx], is given a value according the list
239
252
of positional arguments values [pargs]. *)
240
253
if pargs = [] then
241
254
let misses = List.filter Cmdliner_def.Arg_info.is_req posidx in
242
-
if misses = [] then Ok cline else
243
-
Error (Cmdliner_msg.err_pos_misses misses, cline)
255
+
if misses = [] then Ok (comp, cline) else
256
+
match comp with
257
+
| Some _ -> Ok (comp, cline)
258
+
| None -> Error (Cmdliner_msg.err_pos_misses misses, cline)
244
259
else
245
260
let last = List.length pargs - 1 in
246
261
let pos rev k = if rev then last - k else k in
247
-
let rec loop misses cline max_spec = function
248
-
| [] -> misses, cline, max_spec
249
-
| a :: al ->
250
-
let apos = Cmdliner_def.Arg_info.pos_kind a in
262
+
let rec loop misses comp cline max_spec = function
263
+
| [] -> misses, comp, cline, max_spec
264
+
| arg_info :: al ->
265
+
let apos = Cmdliner_def.Arg_info.pos_kind arg_info in
251
266
let rev = Cmdliner_def.Arg_info.pos_rev apos in
252
267
let start = pos rev (Cmdliner_def.Arg_info.pos_start apos) in
253
268
let stop = match Cmdliner_def.Arg_info.pos_len apos with
···
255
270
| Some n -> pos rev (Cmdliner_def.Arg_info.pos_start apos + n - 1)
256
271
in
257
272
let start, stop = if rev then stop, start else start, stop in
258
-
let args = match take_range ~for_completion start stop pargs with
259
-
| `Range args -> args
260
-
| `Complete token ->
261
-
let kind = Cmdliner_def.Complete.Opt_name_or_pos_value a in
262
-
comp_request ~after_dashdash:has_dashdash cline ~token kind
273
+
let comp, args = match take_range ~for_completion start stop pargs with
274
+
| None, args -> comp, args
275
+
| Some token, args ->
276
+
let comp =
277
+
Cmdliner_def.Complete.make ~after_dashdash:has_dashdash ~token
278
+
(Opt_name_or_pos_value arg_info)
279
+
in
280
+
Some comp, args
263
281
in
264
282
let max_spec = max stop max_spec in
265
-
let cline = Cmdliner_def.Cline.add a (P args) cline in
266
-
let misses = match Cmdliner_def.Arg_info.is_req a && args = [] with
267
-
| true -> a :: misses
283
+
let cline = Cmdliner_def.Cline.add arg_info (P args) cline in
284
+
let misses = match Cmdliner_def.Arg_info.is_req arg_info && args = [] with
285
+
| true -> arg_info :: misses
268
286
| false -> misses
269
287
in
270
-
loop misses cline max_spec al
288
+
loop misses comp cline max_spec al
271
289
in
272
-
let misses, cline, max_spec = loop [] cline (-1) posidx in
273
-
let consume_excess () =
274
-
match take_range ~for_completion (max_spec + 1) last pargs with
275
-
| `Range args -> args
276
-
| `Complete token ->
277
-
comp_request ~after_dashdash:has_dashdash cline ~token Opt_name
278
-
in
290
+
let misses, comp, cline, max_spec = loop [] comp cline (-1) posidx in
279
291
if misses <> [] then begin
280
-
let _ : string list = consume_excess () in
292
+
if Option.is_some comp then Ok (comp, cline) else
281
293
Error (Cmdliner_msg.err_pos_misses misses, cline)
282
294
end else
283
-
if last <= max_spec then Ok cline else
284
-
Error (Cmdliner_msg.err_pos_excess (consume_excess ()), cline)
295
+
if last <= max_spec then Ok (comp, cline) else
296
+
if Option.is_some comp then Ok (comp, cline) else
297
+
let comp, excess = take_range ~for_completion (max_spec + 1) last pargs in
298
+
match comp with
299
+
| None -> Error (Cmdliner_msg.err_pos_excess excess, cline)
300
+
| Some token ->
301
+
let comp =
302
+
Cmdliner_def.Complete.make ~after_dashdash:has_dashdash ~token Opt_name
303
+
in
304
+
Ok (Some comp, cline)
285
305
286
306
let create ?(peek_opts = false) ~legacy_prefixes ~for_completion al args =
287
-
try
288
-
let optidx, posidx, cline = arg_info_indexes al in
289
-
let r =
290
-
parse_opt_args
291
-
~for_completion ~peek_opts ~legacy_prefixes optidx cline args
292
-
in
293
-
match r with
294
-
| Ok (cline, has_dashdash, _) when peek_opts -> `Ok cline
295
-
| Ok (cline, has_dashdash, pargs) ->
296
-
let r =
297
-
process_pos_args ~for_completion posidx cline ~has_dashdash pargs
298
-
in
299
-
if not for_completion
300
-
then (match r with Ok v -> `Ok v | Error v -> `Error v)
301
-
else begin
302
-
(* Normally [Completion_requested] should have been raised. This
307
+
let optidx, posidx, cline = arg_info_indexes al in
308
+
match
309
+
parse_opt_args ~for_completion ~peek_opts ~legacy_prefixes optidx cline args
310
+
with
311
+
| Ok (comp, cline, _has_dashdash, _pargs) when peek_opts ->
312
+
begin match comp with
313
+
| None -> `Ok cline
314
+
| Some comp -> `Complete (comp, cline)
315
+
end
316
+
| Ok (comp, cline, has_dashdash, pargs) ->
317
+
begin match
318
+
parse_pos_args ~for_completion posidx comp cline ~has_dashdash pargs
319
+
with
320
+
| Ok (None, _) | Error _ when for_completion ->
321
+
(* Normally we should have found a completion token This
303
322
may fail to happen if pos args are ill defined: we may miss the
304
-
completion token. Just make sure we do a completion. N.B. *)
305
-
match List.find_opt has_complete_prefix pargs with
323
+
completion token. Just make sure we do a completion. *)
324
+
begin match List.find_opt has_complete_prefix pargs with
306
325
| None -> assert false
307
326
| Some arg ->
308
327
match maybe_token_to_complete ~for_completion:true arg with
309
328
| None -> assert false
310
329
| Some token ->
311
-
comp_request
312
-
~after_dashdash:has_dashdash cline ~token Opt_name
313
-
end
330
+
let comp =
331
+
Cmdliner_def.Complete.make
332
+
~after_dashdash:has_dashdash ~token Opt_name
333
+
in
334
+
`Complete (comp, cline)
335
+
end
336
+
| Ok (None, cline) -> `Ok cline
337
+
| Ok (Some comp, cline) -> `Complete (comp, cline)
338
+
| Error v -> `Error v
339
+
end
314
340
| Error (errs, cline, has_dashdash, pargs) ->
315
-
let _ : _ result =
316
-
process_pos_args ~for_completion posidx cline ~has_dashdash pargs
317
-
in
318
-
`Error (errs, cline)
319
-
with Completion_requested c -> `Complete c
341
+
match
342
+
parse_pos_args ~for_completion posidx None cline ~has_dashdash pargs
343
+
with
344
+
| Ok (Some comp, cline) -> `Complete (comp, cline)
345
+
| _ -> `Error (errs, cline)
+1
-1
vendor/opam/cmdliner/src/cmdliner_cline.mli
+1
-1
vendor/opam/cmdliner/src/cmdliner_cline.mli
···
15
15
?peek_opts:bool -> legacy_prefixes:bool -> for_completion:bool ->
16
16
Cmdliner_def.Arg_info.Set.t -> string list ->
17
17
[ `Ok of Cmdliner_def.Cline.t
18
-
| `Complete of Cmdliner_def.Complete.t
18
+
| `Complete of Cmdliner_def.Complete.t * Cmdliner_def.Cline.t
19
19
| `Error of string * Cmdliner_def.Cline.t ]
+4
-5
vendor/opam/cmdliner/src/cmdliner_completion.ml
+4
-5
vendor/opam/cmdliner/src/cmdliner_completion.ml
···
68
68
let options = Cmdliner_def.Arg_info.Set.elements set in
69
69
Group ("Options", List.concat (List.map maybe_items options)) :: directives
70
70
71
-
let add_argument_value_directives directives eval arg_info comp =
71
+
let add_argument_value_directives directives eval arg_info comp cline =
72
72
let (Conv conv) =
73
73
let arg_infos = Cmdliner_def.Cmd_info.args (Cmdliner_def.Eval.cmd eval) in
74
74
Option.get (Cmdliner_def.Arg_info.Set.find_opt arg_info arg_infos)
···
80
80
let ctx = match ctx with
81
81
| None -> None
82
82
| Some ctx ->
83
-
let cline = Cmdliner_def.Complete.cline comp in
84
83
match (Cmdliner_term.parser ctx) eval cline with
85
84
| Ok ctx -> Some ctx
86
85
| Error _ -> None
···
122
121
in
123
122
loop [] [] ~files:false ~dirs:false ~restart:false ~raw:None ds
124
123
125
-
let output ~out_ppf ~err_ppf eval comp =
124
+
let output ~out_ppf ~err_ppf eval comp cline =
126
125
let subst = Cmdliner_def.Eval.doclang_subst eval in
127
126
let dirs = add_subcommands_group ~err_ppf ~subst eval comp [] in
128
127
let res = match Cmdliner_def.Complete.kind comp with
129
128
| Opt_value arg_info ->
130
-
add_argument_value_directives dirs eval arg_info comp
129
+
add_argument_value_directives dirs eval arg_info comp cline
131
130
| Opt_name_or_pos_value arg_info ->
132
131
let dirs = add_options_group ~err_ppf ~subst eval comp dirs in
133
-
add_argument_value_directives dirs eval arg_info comp
132
+
add_argument_value_directives dirs eval arg_info comp cline
134
133
| Opt_name ->
135
134
`Directives (add_options_group ~err_ppf ~subst eval comp dirs)
136
135
in
+2
-4
vendor/opam/cmdliner/src/cmdliner_completion.mli
+2
-4
vendor/opam/cmdliner/src/cmdliner_completion.mli
···
4
4
---------------------------------------------------------------------------*)
5
5
6
6
val output :
7
-
out_ppf:Format.formatter ->
8
-
err_ppf:Format.formatter ->
9
-
Cmdliner_def.Eval.t ->
10
-
Cmdliner_def.Complete.t ->
7
+
out_ppf:Format.formatter -> err_ppf:Format.formatter ->
8
+
Cmdliner_def.Eval.t -> Cmdliner_def.Complete.t -> Cmdliner_def.Cline.t ->
11
9
unit
+3
-5
vendor/opam/cmdliner/src/cmdliner_def.ml
+3
-5
vendor/opam/cmdliner/src/cmdliner_def.ml
···
544
544
| Opt_name
545
545
546
546
type t =
547
-
{ cline : Cline.t;
548
-
token : string;
547
+
{ token : string;
549
548
after_dashdash : bool;
550
549
subcmds : bool; (* Note this is adjusted in Cmdliner_eval *)
551
550
kind : kind }
552
551
553
-
let make ?(after_dashdash = false) ?(subcmds = false) cline ~token kind =
554
-
{ cline; token; after_dashdash; subcmds; kind; }
552
+
let make ?(after_dashdash = false) ?(subcmds = false) ~token kind =
553
+
{ token; after_dashdash; subcmds; kind; }
555
554
556
-
let cline c = c.cline
557
555
let token c = c.token
558
556
let after_dashdash c = c.after_dashdash
559
557
let subcmds c = c.subcmds
+1
-5
vendor/opam/cmdliner/src/cmdliner_def.mli
+1
-5
vendor/opam/cmdliner/src/cmdliner_def.mli
···
295
295
| Opt_name
296
296
297
297
type t
298
-
val make :
299
-
?after_dashdash:bool -> ?subcmds:bool -> Cline.t -> token:string -> kind ->
300
-
t
301
-
302
-
val cline : t -> Cline.t
298
+
val make : ?after_dashdash:bool -> ?subcmds:bool -> token:string -> kind -> t
303
299
val token : t -> string
304
300
val after_dashdash : t -> bool
305
301
val subcmds : t -> bool
+8
-7
vendor/opam/cmdliner/src/cmdliner_eval.ml
+8
-7
vendor/opam/cmdliner/src/cmdliner_eval.ml
···
15
15
| `Std_version ]
16
16
17
17
type 'a eval_result =
18
-
('a, [ eval_result_error | `Complete of Cmdliner_def.Complete.t]) result
18
+
('a, [ eval_result_error
19
+
| `Complete of Cmdliner_def.Complete.t * Cmdliner_def.Cline.t]) result
19
20
20
21
let err_help s = "Term error, help requested for unknown command " ^ s
21
22
let err_argv = "argv array must have at least one element"
···
96
97
Cmdliner_msg.pp_version help_ppf eval; Ok `Version
97
98
| `Parse err ->
98
99
Cmdliner_msg.pp_usage_and_err err_ppf eval ~err; Error `Parse
99
-
| `Complete comp ->
100
-
Cmdliner_completion.output ~out_ppf:help_ppf ~err_ppf eval comp;
100
+
| `Complete (comp, cline) ->
101
+
Cmdliner_completion.output ~out_ppf:help_ppf ~err_ppf eval comp cline;
101
102
Ok `Help
102
103
| `Help (fmt, cmd_name) ->
103
104
do_help ~env help_ppf err_ppf eval fmt cmd_name; Ok `Help
···
221
222
| Error (`Parse (try_stdopts, msg)) ->
222
223
(* Command lookup error, we may still prioritize stdargs *)
223
224
begin match cline with
224
-
| `Complete comp -> Error (`Complete comp)
225
+
| `Complete c -> Error (`Complete c)
225
226
| `Error (_, cl) | `Ok cl ->
226
227
let stdopts =
227
228
if try_stdopts
···
234
235
end
235
236
| Error `Complete ->
236
237
begin match cline with
237
-
| `Complete comp ->
238
+
| `Complete (comp, cline) ->
238
239
let comp = Cmdliner_def.Complete.add_subcmds comp in
239
-
Error (`Complete comp)
240
+
Error (`Complete (comp, cline))
240
241
| `Ok _ | `Error _ -> assert false
241
242
end
242
243
| Ok parser ->
243
244
begin match cline with
244
-
| `Complete comp -> Error (`Complete comp)
245
+
| `Complete c -> Error (`Complete c)
245
246
| `Error (e, cl) ->
246
247
begin match try_eval_stdopts ~catch eval cl help version with
247
248
| Some e -> e
+6
-6
vendor/opam/cmdliner/test/test_completion.ml
+6
-6
vendor/opam/cmdliner/test/test_completion.ml
···
501
501
group\n\
502
502
Values\n\
503
503
item\n\
504
-
no-context\n\
504
+
true\n\
505
505
\n\
506
506
item-end\n";
507
507
in
···
581
581
group\n\
582
582
Values\n\
583
583
item\n\
584
-
no-context\n\
584
+
ctx-parse-error\n\
585
585
\n\
586
586
item-end\n";
587
587
complete ["true"; "--dep"; "--__complete="] @@ __POS_OF__
···
589
589
group\n\
590
590
Values\n\
591
591
item\n\
592
-
no-context\n\
592
+
true\n\
593
593
\n\
594
594
item-end\n";
595
595
complete ["--dep"; "--__complete="; "true"] @@ __POS_OF__
···
597
597
group\n\
598
598
Values\n\
599
599
item\n\
600
-
no-context\n\
600
+
true\n\
601
601
\n\
602
602
item-end\n";
603
603
in
···
614
614
group\n\
615
615
Values\n\
616
616
item\n\
617
-
no-context\n\
617
+
ctx-parse-error\n\
618
618
\n\
619
619
item-end\n";
620
620
complete ["true"; "--__complete=a"] @@ __POS_OF__
···
622
622
group\n\
623
623
Values\n\
624
624
item\n\
625
-
no-context\n\
625
+
true\n\
626
626
\n\
627
627
item-end\n";
628
628
in