Format

src/parser/odoc_parser.ml

···
 
 (* Given a Loc.point and the result of [parse_comment], this function returns
    a valid Lexing.position *)
-let position_of_point :
-    t ->
-    Loc.point ->
-    Lexing.position =
+let position_of_point : t -> Loc.point -> Lexing.position =
  fun v point ->
-  let { reversed_newlines; original_pos; _} = v in
+  let { reversed_newlines; original_pos; _ } = v in
   let line_in_comment = point.Loc.line - original_pos.pos_lnum + 1 in
   let rec find_pos_bol reversed_newlines_prefix =
     match reversed_newlines_prefix with
     | [] -> assert false
     | [ _ ] -> original_pos.pos_bol
     | (line_number, line_start_offset) :: prefix ->
-      if line_number > line_in_comment then find_pos_bol prefix
-      else line_start_offset + original_pos.pos_cnum
+        if line_number > line_in_comment then find_pos_bol prefix
+        else line_start_offset + original_pos.pos_cnum
   in
   let pos_bol = find_pos_bol reversed_newlines in
   let pos_lnum = point.Loc.line in
   let pos_cnum = point.column + pos_bol in
   let pos_fname = original_pos.pos_fname in
-  { Lexing.pos_bol; pos_lnum; pos_cnum; pos_fname}
+  { Lexing.pos_bol; pos_lnum; pos_cnum; pos_fname }
 
 (* The main entry point for this module *)
 let parse_comment ~location ~text =
···
 
 (* Accessor functions, as [t] is opaque *)
 let warnings t = t.warnings
-let ast t = t.ast
 
+let ast t = t.ast

src/parser/odoc_parser.mli

···
     in the 4th column (e.g. [{... pos_bol=0; pos_cnum=3 }]) *)
 
 module Ast = Ast
-
 module Loc = Loc
 
 (** Warnings produced during parsing. *)
···
       printed. *)
 end
 
-
 val warnings : t -> Warning.t list
 (** Extract any warnings from the parser result. *)
 
···
 (** Helper function to turn the internal representation of positions back into
     the usual representation in the Lexing module. Note that this relies on
     the information passed in {!parse_comment}, and hence requires the result
-    of that call in addition to the {!Loc.point} being converted. *)
+    of that call in addition to the {!Loc.point} being converted. *)

src/parser/test/test.ml

···
   let tag at : Ast.tag -> sexp = function
     | `Author s -> List [ Atom "@author"; Atom s ]
     | `Deprecated es ->
-        List (Atom "@deprecated" :: List.map (at.at (nestable_block_element at)) es)
+        List
+          (Atom "@deprecated" :: List.map (at.at (nestable_block_element at)) es)
     | `Param (s, es) ->
         List
-          ([ Atom "@param"; Atom s ] @ List.map (at.at (nestable_block_element at)) es)
+          ([ Atom "@param"; Atom s ]
+          @ List.map (at.at (nestable_block_element at)) es)
     | `Raise (s, es) ->
         List
-          ([ Atom "@raise"; Atom s ] @ List.map (at.at (nestable_block_element at)) es)
+          ([ Atom "@raise"; Atom s ]
+          @ List.map (at.at (nestable_block_element at)) es)
     | `Return es ->
         List (Atom "@return" :: List.map (at.at (nestable_block_element at)) es)
     | `See (kind, s, es) ->
···
     | `Since s -> List [ Atom "@since"; Atom s ]
     | `Before (s, es) ->
         List
-          ([ Atom "@before"; Atom s ] @ List.map (at.at (nestable_block_element at)) es)
+          ([ Atom "@before"; Atom s ]
+          @ List.map (at.at (nestable_block_element at)) es)
     | `Version s -> List [ Atom "@version"; Atom s ]
     | `Canonical p -> List [ Atom "@canonical"; at.at str p ]
     | `Inline -> Atom "@inline"
···
     | `Heading (level, label, es) ->
         let label = List [ Atom "label"; opt str label ] in
         let level = string_of_int level in
