odoc: Don't fail for removed whitespaces in code blocks

During normalisation, allow whitespaces to disappear from code blocks.
This happens when code if formatted.

Author: Julow

lib/Docstring.ml

@@ -79,11 +79,14 @@ let list f fmt l =
   let pp_sep _ () = () in
   Format.pp_print_list ~pp_sep f fmt l
 
-let str fmt s =
-  let pp_sep fmt () = Format.pp_print_string fmt " " in
+let str_with_sep ~pp_sep fmt s =
   Format.pp_print_list ~pp_sep Astring.String.Sub.pp fmt
     (normalize_text_subs s)
 
+let str fmt s =
+  let pp_sep fmt () = Format.pp_print_string fmt " " in
+  str_with_sep ~pp_sep fmt s
+
 let ign_loc f fmt with_loc = f fmt with_loc.Odoc_parser.Loc.value
 
 let fpf = Format.fprintf
@@ -154,7 +157,8 @@ let rec odoc_nestable_block_element c fmt : Ast.nestable_block_element -> _ =
           m.tags
       in
       let fmt_content =
-        ign_loc (fun fmt s -> str fmt (c.normalize_code s))
+        let pp_sep _ () = () in
+        ign_loc (fun fmt s -> str_with_sep ~pp_sep fmt (c.normalize_code s))
       in
       let fmt_output =
         option (list (ign_loc (odoc_nestable_block_element c)))

test/passing/refs.default/repl.mli.ref

@@ -3,105 +3,104 @@ type t = k
 
     Block delimiters should be on their own line:
     {[
-      let x = 1
+    let x = 1
     ]}
 
     As of odoc 2.1, a block can carry metadata:
     {@ocaml[
-      let x = 2
+    let x = 2
     ]}
 
     An OCaml block that should break:
     {[
-      let x = 2 in
-      x + x
+    let x = 2 in
+    x + x
     ]}
 
     A toplevel phrase with no output:
     {[
-      # let x = 2 and y = 3 in
-        x + y
-        ;;
+    # let x = 2 and y = 3 in
+      x + y
+      ;;
     ]}
 
     A toplevel phrase with output:
     {@ocaml[
-      # let x = 2;;
-      val x : int = 2
+    # let x = 2;;
+    val x : int = 2
     ]}
 
     Many toplevel phrases without output:
     {[
-      # let x = 2;;
-      # x + 2;;
-      # let x = 2 and y = 3 in
-        x + y
-        ;;
+    # let x = 2;;
+    # x + 2;;
+    # let x = 2 and y = 3 in
+      x + y
+      ;;
     ]}
 
     Many toplevel phrases with output:
     {[
-      # let x = 2;;
-      val x : int = 2
-      # x + 2;;
-      - : int = 4
-      # let x = 2 and y = 3 in
-        x + y
-        ;;
+    # let x = 2;;
+    val x : int = 2
+    # x + 2;;
+    - : int = 4
+    # let x = 2 and y = 3 in
+      x + y
+      ;;
     ]}
 
     Output are printed after a newline:
     {[
-      # let x = 2;; val x : int = 2
-      # let x = 3;;
-      # let x = 4;; val x : int = 4
+    # let x = 2;; val x : int = 2
+    # let x = 3;;
+    # let x = 4;; val x : int = 4
     ]}
 
     Excessive linebreaks are removed:
     {[
-      # let x = 2 in
-        x + 1
-        ;;
+    
+      # let x = 2 in x+1;;
+
       output
-      # let y = 3 in
-        y + 1
-        ;;
+
+      # let y = 3 in y+1;;
     ]}
 
     Linebreak after `#`:
     {[
-      # let x = 2 in
-        x + 1
-        ;;
+    # let x = 2 in
+      x + 1
+      ;;
     ]} *)
 
 (** INVALID BLOCKS: The formatting of invalid blocks is preserved.
 
     Invalid toplevel phrase/ocaml block:
     {[
-      - : int =
-       4
+    - : int =
+     4
     ]}
 
     Output before a toplevel phrase:
     {[
-      - : int = 4
-      # 2+2;;
+    - : int = 4
+    # 2+2;;
     ]}
 
     No `;;` at the end of the phrase, no output:
     {[
-      # let x = 2 in x+1
+    # let x = 2 in x+1
     ]}
 
     No `;;` at the end of the phrase, with output:
     {[
-      # let x = 2 in x+1
-      some output
+    # let x = 2 in x+1
+    some output
     ]}
 
     Multiple phrases without `;;` at the end:
     {[
-      # let x = 2 in x+1
-      # let x = 4 in x+1
+    # let x = 2 in x+1
+    # let x = 4 in x+1
     ]} *)