Use compare instead of introducing equal

src/analysis/destruct.ml

@@ -489,7 +489,7 @@ let find_field_name_for_punning_field patt = function
     List.find_opt ~f:(fun (_, _, opat) ->
         let ppat_loc = patt.Typedtree.pat_loc
         and opat_loc = opat.Typedtree.pat_loc in
-        Location_aux.equal ppat_loc opat_loc
+        Int.equal (Location_aux.compare ppat_loc opat_loc) 0
       ) fields |> Option.map ~f:(fun (_, label, _) -> label)
   | _ -> None
 

src/ocaml/parsing/location_aux.ml

@@ -38,12 +38,6 @@ let compare (l1: t) (l2: t) =
   | 0 -> Lexing.compare_pos l1.loc_end l2.loc_end
   | _ -> assert false
 
-let equal
-  { loc_start = start_a; loc_end = end_a; loc_ghost = ghost_a }
-  { loc_start = start_b; loc_end = end_b; loc_ghost = ghost_b } =
-    Lexing.equal_position start_a start_b && Lexing.equal_position end_a end_b &&
-      Bool.equal ghost_a ghost_b
-
 let compare_pos pos loc =
   if Lexing.compare_pos pos loc.Location.loc_start < 0 then
     -1

src/ocaml/parsing/location_aux.mli

@@ -35,9 +35,6 @@ val compare : t -> t -> int
 
 val compare_pos: Lexing.position -> t -> int
 
-(** [equal l1 l2] equality between location *)
-val equal : t -> t -> bool
-
 (** Return the smallest location covered by both arguments,
     ghost if both are ghosts *)
 val union : t -> t -> t

src/utils/std.ml

@@ -549,13 +549,6 @@ module Lexing = struct
   include (Lexing : module type of struct include Lexing end
            with type position := position)
 
-
-  let equal_position
-    { pos_fname =  fname_a; pos_lnum = lnum_a; pos_bol = bol_a; pos_cnum = cnum_a }
-    { pos_fname =  fname_b; pos_lnum = lnum_b; pos_bol = bol_b; pos_cnum = cnum_b } =
-        String.equal fname_a fname_b && Int.equal lnum_a lnum_b &&
-        Int.equal bol_a bol_b && Int.equal cnum_a cnum_b
-
   let move buf p =
     buf.lex_abs_pos <- (p.pos_cnum - buf.lex_curr_pos);
     buf.lex_curr_p <- p