-        List [ Atom level; label; List (List.map (at.at (inline_element at)) es) ]
+        List
+          [ Atom level; label; List (List.map (at.at (inline_element at)) es) ]
     | `Tag t -> tag at t
 
-  let docs at : Ast.t -> sexp = fun f -> List (List.map (at.at (block_element at)) f)
+  let docs at : Ast.t -> sexp =
+   fun f -> List (List.map (at.at (block_element at)) f)
 end
 
 let error err = Atom (Odoc_parser.Warning.to_string err)
···
     List [ List [ Atom "output"; value ]; List [ Atom "warnings"; warnings ] ]
   in
   Sexplib0.Sexp.pp_hum formatter output;
-  Format.pp_print_flush formatter ()  
-  
-  let test ?(location = { Loc.line = 1; column = 0 }) str =
+  Format.pp_print_flush formatter ()
+
+let test ?(location = { Loc.line = 1; column = 0 }) str =
   let dummy_filename = "f.ml" in
   let location =
     {
···
        "{!indexlist}"
        (Ok []); *)
 
-       let lexing_pos_to_sexp : Lexing.position -> sexp = fun v ->
-          List [
-            List [Atom "pos_fname"; Atom v.pos_fname];
-            List [Atom "pos_bol"; Atom (string_of_int v.pos_bol)];
-            List [Atom "pos_lnum"; Atom (string_of_int v.pos_lnum)];
-            List [Atom "pos_cnum"; Atom (string_of_int v.pos_cnum)];
+    let lexing_pos_to_sexp : Lexing.position -> sexp =
+     fun v ->
+      List
+        [
+          List [ Atom "pos_fname"; Atom v.pos_fname ];
+          List [ Atom "pos_bol"; Atom (string_of_int v.pos_bol) ];
+          List [ Atom "pos_lnum"; Atom (string_of_int v.pos_lnum) ];
+          List [ Atom "pos_cnum"; Atom (string_of_int v.pos_cnum) ];
+        ]
+
+    let parser_output formatter pv =
+      let ast, warnings = Odoc_parser.(ast pv, warnings pv) in
+      let at conv v =
+        let { Loc.start; end_; _ } = Loc.location v in
+        let v' = Loc.value v |> conv in
+        let start' =
+          Odoc_parser.position_of_point pv start |> lexing_pos_to_sexp
+        in
+        let start'' = Location_to_sexp.point start in
+        let end' =
+          Odoc_parser.position_of_point pv end_ |> lexing_pos_to_sexp
+        in
+        let end'' = Location_to_sexp.point end_ in
+        List
+          [
+            List [ Atom "start"; start' ];
+            List [ Atom "start_loc"; start'' ];
+            List [ Atom "end"; end' ];
+            List [ Atom "end_loc"; end'' ];
+            List [ Atom "value"; v' ];
           ]
-     
-          let parser_output formatter pv =
-            let ast, warnings = Odoc_parser.(ast pv, warnings pv) in
-            let at conv v =
-              let { Loc.start; end_; _ } = Loc.location v in
-              let v' = Loc.value v |> conv in
-              let start' = Odoc_parser.position_of_point pv start |> lexing_pos_to_sexp in
-              let start'' = Location_to_sexp.point start in
-              let end' = Odoc_parser.position_of_point pv end_ |> lexing_pos_to_sexp in 
-              let end'' = Location_to_sexp.point end_ in
-              List [
-                List [Atom "start"; start'];
-                List [Atom "start_loc"; start''];
-                List [Atom "end"; end'];
-                List [Atom "end_loc"; end''];
-                List [Atom "value"; v']
-              ]
-            in
-            let sexp = Ast_to_sexp.(docs { at = at} ast) in
-            let warnings = List (List.map error warnings) in
-            let output =
-              List [ List [ Atom "output"; sexp ]; List [ Atom "warnings"; warnings ] ]
-            in
-            Sexplib0.Sexp.pp_hum formatter output;
-            Format.pp_print_flush formatter ()  
-            
-          
-          
-    let test ?(location = Lexing.{pos_bol=0; pos_cnum=0; pos_lnum=1; pos_fname="none"}) text =
+      in
+      let sexp = Ast_to_sexp.(docs { at } ast) in
+      let warnings = List (List.map error warnings) in
+      let output =
+        List
+          [ List [ Atom "output"; sexp ]; List [ Atom "warnings"; warnings ] ]
+      in
+      Sexplib0.Sexp.pp_hum formatter output;
+      Format.pp_print_flush formatter ()
+
+    let test
+        ?(location =
+          Lexing.{ pos_bol = 0; pos_cnum = 0; pos_lnum = 1; pos_fname = "none" })
+        text =
       let ast = Odoc_parser.parse_comment ~location ~text in
       Format.printf "%a" parser_output ast
 
     let non_offset_location =
       test "one\n two\n  three";
-      [%expect{|
+      [%expect
+        {|
         ((output
           (((start ((pos_fname none) (pos_bol 0) (pos_lnum 1) (pos_cnum 0)))
             (start_loc (1 0))
···
                 (start_loc (3 2))
                 (end ((pos_fname none) (pos_bol 9) (pos_lnum 3) (pos_cnum 16)))
                 (end_loc (3 7)) (value (word three)))))))))
-         (warnings ())) |} ]
+         (warnings ())) |}]
 
-      let offset_location =
-        test ~location:Lexing.{pos_bol=10; pos_cnum=20; pos_lnum=2; pos_fname="none"} "one\n two\n  three";
-        [%expect{|
+    let offset_location =
+      test
+        ~location:
+          Lexing.
+            { pos_bol = 10; pos_cnum = 20; pos_lnum = 2; pos_fname = "none" }
+        "one\n two\n  three";
+      [%expect
+        {|
           ((output
             (((start ((pos_fname none) (pos_bol 10) (pos_lnum 2) (pos_cnum 20)))
               (start_loc (2 10))
···
                   (start_loc (4 2))
                   (end ((pos_fname none) (pos_bol 29) (pos_lnum 4) (pos_cnum 36)))
                   (end_loc (4 7)) (value (word three)))))))))
-           (warnings ())) |} ]
-  
-    end in
-     ()
+           (warnings ())) |}]
+  end in
+  ()

src/parser/warning.ml

···
   in
   Printf.sprintf "File \"%s\", %s:\n%s" location.file location_string message
 
-let pp fmt v =
-  Format.fprintf fmt "%s" (to_string v)
+let pp fmt v = Format.fprintf fmt "%s" (to_string v)
 
 let kasprintf k fmt =
   Format.(kfprintf (fun _ -> k (flush_str_formatter ())) str_formatter fmt)