Kakadu / zanuda / 18

Committed 17 Sep 2025 05:06PM UTC coverage: 85.847% (-1.5%) from 87.346%

Build # 18

Build Type

push

github

Committed by

Kakadu

Commit Message

Repair coverage testing

Signed-off-by: Kakadu <Kakadu@pm.me>

Run Details

2032 of 2367 relevant lines covered (85.85%)

477.23 hits per line

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

95.83

/src/typed/Propose_function.ml

[@@@ocaml.text "/*"]

(** Copyright 2021-2025, Kakadu. *)

(** SPDX-License-Identifier: LGPL-3.0-or-later *)

[@@@ocaml.text "/*"]

open Base
open Zanuda_core
open Zanuda_core.Utils

type input = Tast_iterator.iterator

let lint_id = "propose_function"
let lint_source = LINT.FPCourse
let group = LINT.Style
let level = LINT.Warn

let documentation =
  {|
### What it does
Proposes to rewrite 'fun x -> match x with ...' to `function`.

### Why?
The `function` keyword allows more shorter syntax for pattern matching on last argument.
The lint should not be raised if scrutinee variable is used later in the code.

The following code is recommended:

```ocaml
  let f = function
    | [] -> ...
    | (x::xs) as arg -> ... x ... xs ... arg
```

And this piece of code is discouraged:

```ocaml
  let f arg  = match arg with
    | [] -> ...
    | (x::xs) -> ... x ... xs ... arg
```
|}
  |> Stdlib.String.trim
;;

let describe_as_json () =
  describe_as_clippy_json lint_id ~group ~level ~docs:documentation
;;

let msg ppf () = Format.fprintf ppf "Using `function` is recommended%!"

let report filename ~loc =
  let module M = struct
    let txt ppf () = Utils.Report.txt ~filename ~loc ppf msg ()

    let rdjsonl ppf () =
      RDJsonl.pp
        ppf
        ~filename:(Config.recover_filepath loc.loc_start.pos_fname)
        ~line:loc.loc_start.pos_lnum
        msg
        ()
    ;;
  end
  in
  (module M : LINT.REPORTER)
;;

let no_ident ident c = Utils.no_ident ident (fun it -> it.case it c)

let pat () =
  let open Tast_pattern in
  texp_function_body
    ((nolabel ** __) ^:: nil)
    (as__ (texp_match (texp_ident_loc __) drop __))
;;

let run _ fallback =
  let open Tast_iterator in
  { fallback with
    expr =
      (fun self expr ->
        let open Typedtree in
        let loc = expr.exp_loc in
        Tast_pattern.parse
          (pat ())
          loc
          ~on_error:(fun _desc () -> ())
          expr
          (fun (scru_ident, scru_loc) match_expr _scru_loc scru_pat cases () ->
            match scru_pat with
            | Path.Pident id ->
              if String.equal (Ident.name scru_ident) (Ident.name id)
                 && List.for_all cases ~f:(no_ident scru_ident)
              then (
                Collected_lints.add
                  ~loc
                  (report loc.Location.loc_start.Lexing.pos_fname ~loc);
                Refactoring.Propose_function.register_fix
                  ~loc:match_expr.exp_loc
                  scru_loc
                  cases)
            | _ -> ())
          ();
        fallback.expr self expr)
  }
;;

1	[@@@ocaml.text "/*"]
2
3	(** Copyright 2021-2025, Kakadu. *)
4
5	(** SPDX-License-Identifier: LGPL-3.0-or-later *)
6
7	[@@@ocaml.text "/*"]
8
9	open Base
10	open Zanuda_core
11	open Zanuda_core.Utils
12
13	type input = Tast_iterator.iterator
14
15	let lint_id = "propose_function"
16	let lint_source = LINT.FPCourse
17	let group = LINT.Style
18	let level = LINT.Warn
19
20	let documentation =
21	{\|
22	### What it does
23	Proposes to rewrite 'fun x -> match x with ...' to `function`.
24
25	### Why?
26	The `function` keyword allows more shorter syntax for pattern matching on last argument.
27	The lint should not be raised if scrutinee variable is used later in the code.
28
29	The following code is recommended:
30
31	```ocaml
32	let f = function
33	\| [] -> ...
34	\| (x::xs) as arg -> ... x ... xs ... arg
35	```
36
37	And this piece of code is discouraged:
38
39	```ocaml
40	let f arg = match arg with
41	\| [] -> ...
42	\| (x::xs) -> ... x ... xs ... arg
43	```
44	\|}
45	\|> Stdlib.String.trim	48✔
46	;;
47
48	let describe_as_json () =
49	describe_as_clippy_json lint_id ~group ~level ~docs:documentation	1✔
50	;;
51
52	let msg ppf () = Format.fprintf ppf "Using `function` is recommended%!"	12✔
53
54	let report filename ~loc =
55	let module M = struct	9✔
56	let txt ppf () = Utils.Report.txt ~filename ~loc ppf msg ()	9✔
57
58	let rdjsonl ppf () =
59	RDJsonl.pp	3✔
60	ppf
61	~filename:(Config.recover_filepath loc.loc_start.pos_fname)	3✔
62	~line:loc.loc_start.pos_lnum
63	msg
64	()
65	;;
66	end
67	in
68	(module M : LINT.REPORTER)
69	;;
70
71	let no_ident ident c = Utils.no_ident ident (fun it -> it.case it c)	21✔
72
73	let pat () =
74	let open Tast_pattern in	1,320✔
75	texp_function_body
76	((nolabel ** __) ^:: nil)	1,320✔
77	(as__ (texp_match (texp_ident_loc __) drop __))	1,320✔
78	;;
79
80	let run _ fallback =
81	let open Tast_iterator in	53✔
82	{ fallback with
83	expr =
84	(fun self expr ->
85	let open Typedtree in	1,320✔
86	let loc = expr.exp_loc in
87	Tast_pattern.parse
88	(pat ())	1,320✔
89	loc
90	~on_error:(fun _desc () -> ())	1,309✔
91	expr
92	(fun (scru_ident, scru_loc) match_expr _scru_loc scru_pat cases () ->
93	match scru_pat with	11✔
94	\| Path.Pident id ->	11✔
95	if String.equal (Ident.name scru_ident) (Ident.name id)	11✔
96	&& List.for_all cases ~f:(no_ident scru_ident)	10✔
97	then (	9✔
98	Collected_lints.add
99	~loc
100	(report loc.Location.loc_start.Lexing.pos_fname ~loc);	9✔
101	Refactoring.Propose_function.register_fix	9✔
102	~loc:match_expr.exp_loc
103	scru_loc
104	cases)
105	\| _ -> ())	×
106	();
107	fallback.expr self expr)	1,320✔
108	}
109	;;

Kakadu / zanuda / 18

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