res_printer.ml

module Doc = Res_doc
module Comment_table = Res_comments_table
module Comment = Res_comment
module Token = Res_token
module Parens = Res_parens
module Parsetree_viewer = Res_parsetree_viewer

let default_print_width = 100

type callback_style =
  (* regular arrow function, example: `let f = x => x + 1` *)
  | NoCallback
  (* `Thing.map(foo, (arg1, arg2) => MyModuleBlah.toList(argument))` *)
  | FitsOnOneLine
  (* Thing.map(longArgumet, veryLooooongArgument, (arg1, arg2) =>
   *   MyModuleBlah.toList(argument)
   * )
   *)
  | ArgumentsFitOnOneLine

let add_parens doc =
  Doc.group
    (Doc.concat
       [
         Doc.lparen;
         Doc.indent (Doc.concat [Doc.soft_line; doc]);
         Doc.soft_line;
         Doc.rparen;
       ])

(* Keep the delimiters on the expression's first and last lines. The parser
   excludes parentheses from expression locations, so breaking just inside
   them would create blank lines or move comments on the next formatting pass. *)
let add_statement_parens doc =
  Doc.group (Doc.concat [Doc.lparen; doc; Doc.rparen])

(* Module expressions hug their parens, so a multi-line structure or
   signature keeps its braces next to them: [(M: {...})] *)
let add_mod_expr_parens doc = Doc.concat [Doc.lparen; doc; Doc.rparen]

(* Whether a module expression's printed form starts with a doc comment:
   doc comments print before other attributes, and an unparenthesized
   constraint or application starts with its leftmost module *)
let rec mod_expr_starts_with_doc_comment (mod_expr : Parsetree.module_expr) =
  match mod_expr.pmod_desc with
  (* A functor's attributes print on its first parameter, an await's after
     [await] *)
  | Pmod_functor _ | Pmod_await _ -> false
  | _
    when List.exists Parsetree_viewer.is_doc_comment_attribute
           mod_expr.pmod_attributes ->
    true
  | _ when Parsetree_viewer.mod_expr_has_attributes mod_expr -> false
  | Pmod_constraint (inner, _) -> mod_expr_starts_with_doc_comment inner
  | Pmod_apply _ ->
    let _, call_expr = Parsetree_viewer.mod_expr_apply mod_expr in
    (not (Parens.mod_apply_callee call_expr))
    && mod_expr_starts_with_doc_comment call_expr
  | _ -> false

let add_braces ?(force_break = false) doc =
  Doc.breakable_group ~force_break
    (Doc.concat
       [
         Doc.lbrace;
         Doc.indent (Doc.concat [Doc.soft_line; doc]);
         Doc.soft_line;
         Doc.rbrace;
       ])

let add_async doc = Doc.concat [Doc.text "async "; doc]

let has_inline_type_definitions type_declarations =
  type_declarations
  |> List.find_opt (fun (td : Parsetree.type_declaration) ->
      td.ptype_origin = Inline_record_definition)
  |> Option.is_some

let get_first_leading_comment tbl loc =
  match Hashtbl.find tbl.Comment_table.leading loc with
  | comment :: _ -> Some comment
  | [] -> None
  | exception Not_found -> None

(* Checks if `loc` has a leading line comment, i.e. `// comment above`*)
let has_leading_line_comment tbl loc =
  match get_first_leading_comment tbl loc with
  | Some comment -> Comment.is_single_line_comment comment
  | None -> false

let has_trailing_single_line_comment tbl loc =
  match Hashtbl.find_opt tbl.Comment_table.trailing loc with
  | Some (comment :: _) -> Comment.is_single_line_comment comment
  | _ -> false

let has_any_trailing_line_comment tbl loc =
  match Hashtbl.find_opt tbl.Comment_table.trailing loc with
  | Some comments -> List.exists Comment.is_single_line_comment comments
  | None -> false

let has_comment_below tbl loc =
  match Hashtbl.find tbl.Comment_table.trailing loc with
  | comment :: _ ->
    let comment_loc = Comment.loc comment in
    comment_loc.Location.loc_start.pos_lnum > loc.Location.loc_end.pos_lnum
  | [] -> false
  | exception Not_found -> false

let has_comments_inside tbl loc =
  match Hashtbl.find_opt tbl.Comment_table.inside loc with
  | None -> false
  | _ -> true

let has_trailing_comments tbl loc =
  match Hashtbl.find_opt tbl.Comment_table.trailing loc with
  | None -> false
  | _ -> true

let has_leading_comments tbl loc =
  match Hashtbl.find_opt tbl.Comment_table.leading loc with
  | None -> false
  | _ -> true

(* Compact layouts print expression comments but not comments on the full
 * labeled argument. For unlabeled arguments, leading expression comments
 * already work in the compact layout; forcing a different layout can make
 * comments exposed by removing parameter parentheses unstable. *)
let argument_requires_regular_layout cmt_tbl ((lbl, arg) as argument) =
  let loc = Parsetree_viewer.argument_loc argument in
  let has_leading_label_comments =
    match lbl with
    | Asttypes.Nolabel -> false
    | Labelled _ | Optional _ ->
      has_leading_comments cmt_tbl loc
      || has_leading_comments cmt_tbl arg.Parsetree.pexp_loc
  in
  (* Trailing comments can escape compact layouts when the body breaks. *)
  has_leading_label_comments
  || has_trailing_comments cmt_tbl loc
  || has_trailing_comments cmt_tbl arg.pexp_loc

let print_multiline_comment_content txt =
  (* Turns
   *         |* first line
   *  * second line
   *      * third line *|
   * Into
   * |* first line
   *  * second line
   *  * third line *|
   *
   * What makes a comment suitable for this kind of indentation?
   *  ->  multiple lines + every line starts with a star
   *)
  let rec indent_stars lines acc =
    match lines with
    | [] -> Doc.nil
    | [last_line] ->
      let line = String.trim last_line in
      let doc = Doc.text (" " ^ line) in
      let trailing_space = if line = "" then Doc.nil else Doc.space in
      List.rev (trailing_space :: doc :: acc) |> Doc.concat
    | line :: lines ->
      let line = String.trim line in
      if line != "" && String.unsafe_get line 0 == '*' then
        let doc = Doc.text (" " ^ line) in
        indent_stars lines (Doc.hard_line :: doc :: acc)
      else
        let trailing_space =
          let len = String.length txt in
          if len > 0 && String.unsafe_get txt (len - 1) = ' ' then Doc.space
          else Doc.nil
        in
        let content = Comment.trim_spaces txt in
        Doc.concat [Doc.text content; trailing_space]
  in
  let lines = String.split_on_char '\n' txt in
  match lines with
  | [] -> Doc.text "/* */"
  | [line] ->
    Doc.concat
      [Doc.text "/* "; Doc.text (Comment.trim_spaces line); Doc.text " */"]
  | first :: rest ->
    (* The printer writes the line break, so drop the CRs of a CRLF one *)
    let first =
      let len = ref (String.length first) in
      while !len > 0 && String.unsafe_get first (!len - 1) = '\r' do
        decr len
      done;
      String.sub first 0 !len [@doesNotRaise]
    in
    let first_line = Comment.trim_spaces first in
    Doc.concat
      [
        Doc.text "/*";
        (match first_line with
        | "" | "*" -> Doc.nil
        | _ -> Doc.space);
        indent_stars rest [Doc.hard_line; Doc.text first_line];
        Doc.text "*/";
      ]

let print_trailing_comment (prev_loc : Location.t) (node_loc : Location.t)
    comment =
  let single_line = Comment.is_single_line_comment comment in
  let content =
    let txt = Comment.txt comment in
    if single_line then Doc.text ("//" ^ txt)
    else print_multiline_comment_content txt
  in
  let diff =
    let cmt_start = (Comment.loc comment).loc_start in
    cmt_start.pos_lnum - prev_loc.loc_end.pos_lnum
  in
  let is_below =
    (Comment.loc comment).loc_start.pos_lnum > node_loc.loc_end.pos_lnum
  in
  if diff > 0 || is_below then
    Doc.concat
      [
        Doc.break_parent;
        Doc.line_suffix
          (Doc.concat
             [
               Doc.hard_line;
               (if diff > 1 then Doc.hard_line else Doc.nil);
               content;
             ]);
      ]
  else if not single_line then Doc.concat [Doc.space; content]
  else Doc.line_suffix (Doc.concat [Doc.space; content])

let print_comment_content comment =
  let txt = Comment.txt comment in
  if Comment.is_single_line_comment comment then Doc.text ("//" ^ txt)
  else print_multiline_comment_content txt

let print_leading_comment ?next_comment comment =
  let single_line = Comment.is_single_line_comment comment in
  let content = print_comment_content comment in
  let separator =
    Doc.concat
      [
        (if single_line then Doc.concat [Doc.hard_line; Doc.break_parent]
         else Doc.nil);
        (match next_comment with
        | Some next ->
          let next_loc = Comment.loc next in
          let curr_loc = Comment.loc comment in
          let diff =
            next_loc.Location.loc_start.pos_lnum
            - curr_loc.Location.loc_end.pos_lnum
          in
          let next_single_line = Comment.is_single_line_comment next in
          if single_line && next_single_line then
            if diff > 1 then Doc.hard_line else Doc.nil
          else if single_line && not next_single_line then
            if diff > 1 then Doc.hard_line else Doc.nil
          else if diff > 1 then Doc.concat [Doc.hard_line; Doc.hard_line]
          else if diff == 1 then Doc.hard_line
          else Doc.space
        | None -> Doc.nil);
      ]
  in
  Doc.concat [content; separator]

(* This function is used for printing comments inside an empty block *)
let print_comments_inside cmt_tbl loc =
  let print_comment comment =
    let single_line = Comment.is_single_line_comment comment in
    let txt = Comment.txt comment in
    if single_line then Doc.text ("//" ^ txt)
    else print_multiline_comment_content txt
  in
  let force_break =
    loc.Location.loc_start.pos_lnum <> loc.Location.loc_end.pos_lnum
  in
  let rec loop acc comments =
    match comments with
    | [] -> Doc.nil
    | [comment] ->
      let cmt_doc = print_comment comment in
      let cmts_doc = Doc.concat (Doc.soft_line :: List.rev (cmt_doc :: acc)) in
      let doc =
        Doc.breakable_group ~force_break
          (Doc.concat
             [Doc.if_breaks (Doc.indent cmts_doc) cmts_doc; Doc.soft_line])
      in
      doc
    | comment :: rest ->
      let cmt_doc = Doc.concat [print_comment comment; Doc.line] in
      loop (cmt_doc :: acc) rest
  in
  match Hashtbl.find cmt_tbl.Comment_table.inside loc with
  | exception Not_found -> Doc.nil
  | comments ->
    Hashtbl.remove cmt_tbl.inside loc;
    loop [] comments

(* This function is used for printing comments inside an empty file *)
let print_comments_inside_file cmt_tbl =
  let rec loop acc comments =
    match comments with
    | [] -> Doc.nil
    | [comment] ->
      (* Nothing follows the last comment: the line break after a line comment
         would add an empty line to the final newline of the file. *)
      let cmt_doc = print_comment_content comment in
      let doc =
        Doc.group (Doc.concat [Doc.concat (List.rev (cmt_doc :: acc))])
      in
      doc
    | comment :: (next_comment :: _comments as rest) ->
      let cmt_doc = print_leading_comment ~next_comment comment in
      loop (cmt_doc :: acc) rest
  in
  match Hashtbl.find cmt_tbl.Comment_table.inside Location.none with
  | exception Not_found -> Doc.nil
  | comments ->
    Hashtbl.remove cmt_tbl.inside Location.none;
    Doc.group (loop [] comments)

let print_leading_comments node tbl loc =
  let rec loop acc comments =
    match comments with
    | [] -> node
    | [comment] ->
      let cmt_doc = print_leading_comment comment in
      let diff =
        loc.Location.loc_start.pos_lnum
        - (Comment.loc comment).Location.loc_end.pos_lnum
      in
      let separator =
        if Comment.is_single_line_comment comment then
          if diff > 1 then Doc.hard_line else Doc.nil
        else if diff == 0 then Doc.space
        else if diff > 1 then Doc.concat [Doc.hard_line; Doc.hard_line]
        else Doc.hard_line
      in
      let comments = Doc.concat (List.rev (separator :: cmt_doc :: acc)) in
      let doc = Doc.group (Doc.concat [Doc.comment comments; node]) in
      doc
    | comment :: (next_comment :: _comments as rest) ->
      let cmt_doc = print_leading_comment ~next_comment comment in
      loop (cmt_doc :: acc) rest
  in
  match Hashtbl.find tbl loc with
  | exception Not_found -> node
  | comments ->
    (* Remove comments from tbl: Some ast nodes have the same location.
     * We only want to print comments once *)
    Hashtbl.remove tbl loc;
    loop [] comments

let print_trailing_comments node tbl loc =
  let rec loop prev acc comments =
    match comments with
    | [] -> Doc.concat (List.rev acc)
    | comment :: comments ->
      let cmt_doc = print_trailing_comment prev loc comment in
      loop (Comment.loc comment) (cmt_doc :: acc) comments
  in
  match Hashtbl.find tbl loc with
  | exception Not_found -> node
  | [] -> node
  | _first :: _ as comments ->
    (* Remove comments from tbl: Some ast nodes have the same location.
     * We only want to print comments once *)
    Hashtbl.remove tbl loc;
    let cmts_doc = loop loc [] comments in
    Doc.concat [node; cmts_doc]

let print_comments doc (tbl : Comment_table.t) loc =
  let doc_with_leading_comments = print_leading_comments doc tbl.leading loc in
  print_trailing_comments doc_with_leading_comments tbl.trailing loc

(* Prints [doc] with the comments of [loc], followed by [marker], a token that
   the source writes right after [loc] (such as [=?]). The trailing comments
   adjacent to [loc] precede the marker in the source and print before it; the
   remaining trailing comments print after it. *)
let print_comments_before_marker doc (tbl : Comment_table.t) loc marker =
  let after_marker =
    match Hashtbl.find_opt tbl.trailing loc with
    | None -> []
    | Some comments ->
      let before_marker, after_marker =
        Comment_table.partition_adjacent_trailing loc comments
      in
      Hashtbl.replace tbl.trailing loc before_marker;
      after_marker
  in
  let doc = Doc.concat [print_comments doc tbl loc; marker] in
  match after_marker with
  | [] -> doc
  | _ ->
    Hashtbl.replace tbl.trailing loc after_marker;
    print_trailing_comments doc tbl.trailing loc

(* [~space_multiline] adds a blank line next to nodes printed on several lines *)
let print_list ~get_loc ~nodes ~print ?(force_break = false)
    ?(space_multiline = false) t =
  let rec loop first_loc_opt prev_loc_opt acc nodes =
    match nodes with
    | [] -> (first_loc_opt, prev_loc_opt, Doc.concat (List.rev acc))
    | node :: nodes ->
      let loc = get_loc node in
      let start_pos =
        match get_first_leading_comment t loc with
        | None -> loc.loc_start
        | Some comment -> (Comment.loc comment).loc_start
      in
      let raw_doc = print node t in
      if Doc.is_nil raw_doc then loop first_loc_opt prev_loc_opt acc nodes
      else
        let doc = print_comments raw_doc t loc in
        let acc =
          match (prev_loc_opt, acc) with
          | Some prev_loc, prev_doc :: _ ->
            let sep =
              if start_pos.pos_lnum - prev_loc.Location.loc_end.pos_lnum > 1
              then Doc.concat [Doc.hard_line; Doc.hard_line]
              else if space_multiline then
                Doc.item_separator ~prev:prev_doc ~next:doc
              else Doc.hard_line
            in
            doc :: sep :: acc
          | _ -> [doc]
        in
        let first_loc_opt =
          match first_loc_opt with
          | None -> Some loc
          | Some _ -> first_loc_opt
        in
        loop first_loc_opt (Some loc) acc nodes
  in
  let first_loc_opt, last_loc_opt, docs = loop None None [] nodes in
  match (first_loc_opt, last_loc_opt) with
  | Some first_loc, Some last_loc ->
    let force_break =
      force_break || first_loc.loc_start.pos_lnum != last_loc.loc_end.pos_lnum
    in
    Doc.breakable_group ~force_break docs
  | _ -> Doc.nil

let print_listi ~get_loc ~nodes ~print ?(ignore_empty_lines = false)
    ?(force_break = false) t =
  let rec loop i first_loc_opt prev_loc_opt acc nodes =
    match nodes with
    | [] -> (first_loc_opt, prev_loc_opt, Doc.concat (List.rev acc))
    | node :: nodes ->
      let loc = get_loc node in
      let start_pos =
        match get_first_leading_comment t loc with
        | None -> loc.loc_start
        | Some comment -> (Comment.loc comment).loc_start
      in
      let raw_doc = print node t i in
      if Doc.is_nil raw_doc then loop i first_loc_opt prev_loc_opt acc nodes
      else
        let doc = print_comments raw_doc t loc in
        let acc =
          match prev_loc_opt with
          | None -> [doc]
          | Some prev_loc ->
            let sep =
              if
                start_pos.pos_lnum - prev_loc.Location.loc_end.pos_lnum > 1
                && not ignore_empty_lines
              then Doc.concat [Doc.hard_line; Doc.hard_line]
              else Doc.line
            in
            doc :: sep :: acc
        in
        let first_loc_opt =
          match first_loc_opt with
          | None -> Some loc
          | Some _ -> first_loc_opt
        in
        loop (i + 1) first_loc_opt (Some loc) acc nodes
  in
  let first_loc_opt, last_loc_opt, docs = loop 0 None None [] nodes in
  match (first_loc_opt, last_loc_opt) with
  | Some first_loc, Some last_loc ->
    let force_break =
      force_break || first_loc.loc_start.pos_lnum != last_loc.loc_end.pos_lnum
    in
    Doc.breakable_group ~force_break docs
  | _ -> Doc.nil

let rec print_longident_aux accu = function
  | Longident.Lident s -> Doc.text s :: accu
  | Ldot (lid, s) -> print_longident_aux (Doc.text s :: accu) lid

let print_longident = function
  | Longident.Lident txt -> Doc.text txt
  | lid -> Doc.join ~sep:Doc.dot (print_longident_aux [] lid)

type identifier_style = UppercaseExoticIdent | ExoticIdent | NormalIdent

let classify_ident_content ?(allow_uident = false) ?(allow_hyphen = false) txt =
  if Token.is_keyword_txt txt then ExoticIdent
  else
    let len = String.length txt in
    let rec loop i =
      if i == len then NormalIdent
      else if i == 0 then
        match String.unsafe_get txt i with
        | '\\' -> UppercaseExoticIdent
        | 'A' .. 'Z' when allow_uident -> loop (i + 1)
        | 'a' .. 'z' | '$' -> loop (i + 1)
        (* The scanner reads [_] as an identifier only when one of these
           follows; otherwise it is a wildcard. *)
        | '_' when len > 1 -> (
          match String.unsafe_get txt 1 with
          | 'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' | '_' | '$' -> loop (i + 1)
          | _ -> ExoticIdent)
        | _ -> ExoticIdent
      else
        match String.unsafe_get txt i with
        | 'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' | '\'' | '_' | '$' -> loop (i + 1)
        | '-' when allow_hyphen -> loop (i + 1)
        | _ -> ExoticIdent
    in
    loop 0

let print_ident_like ?allow_uident ?allow_hyphen txt =
  match classify_ident_content ?allow_uident ?allow_hyphen txt with
  | ExoticIdent -> Doc.concat [Doc.text "\\\""; Doc.text txt; Doc.text "\""]
  | UppercaseExoticIdent | NormalIdent -> Doc.text txt

let rec unsafe_for_all_range s ~start ~finish p =
  start > finish
  || p (String.unsafe_get s start)
     && unsafe_for_all_range s ~start:(start + 1) ~finish p

let for_all_from s start p =
  let len = String.length s in
  unsafe_for_all_range s ~start ~finish:(len - 1) p

(* See https://github.com/rescript-lang/rescript-compiler/blob/726cfa534314b586e5b5734471bc2023ad99ebd9/jscomp/ext/ext_string.ml#L510 *)
let is_valid_numeric_polyvar_number (x : string) =
  let len = String.length x in
  len > 0
  &&
  let a = Char.code (String.unsafe_get x 0) in
  a <= 57
  &&
  if len > 1 then
    a > 48
    && for_all_from x 1 (function
      | '0' .. '9' -> true
      | _ -> false)
  else a >= 48

(* Exotic identifiers in poly-vars have a "lighter" syntax: #"ease-in" *)
let print_poly_var_ident txt =
  (* numeric poly-vars don't need quotes: #644 *)
  if is_valid_numeric_polyvar_number txt then Doc.text txt
  else
    match classify_ident_content ~allow_uident:true txt with
    | UppercaseExoticIdent ->
      let len = String.length txt in
      (* UppercaseExoticIdent follows the \"..." format,
         so removing the leading backslash is enough to transform it into polyvar style *)
      Doc.text ((String.sub [@doesNotRaise]) txt 1 (len - 1))
    | ExoticIdent -> Doc.concat [Doc.text "\""; Doc.text txt; Doc.text "\""]
    | NormalIdent -> (
      match txt with
      | "" -> Doc.concat [Doc.text "\""; Doc.text txt; Doc.text "\""]
      | _ -> Doc.text txt)

let polyvar_ident_to_string poly_var_ident =
  Doc.concat [Doc.text "#"; print_poly_var_ident poly_var_ident]
  |> Doc.to_string ~width:80

let find_inline_record_definition inline_record_name
    (inline_record_definitions : Parsetree.type_declaration list option) =
  match inline_record_definitions with
  | None -> None
  | Some inline_record_definitions ->
    inline_record_definitions
    |> List.find_opt (fun (r : Parsetree.type_declaration) ->
        r.ptype_name.txt = inline_record_name)

let pending_inline_record_definitions inline_record_definitions =
  let external_name_of_type_declaration
      (type_declaration : Parsetree.type_declaration) =
    match String.index_opt type_declaration.ptype_name.txt '.' with
    | None -> None
    | Some index -> Some (String.sub type_declaration.ptype_name.txt 0 index)
  in
  match inline_record_definitions with
  | [] -> None
  | first :: rest -> (
    match external_name_of_type_declaration first with
    | None -> None
    | Some external_name ->
      if
        List.for_all
          (fun type_declaration ->
            external_name_of_type_declaration type_declaration
            = Some external_name)
          rest
      then Some (external_name, inline_record_definitions)
      else None)

let print_lident l =
  let flat_lid lid =
    let rec flat accu = function
      | Longident.Lident s -> s :: accu
      | Ldot (lid, s) -> flat (s :: accu) lid
    in
    flat [] lid
  in
  match l with
  | Longident.Lident txt -> print_ident_like txt
  | Longident.Ldot (path, txt) ->
    Doc.concat
      [
        Doc.join ~sep:Doc.dot (List.map Doc.text (flat_lid path));
        Doc.dot;
        print_ident_like txt;
      ]

let print_longident_location l cmt_tbl =
  let doc = print_longident l.Location.txt in
  print_comments doc cmt_tbl l.loc

(* Module.SubModule.x *)
let print_lident_path path cmt_tbl =
  let doc = print_lident path.Location.txt in
  print_comments doc cmt_tbl path.loc

(* Module.SubModule.x or Module.SubModule.X *)
let print_ident_path path cmt_tbl =
  let doc = print_lident path.Location.txt in
  print_comments doc cmt_tbl path.loc

let print_string_loc sloc cmt_tbl =
  let doc = print_ident_like sloc.Location.txt in
  print_comments doc cmt_tbl sloc.loc

let print_string_contents txt =
  let lines = String.split_on_char '\n' txt in
  Doc.join ~sep:Doc.literal_line (List.map Doc.text lines)

let interleave_template_parts sources values =
  let rec loop acc sources values =
    match (sources, values) with
    | [source], [] -> Doc.concat [acc; source]
    | source :: sources, value :: values ->
      loop (Doc.concat [acc; source; value]) sources values
    | _ -> assert false
  in
  loop Doc.nil sources values

let print_constant c =
  match c with
  | Parsetree.Pconst_integer (s, suffix) -> (
    match suffix with
    | Some c -> Doc.text (s ^ Char.escaped c)
    | None -> Doc.text s)
  | Pconst_string payload ->
    Doc.concat
      [
        Doc.text "\"";
        print_string_contents (String_literal.string_source payload);
        Doc.text "\"";
      ]
  | Pconst_char {source} ->
    Doc.concat [Doc.text "'"; Doc.text source; Doc.text "'"]
  | Pconst_float (s, _) -> Doc.text s

module State = struct
  let custom_layout_threshold = 2

  type pending_inline_record_definitions = {
    external_name: string;
    definitions: Parsetree.type_declaration list;
  }

  type t = {
    custom_layout: int;
    mutable pending_inline_record_defs_for_external:
      pending_inline_record_definitions option;
  }

  let init () =
    {custom_layout = 0; pending_inline_record_defs_for_external = None}

  let next_custom_layout t =
    {
      custom_layout = t.custom_layout + 1;
      pending_inline_record_defs_for_external =
        t.pending_inline_record_defs_for_external;
    }

  let should_break_callback t = t.custom_layout > custom_layout_threshold
end

let rec print_structure ~state (s : Parsetree.structure) t =
  match s with
  | [] -> print_comments_inside_file t
  | structure ->
    let previous_can_continue = ref false in
    print_list ~space_multiline:true
      ~get_loc:(fun s -> s.Parsetree.pstr_loc)
      ~nodes:structure
      ~print:(fun item cmt_tbl ->
        let protect_regexp = !previous_can_continue in
        (previous_can_continue :=
           match item.Parsetree.pstr_desc with
           | Pstr_value _ | Pstr_eval _ -> true
           | _ -> false);
        print_structure_item ~state ~protect_regexp item cmt_tbl)
      t

and print_statement_expr ~protect_regexp expr kind doc =
  match kind with
  | Parens.Parenthesized -> add_parens doc
  | Braced braces -> print_braces doc expr braces
  | Nothing when protect_regexp && Parens.starts_with_regexp expr ->
    add_statement_parens doc
  | Nothing -> doc

and print_structure_item ~state ?(protect_regexp = false)
    (si : Parsetree.structure_item) cmt_tbl =
  let clear_pending () =
    state.State.pending_inline_record_defs_for_external <- None
  in
  match si.pstr_desc with
  | Pstr_value (rec_flag, value_bindings) ->
    clear_pending ();
    let rec_flag =
      match rec_flag with
      | Asttypes.Nonrecursive -> Doc.nil
      | Asttypes.Recursive -> Doc.text "rec "
    in
    print_value_bindings ~state ~rec_flag value_bindings cmt_tbl
  | Pstr_type (rec_flag, type_declarations) ->
    print_type_declarations ~state ~rec_flag type_declarations cmt_tbl
  | Pstr_primitive value_description ->
    print_value_description ~state value_description cmt_tbl
  | Pstr_eval (expr, attrs) ->
    clear_pending ();
    let expr_doc =
      let protect_regexp = protect_regexp && attrs = [] in
      let doc = print_expression_with_comments ~state expr cmt_tbl in
      print_statement_expr ~protect_regexp expr (Parens.structure_expr expr) doc
    in
    Doc.concat [print_attributes ~state attrs cmt_tbl; expr_doc]
  | Pstr_attribute attr ->
    clear_pending ();
    fst (print_attribute ~state ~standalone:true attr cmt_tbl)
  | Pstr_raw {name_loc; source; attrs} ->
    clear_pending ();
    Doc.concat
      [
        print_attributes ~state attrs cmt_tbl;
        print_extension ~state ~at_module_lvl:true
          (Ast_raw.to_extension ~name:"raw" ~name_loc source)
          cmt_tbl;
      ]
  | Pstr_extension (extension, attrs) ->
    clear_pending ();
    Doc.concat
      [
        print_attributes ~state attrs cmt_tbl;
        Doc.concat
          [print_extension ~state ~at_module_lvl:true extension cmt_tbl];
      ]
  | Pstr_include include_declaration ->
    clear_pending ();
    print_include_declaration ~state include_declaration cmt_tbl
  | Pstr_open open_description ->
    clear_pending ();
    print_open_description ~state open_description cmt_tbl
  | Pstr_modtype mod_type_decl ->
    clear_pending ();
    print_module_type_declaration ~state mod_type_decl cmt_tbl
  | Pstr_module module_binding ->
    clear_pending ();
    print_module_binding ~state ~is_rec:false module_binding cmt_tbl 0
  | Pstr_recmodule module_bindings ->
    clear_pending ();
    print_listi
      ~get_loc:(fun mb -> mb.Parsetree.pmb_loc)
      ~nodes:module_bindings
      ~print:(print_module_binding ~state ~is_rec:true)
      cmt_tbl
  | Pstr_exception extension_constructor ->
    clear_pending ();
    print_exception_def ~state extension_constructor cmt_tbl
  | Pstr_typext type_extension ->
    clear_pending ();
    print_type_extension ~state type_extension cmt_tbl

and print_type_extension ~state (te : Parsetree.type_extension) cmt_tbl =
  let prefix = Doc.text "type " in
  let name = print_lident_path te.ptyext_path cmt_tbl in
  let type_params = print_type_params ~state te.ptyext_params cmt_tbl in
  let extension_constructors =
    let ecs = te.ptyext_constructors in
    let force_break =
      match (ecs, List.rev ecs) with
      | first :: _, last :: _ ->
        first.pext_loc.loc_start.pos_lnum > te.ptyext_path.loc.loc_end.pos_lnum
        || first.pext_loc.loc_start.pos_lnum < last.pext_loc.loc_end.pos_lnum
      | _ -> false
    in
    let private_flag =
      match te.ptyext_private with
      | Asttypes.Private -> Doc.concat [Doc.text "private"; Doc.line]
      | Public -> Doc.nil
    in
    let rows =
      print_listi
        ~get_loc:(fun n -> n.Parsetree.pext_loc)
        ~print:(print_extension_constructor ~state)
        ~nodes:ecs ~force_break cmt_tbl
    in
    Doc.breakable_group ~force_break
      (Doc.indent (Doc.concat [Doc.line; private_flag; rows]))
  in
  Doc.group
    (Doc.concat
       [
         print_attributes ~state ~loc:te.ptyext_path.loc te.ptyext_attributes
           cmt_tbl;
         prefix;
         name;
         type_params;
         Doc.text " +=";
         extension_constructors;
       ])

and print_module_binding ~state ~is_rec module_binding cmt_tbl i =
  let prefix =
    if i = 0 then
      Doc.concat
        [Doc.text "module "; (if is_rec then Doc.text "rec " else Doc.nil)]
    else Doc.text "and "
  in
  let mod_expr_doc, mod_constraint_doc =
    match module_binding.pmb_expr with
    | {pmod_desc = Pmod_constraint (mod_expr, mod_type)} as constrained
    (* [module M: S = E] has no node for the constraint's attributes *)
      when not (Parsetree_viewer.mod_expr_has_attributes constrained) ->
      let mod_expr_doc =
        if Parens.mod_expr_parens constrained then
          add_mod_expr_parens (print_mod_expr ~state mod_expr cmt_tbl)
        else print_mod_expr_constraint_parens ~state mod_expr cmt_tbl
      in
      ( mod_expr_doc,
        Doc.concat [Doc.text ": "; print_mod_type ~state mod_type cmt_tbl] )
    | mod_expr -> (print_mod_expr ~state mod_expr cmt_tbl, Doc.nil)
  in
  let mod_name =
    let doc = Doc.text module_binding.pmb_name.Location.txt in
    print_comments doc cmt_tbl module_binding.pmb_name.loc
  in
  let doc =
    Doc.concat
      [
        print_attributes ~state ~loc:module_binding.pmb_name.loc
          module_binding.pmb_attributes cmt_tbl;
        prefix;
        mod_name;
        mod_constraint_doc;
        Doc.text " = ";
        mod_expr_doc;
      ]
  in
  print_comments doc cmt_tbl module_binding.pmb_loc

and print_module_type_declaration ~state
    (mod_type_decl : Parsetree.module_type_declaration) cmt_tbl =
  let mod_name =
    let doc = Doc.text mod_type_decl.pmtd_name.txt in
    print_comments doc cmt_tbl mod_type_decl.pmtd_name.loc
  in
  Doc.concat
    [
      print_attributes ~state mod_type_decl.pmtd_attributes cmt_tbl;
      Doc.text "module type ";
      mod_name;
      (match mod_type_decl.pmtd_type with
      | None -> Doc.nil
      | Some mod_type ->
        Doc.concat [Doc.text " = "; print_mod_type ~state mod_type cmt_tbl]);
    ]

and print_mod_type ~state mod_type cmt_tbl =
  let mod_type_doc =
    match mod_type.pmty_desc with
    | Parsetree.Pmty_ident longident ->
      Doc.concat
        [
          print_attributes ~state ~loc:longident.loc mod_type.pmty_attributes
            cmt_tbl;
          print_longident_location longident cmt_tbl;
        ]
    | Pmty_signature [] ->
      if has_comments_inside cmt_tbl mod_type.pmty_loc then
        let doc = print_comments_inside cmt_tbl mod_type.pmty_loc in
        Doc.concat [Doc.lbrace; doc; Doc.rbrace]
      else
        let should_break =
          mod_type.pmty_loc.loc_start.pos_lnum
          < mod_type.pmty_loc.loc_end.pos_lnum
        in
        Doc.breakable_group ~force_break:should_break
          (Doc.concat [Doc.lbrace; Doc.soft_line; Doc.soft_line; Doc.rbrace])
    | Pmty_signature signature ->
      let signature_doc =
        Doc.breakable_group ~force_break:true
          (Doc.concat
             [
               Doc.lbrace;
               Doc.indent
                 (Doc.concat
                    [Doc.line; print_signature ~state signature cmt_tbl]);
               Doc.line;
               Doc.rbrace;
             ])
      in
      Doc.concat
        [
          print_attributes ~state mod_type.pmty_attributes cmt_tbl; signature_doc;
        ]
    | Pmty_functor _ ->
      let parameters, return_type = Parsetree_viewer.functor_type mod_type in
      let parameters_doc =
        match parameters with
        | [] -> Doc.nil
        | [(attrs, {Location.txt = "_"; loc}, Some mod_type)] ->
          let cmt_loc =
            {loc with loc_end = mod_type.Parsetree.pmty_loc.loc_end}
          in
          let attrs = print_attributes ~state attrs cmt_tbl in
          let doc =
            Doc.concat [attrs; print_mod_type ~state mod_type cmt_tbl]
          in
          print_comments doc cmt_tbl cmt_loc
        | [(attrs, {Location.txt = "*"; loc}, None)] ->
          let attrs = print_attributes ~state attrs cmt_tbl in
          let doc = Doc.concat [attrs; Doc.text "()"] in
          print_comments doc cmt_tbl loc
        | params ->
          Doc.group
            (Doc.concat
               [
                 Doc.lparen;
                 Doc.indent
                   (Doc.concat
                      [
                        Doc.soft_line;
                        Doc.join
                          ~sep:(Doc.concat [Doc.comma; Doc.line])
                          (List.map
                             (fun (attrs, lbl, mod_type) ->
                               let cmt_loc =
                                 match mod_type with
                                 | None -> lbl.Asttypes.loc
                                 | Some mod_type ->
                                   {
                                     lbl.Asttypes.loc with
                                     loc_end =
                                       mod_type.Parsetree.pmty_loc.loc_end;
                                   }
                               in
                               let attrs =
                                 print_attributes ~state attrs cmt_tbl
                               in
                               let lbl_doc =
                                 if lbl.Location.txt = "_" then Doc.nil
                                 else if lbl.txt = "*" then
                                   let doc = Doc.text "()" in
                                   print_comments doc cmt_tbl lbl.loc
                                 else
                                   let doc = Doc.text lbl.txt in
                                   print_comments doc cmt_tbl lbl.loc
                               in
                               let doc =
                                 Doc.concat
                                   [
                                     attrs;
                                     lbl_doc;
                                     (match mod_type with
                                     | None -> Doc.nil
                                     | Some mod_type ->
                                       Doc.concat
                                         [
                                           (if lbl.txt = "_" then Doc.nil
                                            else Doc.text ": ");
                                           print_mod_type ~state mod_type
                                             cmt_tbl;
                                         ]);
                                   ]
                               in
                               print_comments doc cmt_tbl cmt_loc)
                             params);
                      ]);
                 Doc.trailing_comma;
                 Doc.soft_line;
                 Doc.rparen;
               ])
      in
      let return_doc =
        let doc = print_mod_type ~state return_type cmt_tbl in
        if Parens.mod_type_functor_return return_type then add_parens doc
        else doc
      in
      (* When the functor result is a signature, keep its opening brace on the
         same line as `=>` instead of breaking onto a new line, mirroring how
         module-expression functors are printed (see print_mod_functor). *)
      let arrow_sep =
        match return_type.pmty_desc with
        | Pmty_signature _ -> Doc.space
        | _ -> Doc.line
      in
      Doc.group
        (Doc.concat
           [
             parameters_doc;
             Doc.group (Doc.concat [Doc.text " =>"; arrow_sep; return_doc]);
           ])
    | Pmty_typeof mod_expr ->
      Doc.concat
        [
          Doc.text "module type of ";
          print_mod_expr_constraint_parens ~state mod_expr cmt_tbl;
        ]
    | Pmty_extension extension ->
      print_extension ~state ~at_module_lvl:false extension cmt_tbl
    | Pmty_alias longident ->
      Doc.concat
        [Doc.text "module "; print_longident_location longident cmt_tbl]
    | Pmty_with (mod_type, with_constraints) ->
      let operand =
        let doc = print_mod_type ~state mod_type cmt_tbl in
        if Parens.mod_type_with_operand mod_type then add_parens doc else doc
      in
      Doc.group
        (Doc.concat
           [
             operand;
             Doc.indent
               (Doc.concat
                  [
                    Doc.line;
                    print_with_constraints ~state with_constraints cmt_tbl;
                  ]);
           ])
  in
  let attrs_already_printed =
    match mod_type.pmty_desc with
    | Pmty_functor _ | Pmty_signature _ | Pmty_ident _ -> true
    | _ -> false
  in
  let doc =
    Doc.concat
      [
        (if attrs_already_printed then Doc.nil
         else print_attributes ~state mod_type.pmty_attributes cmt_tbl);
        mod_type_doc;
      ]
  in
  print_comments doc cmt_tbl mod_type.pmty_loc

and print_with_constraints ~state with_constraints cmt_tbl =
  let rows =
    List.mapi
      (fun i with_constraint ->
        Doc.group
          (Doc.concat
             [
               (if i == 0 then Doc.text "with " else Doc.text "and ");
               print_with_constraint ~state with_constraint cmt_tbl;
             ]))
      with_constraints
  in
  Doc.join ~sep:Doc.line rows

and print_with_constraint ~state (with_constraint : Parsetree.with_constraint)
    cmt_tbl =
  match with_constraint with
  (* with type X.t = ... *)
  | Pwith_type (longident, type_declaration) ->
    Doc.group
      (print_type_declaration ~state
         ~name:(print_lident_path longident cmt_tbl)
         ~equal_sign:"=" ~rec_flag:Doc.nil 0 type_declaration
         Comment_table.empty)
  (* with module X.Y = Z *)
  | Pwith_module ({txt = longident1}, {txt = longident2}) ->
    Doc.concat
      [
        Doc.text "module ";
        print_longident longident1;
        Doc.text " =";
        Doc.indent (Doc.concat [Doc.line; print_longident longident2]);
      ]
  (* with type X.t := ..., same format as [Pwith_type] *)
  | Pwith_typesubst (longident, type_declaration) ->
    Doc.group
      (print_type_declaration ~state
         ~name:(print_lident_path longident cmt_tbl)
         ~equal_sign:":=" ~rec_flag:Doc.nil 0 type_declaration
         Comment_table.empty)
  | Pwith_modsubst ({txt = longident1}, {txt = longident2}) ->
    Doc.concat
      [
        Doc.text "module ";
        print_longident longident1;
        Doc.text " :=";
        Doc.indent (Doc.concat [Doc.line; print_longident longident2]);
      ]

and print_signature ~state signature cmt_tbl =
  match signature with
  | [] -> print_comments_inside_file cmt_tbl
  | signature ->
    print_list ~space_multiline:true
      ~get_loc:(fun s -> s.Parsetree.psig_loc)
      ~nodes:signature
      ~print:(print_signature_item ~state)
      cmt_tbl

and print_signature_item ~state (si : Parsetree.signature_item) cmt_tbl =
  let clear_pending () =
    state.State.pending_inline_record_defs_for_external <- None
  in
  match si.psig_desc with
  | Parsetree.Psig_value value_description ->
    print_value_description ~state value_description cmt_tbl
  | Psig_type (rec_flag, type_declarations) ->
    print_type_declarations ~state ~rec_flag type_declarations cmt_tbl
  | Psig_typext type_extension ->
    clear_pending ();
    print_type_extension ~state type_extension cmt_tbl
  | Psig_exception extension_constructor ->
    clear_pending ();
    print_exception_def ~state extension_constructor cmt_tbl
  | Psig_module module_declaration ->
    clear_pending ();
    print_module_declaration ~state module_declaration cmt_tbl
  | Psig_recmodule module_declarations ->
    clear_pending ();
    print_rec_module_declarations ~state module_declarations cmt_tbl
  | Psig_modtype mod_type_decl ->
    clear_pending ();
    print_module_type_declaration ~state mod_type_decl cmt_tbl
  | Psig_open open_description ->
    clear_pending ();
    print_open_description ~state open_description cmt_tbl
  | Psig_include include_description ->
    clear_pending ();
    print_include_description ~state include_description cmt_tbl
  | Psig_attribute attr ->
    clear_pending ();
    fst (print_attribute ~state ~standalone:true attr cmt_tbl)
  | Psig_extension (extension, attrs) ->
    clear_pending ();
    Doc.concat
      [
        print_attributes ~state attrs cmt_tbl;
        Doc.concat
          [print_extension ~state ~at_module_lvl:true extension cmt_tbl];
      ]

and print_rec_module_declarations ~state module_declarations cmt_tbl =
  print_listi
    ~get_loc:(fun n -> n.Parsetree.pmd_loc)
    ~nodes:module_declarations
    ~print:(print_rec_module_declaration ~state)
    cmt_tbl

and print_rec_module_declaration ~state md cmt_tbl i =
  let body =
    match md.pmd_type.pmty_desc with
    | Parsetree.Pmty_alias longident ->
      Doc.concat [Doc.text " = "; print_longident_location longident cmt_tbl]
    | _ ->
      let needs_parens =
        match md.pmd_type.pmty_desc with
        | Pmty_with _ -> true
        | _ -> false
      in
      let mod_type_doc =
        let doc = print_mod_type ~state md.pmd_type cmt_tbl in
        if needs_parens then add_parens doc else doc
      in
      Doc.concat [Doc.text ": "; mod_type_doc]
  in
  let prefix = if i < 1 then "module rec " else "and " in
  Doc.concat
    [
      print_attributes ~state ~loc:md.pmd_name.loc md.pmd_attributes cmt_tbl;
      Doc.text prefix;
      print_comments (Doc.text md.pmd_name.txt) cmt_tbl md.pmd_name.loc;
      body;
    ]

and print_module_declaration ~state (md : Parsetree.module_declaration) cmt_tbl
    =
  let body =
    match md.pmd_type.pmty_desc with
    | Parsetree.Pmty_alias longident ->
      Doc.concat [Doc.text " = "; print_longident_location longident cmt_tbl]
    | _ -> Doc.concat [Doc.text ": "; print_mod_type ~state md.pmd_type cmt_tbl]
  in
  Doc.concat
    [
      print_attributes ~state ~loc:md.pmd_name.loc md.pmd_attributes cmt_tbl;
      Doc.text "module ";
      print_comments (Doc.text md.pmd_name.txt) cmt_tbl md.pmd_name.loc;
      body;
    ]

and print_open_description ~state
    (open_description : Parsetree.open_description) cmt_tbl =
  Doc.concat
    [
      print_attributes ~state open_description.popen_attributes cmt_tbl;
      Doc.text "open";
      (match open_description.popen_override with
      | Asttypes.Fresh -> Doc.space
      | Asttypes.Override -> Doc.text "! ");
      print_longident_location open_description.popen_lid cmt_tbl;
    ]

and print_include_description ~state
    (include_description : Parsetree.include_description) cmt_tbl =
  Doc.concat
    [
      print_attributes ~state include_description.pincl_attributes cmt_tbl;
      Doc.text "include ";
      print_mod_type ~state include_description.pincl_mod cmt_tbl;
    ]

and print_include_declaration ~state
    (include_declaration : Parsetree.include_declaration) cmt_tbl =
  Doc.concat
    [
      print_attributes ~state include_declaration.pincl_attributes cmt_tbl;
      Doc.text "include ";
      (let include_doc =
         match include_declaration.pincl_mod with
         (* 
           include Module.Name({ type t = t })
           try as oneliner if there is a single type alias declaration
          *)
         | {
          pmod_attributes = [];
          pmod_desc =
            Pmod_apply
              ( {pmod_desc = Pmod_ident longident_loc; pmod_attributes = []},
                {
                  pmod_attributes = [];
                  pmod_desc =
                    Pmod_structure
                      [
                        ({
                           pstr_desc =
                             Pstr_type
                               ( _,
                                 [
                                   {
                                     ptype_kind = Ptype_abstract;
                                     ptype_manifest = Some _;
                                   };
                                 ] );
                         } as structure_item);
                      ];
                } );
         } ->
           Doc.concat
             [
               print_longident_location longident_loc cmt_tbl;
               Doc.lparen;
               Doc.breakable_group ~force_break:false
                 (Doc.concat
                    [
                      Doc.lbrace;
                      Doc.indent
                        (Doc.concat
                           [
                             Doc.soft_line;
                             print_structure_item ~state structure_item cmt_tbl;
                           ]);
                      Doc.soft_line;
                      Doc.rbrace;
                    ]);
               Doc.rparen;
             ]
         | _ -> print_mod_expr ~state include_declaration.pincl_mod cmt_tbl
       in
       if Parens.mod_constraint include_declaration.pincl_mod then
         add_parens include_doc
       else include_doc);
    ]

and print_value_bindings ~state ~rec_flag (vbs : Parsetree.value_binding list)
    cmt_tbl =
  print_listi
    ~get_loc:(fun vb -> vb.Parsetree.pvb_loc)
    ~nodes:vbs
    ~print:(print_value_binding ~state ~rec_flag)
    cmt_tbl

and print_value_description ~state value_description cmt_tbl =
  let is_external =
    match value_description.pval_prim with
    | None -> false
    | Some _ -> true
  in
  let attrs =
    print_attributes ~state ~loc:value_description.pval_name.loc
      (Ast_helper.Val.description_attributes value_description)
      cmt_tbl
  in
  let header = if is_external then "external " else "let " in
  let inline_record_definitions =
    match state.State.pending_inline_record_defs_for_external with
    | Some {external_name; definitions}
      when is_external && external_name = value_description.pval_name.txt ->
      state.State.pending_inline_record_defs_for_external <- None;
      Some definitions
    | Some _ ->
      state.State.pending_inline_record_defs_for_external <- None;
      None
    | None -> None
  in
  Doc.group
    (Doc.concat
       [
         attrs;
         Doc.text header;
         print_comments
           (print_ident_like value_description.pval_name.txt)
           cmt_tbl value_description.pval_name.loc;
         Doc.text ": ";
         print_typ_expr ?inline_record_definitions ~state
           value_description.pval_type cmt_tbl;
         (if is_external then
            Doc.group
              (Doc.concat
                 [
                   Doc.text " =";
                   Doc.indent
                     (Doc.concat
                        [
                          Doc.line;
                          (let s =
                             match value_description.pval_prim with
                             | Some (Prim_name s) | Some (Prim_ffi {name = s})
                               ->
                               s
                             | Some (Prim_inline_const _) | None -> ""
                           in
                           Doc.concat [Doc.text "\""; Doc.text s; Doc.text "\""]);
                        ]);
                 ])
          else Doc.nil);
       ])

and print_type_declarations ~state ~rec_flag type_declarations cmt_tbl =
  if has_inline_type_definitions type_declarations then (
    let inline_record_definitions, regular_declarations =
      type_declarations
      |> List.partition (fun (td : Parsetree.type_declaration) ->
          td.ptype_origin = Inline_record_definition)
    in
    match regular_declarations with
    | [] -> (
      match pending_inline_record_definitions inline_record_definitions with
      | Some (external_name, definitions) ->
        state.State.pending_inline_record_defs_for_external <-
          Some State.{external_name; definitions};
        Doc.nil
      | None ->
        print_listi
          ~get_loc:(fun n -> n.Parsetree.ptype_loc)
          ~nodes:type_declarations
          ~print:
            (print_type_declaration2 ~state
               ~rec_flag:
                 (match rec_flag with
                 | Nonrecursive -> Doc.nil
                 | Recursive -> Doc.text "rec "))
          cmt_tbl)
    | _ ->
      state.State.pending_inline_record_defs_for_external <- None;
      let adjusted_rec_flag =
        match rec_flag with
        | Recursive ->
          if List.length regular_declarations > 1 then Doc.text "rec "
          else Doc.nil
        | Nonrecursive -> Doc.nil
      in
      print_listi
        ~get_loc:(fun n -> n.Parsetree.ptype_loc)
        ~nodes:regular_declarations
        ~print:
          (print_type_declaration2 ~inline_record_definitions ~state
             ~rec_flag:adjusted_rec_flag)
        cmt_tbl)
  else (
    state.State.pending_inline_record_defs_for_external <- None;
    print_listi
      ~get_loc:(fun n -> n.Parsetree.ptype_loc)
      ~nodes:type_declarations
      ~print:
        (print_type_declaration2 ~state
           ~rec_flag:
             (match rec_flag with
             | Nonrecursive -> Doc.nil
             | Recursive -> Doc.text "rec "))
      cmt_tbl)

(*
 * type_declaration = {
 *    ptype_name: string loc;
 *    ptype_params: (core_type * variance) list;
 *          (* ('a1,...'an) t; None represents  _*)
 *    ptype_cstrs: (core_type * core_type * Location.t) list;
 *          (* ... constraint T1=T1'  ... constraint Tn=Tn' *)
 *    ptype_kind: type_kind;
 *    ptype_private: private_flag;   (* = private ... *)
 *    ptype_manifest: core_type option;  (* = T *)
 *    ptype_attributes: attributes;   (* ... [@@id1] [@@id2] *)
 *    ptype_loc: Location.t;
 * }
 *
 *
 *  type t                     (abstract, no manifest)
 *  type t = T0                (abstract, manifest=T0)
 *  type t = C of T | ...      (variant,  no manifest)
 *  type t = T0 = C of T | ... (variant,  manifest=T0)
 *  type t = {l: T; ...}       (record,   no manifest)
 *  type t = T0 = {l : T; ...} (record,   manifest=T0)
 *  type t = ..                (open,     no manifest)
 *
 *
 * and type_kind =
 *  | Ptype_abstract
 *  | Ptype_variant of constructor_declaration list
 *        (* Invariant: non-empty list *)
 *  | Ptype_record of label_declaration list
 *        (* Invariant: non-empty list *)
 *  | Ptype_open
 *)
and print_type_declaration ~state ~name ~equal_sign ~rec_flag i
    (td : Parsetree.type_declaration) cmt_tbl =
  let attrs =
    print_attributes ~state ~loc:td.ptype_loc td.ptype_attributes cmt_tbl
  in
  let prefix =
    if i > 0 then Doc.text "and " else Doc.concat [Doc.text "type "; rec_flag]
  in
  let type_name = name in
  let type_params = print_type_params ~state td.ptype_params cmt_tbl in
  let manifest_and_kind =
    match td.ptype_kind with
    | Ptype_abstract -> (
      match td.ptype_manifest with
      | None -> Doc.nil
      | Some typ ->
        Doc.concat
          [
            Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
            print_private_flag td.ptype_private;
            print_typ_expr ~state typ cmt_tbl;
          ])
    | Ptype_open ->
      Doc.concat
        [
          Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
          print_private_flag td.ptype_private;
          Doc.text "..";
        ]
    | Ptype_record lds ->
      let manifest =
        match td.ptype_manifest with
        | None -> Doc.nil
        | Some typ ->
          Doc.concat
            [
              Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
              print_typ_expr ~state typ cmt_tbl;
            ]
      in
      Doc.concat
        [
          manifest;
          Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
          print_private_flag td.ptype_private;
          print_record_declaration ~record_loc:td.ptype_loc ~state lds cmt_tbl;
        ]
    | Ptype_variant cds ->
      let manifest =
        match td.ptype_manifest with
        | None -> Doc.nil
        | Some typ ->
          Doc.concat
            [
              Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
              print_typ_expr ~state typ cmt_tbl;
            ]
      in
      Doc.concat
        [
          manifest;
          Doc.concat [Doc.space; Doc.text equal_sign];
          print_constructor_declarations ~state ~private_flag:td.ptype_private
            cds cmt_tbl;
        ]
  in
  let constraints = print_type_definition_constraints ~state td.ptype_cstrs in
  Doc.group
    (Doc.concat
       [attrs; prefix; type_name; type_params; manifest_and_kind; constraints])

and print_type_declaration2 ?inline_record_definitions ~state ~rec_flag
    (td : Parsetree.type_declaration) cmt_tbl i =
  let name =
    let doc = print_ident_like td.Parsetree.ptype_name.txt in
    print_comments doc cmt_tbl td.ptype_name.loc
  in
  let equal_sign = "=" in
  let attrs =
    print_attributes ~state ~loc:td.ptype_loc td.ptype_attributes cmt_tbl
  in
  let prefix =
    if i > 0 then Doc.text "and " else Doc.concat [Doc.text "type "; rec_flag]
  in
  let type_name = name in
  let type_params = print_type_params ~state td.ptype_params cmt_tbl in
  let manifest_and_kind =
    match td.ptype_kind with
    | Ptype_abstract -> (
      match td.ptype_manifest with
      | None -> Doc.nil
      | Some typ ->
        Doc.concat
          [
            Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
            print_private_flag td.ptype_private;
            print_typ_expr ~state typ cmt_tbl;
          ])
    | Ptype_open ->
      Doc.concat
        [
          Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
          print_private_flag td.ptype_private;
          Doc.text "..";
        ]
    | Ptype_record lds ->
      if lds = [] then
        Doc.concat
          [
            Doc.space;
            Doc.text equal_sign;
            Doc.space;
            print_private_flag td.ptype_private;
            Doc.lbrace;
            print_comments_inside cmt_tbl td.ptype_loc;
            Doc.rbrace;
          ]
      else
        let manifest =
          match td.ptype_manifest with
          | None -> Doc.nil
          | Some typ ->
            Doc.concat
              [
                Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
                print_typ_expr ~state typ cmt_tbl;
              ]
        in
        Doc.concat
          [
            manifest;
            Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
            print_private_flag td.ptype_private;
            print_record_declaration ?inline_record_definitions
              ~record_loc:td.ptype_loc ~state lds cmt_tbl;
          ]
    | Ptype_variant cds ->
      let manifest =
        match td.ptype_manifest with
        | None -> Doc.nil
        | Some typ ->
          Doc.concat
            [
              Doc.concat [Doc.space; Doc.text equal_sign; Doc.space];
              print_typ_expr ~state typ cmt_tbl;
            ]
      in
      Doc.concat
        [
          manifest;
          Doc.concat [Doc.space; Doc.text equal_sign];
          print_constructor_declarations ~state ~private_flag:td.ptype_private
            cds cmt_tbl;
        ]
  in
  let constraints = print_type_definition_constraints ~state td.ptype_cstrs in
  Doc.group
    (Doc.concat
       [attrs; prefix; type_name; type_params; manifest_and_kind; constraints])

and print_type_definition_constraints ~state cstrs =
  match cstrs with
  | [] -> Doc.nil
  | cstrs ->
    Doc.indent
      (Doc.group
         (Doc.concat
            [
              Doc.line;
              Doc.group
                (Doc.join ~sep:Doc.line
                   (List.map (print_type_definition_constraint ~state) cstrs));
            ]))

and print_type_definition_constraint ~state
    ((typ1, typ2, _loc) :
      Parsetree.core_type * Parsetree.core_type * Location.t) =
  Doc.concat
    [
      Doc.text "constraint ";
      print_typ_expr ~state typ1 Comment_table.empty;
      Doc.text " = ";
      print_typ_expr ~state typ2 Comment_table.empty;
    ]

and print_private_flag (flag : Asttypes.private_flag) =
  match flag with
  | Private -> Doc.text "private "
  | Public -> Doc.nil

and print_type_params ~state type_params cmt_tbl =
  match type_params with
  | [] -> Doc.nil
  | type_params ->
    Doc.group
      (Doc.concat
         [
           Doc.less_than;
           Doc.indent
             (Doc.concat
                [
                  Doc.soft_line;
                  Doc.join
                    ~sep:(Doc.concat [Doc.comma; Doc.line])
                    (List.map
                       (fun type_param ->
                         let doc = print_type_param ~state type_param cmt_tbl in
                         print_comments doc cmt_tbl
                           (fst type_param).Parsetree.ptyp_loc)
                       type_params);
                ]);
           Doc.trailing_comma;
           Doc.soft_line;
           Doc.greater_than;
         ])

and print_type_param ~state (param : Parsetree.core_type * Asttypes.variance)
    cmt_tbl =
  let typ, variance = param in
  let printed_variance =
    match variance with
    | Covariant -> Doc.text "+"
    | Contravariant -> Doc.text "-"
    | Invariant -> Doc.nil
  in
  Doc.concat [printed_variance; print_typ_expr ~state typ cmt_tbl]

and get_field_start_line (ld : Parsetree.label_declaration) =
  (* For spread fields (...), use the type location instead of pld_loc
     because pld_loc may incorrectly include preceding whitespace *)
  if ld.pld_name.txt = "..." then ld.pld_type.ptyp_loc.loc_start.pos_lnum
  else ld.pld_loc.loc_start.pos_lnum

and print_record_declaration ?check_break_from_loc ?inline_record_definitions
    ?record_loc ~state (lds : Parsetree.label_declaration list) cmt_tbl =
  let force_break =
    match (check_break_from_loc, record_loc, lds) with
    | Some loc, _, _ -> loc.Location.loc_start.pos_lnum < loc.loc_end.pos_lnum
    | None, Some loc, first :: _ ->
      (* Check if first field is on a different line than the opening brace *)
      loc.loc_start.pos_lnum < get_field_start_line first
    | None, None, first :: _ ->
      let last = List.hd (List.rev lds) in
      get_field_start_line first < last.pld_loc.loc_end.pos_lnum
    | _, _, _ -> false
  in
  Doc.breakable_group ~force_break
    (Doc.concat
       [
         Doc.lbrace;
         Doc.indent
           (Doc.concat
              [
                Doc.soft_line;
                Doc.join
                  ~sep:(Doc.concat [Doc.comma; Doc.line])
                  (List.map
                     (fun ld ->
                       let doc =
                         print_label_declaration ?inline_record_definitions
                           ~state ld cmt_tbl
                       in
                       print_comments doc cmt_tbl ld.Parsetree.pld_loc)
                     lds);
              ]);
         Doc.trailing_comma;
         Doc.soft_line;
         Doc.rbrace;
       ])

and collect_literal_dict_rows (e : Parsetree.expression) =
  let tuple_to_row (e : Parsetree.expression) =
    match e with
    | {
     pexp_desc =
       Pexp_tuple
         [{pexp_desc = Pexp_constant (Pconst_string payload); pexp_loc}; value];
    } ->
      let name = String_literal.string_semantic payload in
      Some ((Location.mkloc (Longident.Lident name) pexp_loc, value), e)
    | _ -> None
  in
  match e with
  | {pexp_desc = Pexp_array expressions} ->
    List.filter_map tuple_to_row expressions
  | _ -> []

(* The rows, separated by [","] and a line, without indentation *)
and print_literal_dict_rows ~state rows cmt_tbl =
  Doc.join
    ~sep:(Doc.concat [Doc.text ","; Doc.line])
    (List.map
       (fun ((row, e) :
              (Longident.t Location.loc * Parsetree.expression)
              * Parsetree.expression) ->
         let doc = print_bs_object_row ~state row cmt_tbl in
         print_comments doc cmt_tbl e.pexp_loc)
       rows)

and print_literal_dict_expr ~state (e : Parsetree.expression) cmt_tbl =
  let rows = collect_literal_dict_rows e in
  let rows_doc = print_literal_dict_rows ~state rows cmt_tbl in
  let force_break =
    e.pexp_loc.loc_start.pos_lnum < e.pexp_loc.loc_end.pos_lnum
    || Doc.will_break rows_doc
  in
  if rows = [] then Doc.nil
  else
    Doc.breakable_group ~force_break
      (Doc.concat
         [
           Doc.indent (Doc.concat [Doc.soft_line; rows_doc]);
           Doc.trailing_comma;
           Doc.soft_line;
         ])

(* [...expr] in an array, list or dict. The leading comments of [expr] go
   before the dots, which are part of the spread and not of [expr]. *)
and print_spread_with_comments ~state expr cmt_tbl =
  let leading_comments_doc =
    print_leading_comments Doc.nil cmt_tbl.Comment_table.leading
      expr.Parsetree.pexp_loc
  in
  let doc =
    let doc = print_expression ~state expr cmt_tbl in
    match Parens.expr_allowing_coercion expr with
    | Parens.Parenthesized -> add_parens doc
    | Braced braces -> print_braces doc expr braces
    | Nothing -> doc
  in
  Doc.concat
    [
      leading_comments_doc;
      Doc.dotdotdot;
      print_trailing_comments doc cmt_tbl.Comment_table.trailing
        expr.Parsetree.pexp_loc;
    ]

and print_spread_dict_expr ~state parts (expr : Parsetree.expression) cmt_tbl =
  let print_spread_part spread_expr =
    print_spread_with_comments ~state spread_expr cmt_tbl
  in
  let parts_doc =
    Doc.join
      ~sep:(Doc.concat [Doc.text ","; Doc.line])
      (List.map
         (function
           | Parsetree_viewer.DictExprRows rows_expr ->
             (* Already indented with the spreads *)
             print_literal_dict_rows ~state
               (collect_literal_dict_rows rows_expr)
               cmt_tbl
           | Parsetree_viewer.DictExprSpread spread_expr ->
             print_spread_part spread_expr)
         parts)
  in
  let inside_comments_doc = print_comments_inside cmt_tbl expr.pexp_loc in
  let force_break =
    expr.pexp_loc.loc_start.pos_lnum < expr.pexp_loc.loc_end.pos_lnum
    || Doc.will_break inside_comments_doc
    || Doc.will_break parts_doc
  in
  Doc.breakable_group ~force_break
    (Doc.concat
       [
         Doc.text "dict{";
         inside_comments_doc;
         Doc.indent
           (Doc.concat
              [(if parts = [] then Doc.nil else Doc.soft_line); parts_doc]);
         (if parts = [] then Doc.nil
          else Doc.concat [Doc.trailing_comma; Doc.soft_line]);
         Doc.rbrace;
       ])

and print_constructor_declarations ~state ~private_flag
    (cds : Parsetree.constructor_declaration list) cmt_tbl =
  let force_break =
    match (cds, List.rev cds) with
    | first :: _, last :: _ ->
      first.pcd_loc.loc_start.pos_lnum < last.pcd_loc.loc_end.pos_lnum
    | _ -> false
  in
  let private_flag =
    match private_flag with
    | Asttypes.Private -> Doc.concat [Doc.text "private"; Doc.line]
    | Public -> Doc.nil
  in
  let rows =
    print_listi
      ~get_loc:(fun cd -> cd.Parsetree.pcd_loc)
      ~nodes:cds
      ~print:(fun cd cmt_tbl i ->
        let doc = print_constructor_declaration2 ~state i cd cmt_tbl in
        print_comments doc cmt_tbl cd.Parsetree.pcd_loc)
      ~force_break cmt_tbl ~ignore_empty_lines:true
  in
  Doc.breakable_group ~force_break
    (Doc.indent (Doc.concat [Doc.line; private_flag; rows]))

and print_constructor_declaration2 ~state i
    (cd : Parsetree.constructor_declaration) cmt_tbl =
  let all_attrs = Ast_helper.Type.constructor_attributes cd in
  let comment_attrs, attrs =
    Parsetree_viewer.partition_doc_comment_attributes all_attrs
  in
  let comment_doc =
    match comment_attrs with
    | [] -> Doc.nil
    | comment_attrs ->
      print_doc_comments ~sep:Doc.hard_line ~state cmt_tbl comment_attrs
  in
  let attrs = print_attributes ~state attrs cmt_tbl in
  let is_dot_dot_dot = cd.pcd_name.txt = "..." in
  let bar =
    if i > 0 || all_attrs <> [] || is_dot_dot_dot then Doc.text "| "
    else Doc.if_breaks (Doc.text "| ") Doc.nil
  in
  let constr_name =
    let doc = Doc.text cd.pcd_name.txt in
    print_comments doc cmt_tbl cd.pcd_name.loc
  in
  let constr_args =
    print_constructor_arguments ~is_dot_dot_dot ~name_loc:cd.pcd_name.loc ~state
      ~indent:true cd.pcd_args cmt_tbl
  in
  let gadt =
    match cd.pcd_res with
    | None -> Doc.nil
    | Some typ ->
      Doc.indent (Doc.concat [Doc.text ": "; print_typ_expr ~state typ cmt_tbl])
  in
  Doc.concat
    [
      comment_doc;
      bar;
      Doc.group
        (Doc.concat
           [
             attrs;
             (* TODO: fix parsing of attributes, so when can print them above the bar? *)
             constr_name;
             constr_args;
             gadt;
           ]);
    ]

and print_constructor_arguments ?(is_dot_dot_dot = false) ~name_loc ~state
    ~indent (cd_args : Parsetree.constructor_arguments) cmt_tbl =
  match cd_args with
  | Pcstr_tuple [] -> Doc.nil
  | Pcstr_tuple types ->
    let args =
      Doc.concat
        [
          (if is_dot_dot_dot then Doc.nil else Doc.lparen);
          Doc.indent
            (Doc.concat
               [
                 Doc.soft_line;
                 Doc.join
                   ~sep:(Doc.concat [Doc.comma; Doc.line])
                   (List.map
                      (fun typexpr -> print_typ_expr ~state typexpr cmt_tbl)
                      types);
               ]);
          Doc.trailing_comma;
          Doc.soft_line;
          (if is_dot_dot_dot then Doc.nil else Doc.rparen);
        ]
    in
    Doc.group (if indent then Doc.indent args else args)
  | Pcstr_record lds ->
    let args =
      Doc.concat
        [
          Doc.lparen;
          (* manually inline the print_record_declaration, gives better layout *)
          Doc.lbrace;
          Doc.indent
            (Doc.concat
               [
                 Doc.soft_line;
                 Doc.join
                   ~sep:(Doc.concat [Doc.comma; Doc.line])
                   (List.map
                      (fun ld ->
                        let doc = print_label_declaration ~state ld cmt_tbl in
                        print_comments doc cmt_tbl ld.Parsetree.pld_loc)
                      lds);
               ]);
          Doc.trailing_comma;
          Doc.soft_line;
          Doc.rbrace;
          Doc.rparen;
        ]
    in
    (* Like a record type declaration, keep the inline record multiline when
       the first field starts on a later line than the constructor name. *)
    let force_break =
      match lds with
      | first :: _ ->
        name_loc.Location.loc_end.pos_lnum < get_field_start_line first
      | [] -> false
    in
    Doc.breakable_group ~force_break (if indent then Doc.indent args else args)

and print_label_declaration ?inline_record_definitions ~state
    (ld : Parsetree.label_declaration) cmt_tbl =
  let attrs =
    (* The runtime name is held as a field rather than an attribute, so put its
       surface syntax back. *)
    print_attributes ~state ~loc:ld.pld_name.loc
      (Ast_helper.Type.field_attributes ld)
      cmt_tbl
  in
  let mutable_flag =
    match ld.pld_mutable with
    | Mutable -> Doc.text "mutable "
    | Immutable -> Doc.nil
  in
  let name, is_dot =
    let doc, is_dot =
      if ld.pld_name.txt = "..." then (Doc.text ld.pld_name.txt, true)
      else (print_ident_like ld.pld_name.txt, false)
    in
    (print_comments doc cmt_tbl ld.pld_name.loc, is_dot)
  in
  let optional = if ld.pld_optional then Doc.text "?" else Doc.nil in
  Doc.group
    (Doc.concat
       [
         attrs;
         mutable_flag;
         name;
         optional;
         (if is_dot then Doc.nil else Doc.text ": ");
         print_typ_expr ?inline_record_definitions ~state ld.pld_type cmt_tbl;
       ])

and print_typ_expr ?inline_record_definitions ~(state : State.t)
    (typ_expr : Parsetree.core_type) cmt_tbl =
  let print_arrow typ_expr =
    let attrs_before, args, return_type =
      Parsetree_viewer.arrow_type typ_expr
    in
    let return_type_needs_parens =
      match return_type.ptyp_desc with
      | Ptyp_alias _ -> true
      | _ -> false
    in
    let return_doc =
      let doc =
        print_typ_expr ?inline_record_definitions ~state return_type cmt_tbl
      in
      if return_type_needs_parens then Doc.concat [Doc.lparen; doc; Doc.rparen]
      else doc
    in
    match args with
    | [] -> Doc.nil
    | [
     (( Parg_type {attrs = []; lbl = Nolabel}
      | Parg_fixed {attrs = []; lbl = Nolabel} ) as arg);
    ] ->
      let has_attrs_before = not (attrs_before = []) in
      let attrs =
        if has_attrs_before then
          print_attributes ~state ~inline:true attrs_before cmt_tbl
        else Doc.nil
      in
      let typ_doc =
        match arg with
        | Parg_type {typ} -> (
          let doc =
            print_typ_expr ?inline_record_definitions ~state typ cmt_tbl
          in
          match typ.ptyp_desc with
          | Ptyp_arrow _ | Ptyp_tuple _ | Ptyp_alias _ -> add_parens doc
          | _ -> doc)
        | Parg_fixed _ ->
          print_type_parameter ?inline_record_definitions ~state arg cmt_tbl
      in
      Doc.group
        (Doc.concat
           [
             Doc.group attrs;
             Doc.group
               (if has_attrs_before then
                  Doc.concat
                    [
                      Doc.lparen;
                      Doc.indent
                        (Doc.concat
                           [Doc.soft_line; typ_doc; Doc.text " => "; return_doc]);
                      Doc.soft_line;
                      Doc.rparen;
                    ]
                else Doc.concat [typ_doc; Doc.text " => "; return_doc]);
           ])
    | args ->
      let attrs = print_attributes ~state ~inline:true attrs_before cmt_tbl in
      let rendered_args =
        Doc.concat
          [
            attrs;
            Doc.text "(";
            Doc.indent
              (Doc.concat
                 [
                   Doc.soft_line;
                   Doc.join
                     ~sep:(Doc.concat [Doc.comma; Doc.line])
                     (List.map
                        (fun tp ->
                          print_type_parameter ?inline_record_definitions ~state
                            tp cmt_tbl)
                        args);
                 ]);
            Doc.trailing_comma;
            Doc.soft_line;
            Doc.text ")";
          ]
      in
      Doc.group (Doc.concat [rendered_args; Doc.text " => "; return_doc])
  in
  let rendered_type =
    match typ_expr.ptyp_desc with
    | Ptyp_any -> Doc.text "_"
    | Ptyp_var var ->
      Doc.concat [Doc.text "'"; print_ident_like ~allow_uident:true var]
    | Ptyp_extension extension ->
      print_extension ~state ~at_module_lvl:false extension cmt_tbl
    | Ptyp_alias (typ, alias) ->
      let typ =
        (* Technically type t = (string, float) => unit as 'x, doesn't require
         * parens around the arrow expression. This is very confusing though.
         * Is the "as" part of "unit" or "(string, float) => unit". By printing
         * parens we guide the user towards its meaning.*)
        let needs_parens =
          match typ.ptyp_desc with
          | Ptyp_arrow _ -> true
          | _ -> false
        in
        let doc =
          print_typ_expr ?inline_record_definitions ~state typ cmt_tbl
        in
        if needs_parens then Doc.concat [Doc.lparen; doc; Doc.rparen] else doc
      in
      Doc.concat
        [
          typ; Doc.text " as "; Doc.concat [Doc.text "'"; print_ident_like alias];
        ]
    (* object printings *)
    | Ptyp_object (fields, open_flag) ->
      print_object ~state ~inline:false fields open_flag cmt_tbl
    | Ptyp_arrow _ -> print_arrow typ_expr
    | Ptyp_constr ({txt = Lident inline_record_name}, _)
      when inline_record_definitions
           |> find_inline_record_definition inline_record_name
           |> Option.is_some -> (
      match
        inline_record_definitions
        |> find_inline_record_definition inline_record_name
      with
      | Some {ptype_kind = Ptype_record lds; ptype_loc} ->
        print_record_declaration ~check_break_from_loc:ptype_loc
          ~inline_record_definitions:(inline_record_definitions |> Option.get)
          ~state lds cmt_tbl
      | _ -> assert false)
    | Ptyp_constr
        (longident_loc, [{ptyp_desc = Ptyp_object (fields, open_flag)}]) ->
      (* for foo<{"a": b}>, when the object is long and needs a line break, we
         want the <{ and }> to stay hugged together *)
      let constr_name = print_lident_path longident_loc cmt_tbl in
      Doc.concat
        [
          constr_name;
          Doc.less_than;
          print_object ~state ~inline:true fields open_flag cmt_tbl;
          Doc.greater_than;
        ]
    | Ptyp_constr (longident_loc, [{ptyp_desc = Parsetree.Ptyp_tuple tuple}]) ->
      let constr_name = print_lident_path longident_loc cmt_tbl in
      Doc.group
        (Doc.concat
           [
             constr_name;
             Doc.less_than;
             print_tuple_type ?inline_record_definitions ~state ~inline:true
               tuple cmt_tbl;
             Doc.greater_than;
           ])
    | Ptyp_constr (longident_loc, constr_args) -> (
      let constr_name = print_lident_path longident_loc cmt_tbl in
      match constr_args with
      | [] -> constr_name
      | _args ->
        Doc.group
          (Doc.concat
             [
               constr_name;
               Doc.less_than;
               Doc.indent
                 (Doc.concat
                    [
                      Doc.soft_line;
                      Doc.join
                        ~sep:(Doc.concat [Doc.comma; Doc.line])
                        (List.map
                           (fun typexpr ->
                             print_typ_expr ?inline_record_definitions ~state
                               typexpr cmt_tbl)
                           constr_args);
                    ]);
               Doc.trailing_comma;
               Doc.soft_line;
               Doc.greater_than;
             ]))
    | Ptyp_tuple types ->
      print_tuple_type ?inline_record_definitions ~state ~inline:false types
        cmt_tbl
    | Ptyp_poly ([], typ) ->
      print_typ_expr ?inline_record_definitions ~state typ cmt_tbl
    | Ptyp_poly (string_locs, typ) ->
      Doc.concat
        [
          Doc.join ~sep:Doc.space
            (List.map
               (fun {Location.txt; loc} ->
                 let doc = Doc.concat [Doc.text "'"; Doc.text txt] in
                 print_comments doc cmt_tbl loc)
               string_locs);
          Doc.dot;
          Doc.space;
          print_typ_expr ?inline_record_definitions ~state typ cmt_tbl;
        ]
    | Ptyp_package package_type ->
      print_package_type ~state ~print_module_keyword_and_parens:true
        package_type cmt_tbl
    | Ptyp_variant (row_fields, closed_flag, labels_opt) ->
      let force_break =
        typ_expr.ptyp_loc.Location.loc_start.pos_lnum
        < typ_expr.ptyp_loc.loc_end.pos_lnum
      in
      let print_row_field i = function
        | Parsetree.Rtag ({txt; loc}, attrs, true, []) ->
          let comment_attrs, attrs =
            Parsetree_viewer.partition_doc_comment_attributes attrs
          in
          let comment_doc =
            match comment_attrs with
            | [] -> Doc.nil
            | comment_attrs ->
              print_doc_comments ~sep:Doc.hard_line ~state cmt_tbl comment_attrs
          in
          let bar =
            if i > 0 || comment_attrs <> [] then Doc.text "| "
            else Doc.if_breaks (Doc.text "| ") Doc.nil
          in
          let tag_doc =
            Doc.group
              (Doc.concat
                 [
                   print_attributes ~state attrs cmt_tbl;
                   Doc.concat [Doc.text "#"; print_poly_var_ident txt];
                 ])
          in
          Doc.concat [comment_doc; bar; print_comments tag_doc cmt_tbl loc]
        | Rtag ({txt; loc}, attrs, truth, types) ->
          let comment_attrs, attrs =
            Parsetree_viewer.partition_doc_comment_attributes attrs
          in
          let comment_doc =
            match comment_attrs with
            | [] -> Doc.nil
            | comment_attrs ->
              print_doc_comments ~sep:Doc.hard_line ~state cmt_tbl comment_attrs
          in
          let bar =
            if i > 0 || comment_attrs <> [] then Doc.text "| "
            else Doc.if_breaks (Doc.text "| ") Doc.nil
          in
          let do_group {Location.txt = types} =
            Doc.concat
              [
                Doc.lparen;
                Doc.join
                  ~sep:(Doc.concat [Doc.comma; Doc.line])
                  (List.map
                     (fun typ ->
                       print_typ_expr ?inline_record_definitions ~state typ
                         cmt_tbl)
                     types);
                Doc.rparen;
              ]
          in
          let printed_types = List.map do_group types in
          let cases =
            Doc.join ~sep:(Doc.concat [Doc.line; Doc.text "& "]) printed_types
          in
          let cases =
            if truth then Doc.concat [Doc.line; Doc.text "& "; cases] else cases
          in
          let tag_doc =
            Doc.group
              (Doc.concat
                 [
                   print_attributes ~state attrs cmt_tbl;
                   Doc.concat [Doc.text "#"; print_poly_var_ident txt];
                   cases;
                 ])
          in
          Doc.concat [comment_doc; bar; print_comments tag_doc cmt_tbl loc]
        | Rinherit core_type ->
          let bar =
            if i > 0 then Doc.text "| "
            else Doc.if_breaks (Doc.text "| ") Doc.nil
          in
          Doc.concat
            [
              bar;
              print_typ_expr ?inline_record_definitions ~state core_type cmt_tbl;
            ]
      in
      let docs = List.mapi print_row_field row_fields in
      let cases = Doc.join ~sep:Doc.line docs in
      let opening_symbol =
        if closed_flag = Open then Doc.concat [Doc.greater_than; Doc.line]
        else if labels_opt = None then Doc.soft_line
        else Doc.concat [Doc.less_than; Doc.line]
      in
      let labels =
        match labels_opt with
        | None | Some [] -> Doc.nil
        | Some labels ->
          Doc.concat
            (List.map
               (fun label ->
                 Doc.concat [Doc.line; Doc.text "#"; print_poly_var_ident label])
               labels)
      in
      let closing_symbol =
        match labels_opt with
        | None | Some [] -> Doc.nil
        | _ -> Doc.text " >"
      in
      Doc.breakable_group ~force_break
        (Doc.concat
           [
             Doc.lbracket;
             Doc.indent
               (Doc.concat [opening_symbol; cases; closing_symbol; labels]);
             Doc.soft_line;
             Doc.rbracket;
           ])
  in
  let should_print_its_own_attributes =
    match typ_expr.ptyp_desc with
    | Ptyp_arrow _ (* es6 arrow types print their own attributes *) -> true
    | _ -> false
  in
  let doc =
    match typ_expr.ptyp_attributes with
    | _ :: _ as attrs when not should_print_its_own_attributes ->
      let doc_comment_attr, attrs =
        Parsetree_viewer.partition_doc_comment_attributes attrs
      in
      let comment_doc =
        match doc_comment_attr with
        | [] -> Doc.nil
        | _ -> print_doc_comments ~state ~sep:Doc.space cmt_tbl doc_comment_attr
      in
      let attrs_doc =
        match attrs with
        | [] -> Doc.nil
        | _ -> print_attributes ~state attrs cmt_tbl
      in
      Doc.group (Doc.concat [comment_doc; attrs_doc; rendered_type])
    | _ -> rendered_type
  in
  print_comments doc cmt_tbl typ_expr.ptyp_loc

and print_object ~state ~inline fields open_flag cmt_tbl =
  let doc =
    match fields with
    | [] ->
      Doc.concat
        [
          Doc.lbrace;
          (match open_flag with
          | Asttypes.Closed -> Doc.dot
          | Open -> Doc.dotdot);
          Doc.rbrace;
        ]
    | fields ->
      Doc.concat
        [
          Doc.lbrace;
          (match open_flag with
          | Asttypes.Closed -> Doc.nil
          | Open -> (
            match fields with
            (* handle `type t = {.. ...objType, "x": int}`
             * .. and ... should have a space in between *)
            | Oinherit _ :: _ -> Doc.text ".. "
            | _ -> Doc.dotdot));
          Doc.indent
            (Doc.concat
               [
                 Doc.soft_line;
                 Doc.join
                   ~sep:(Doc.concat [Doc.comma; Doc.line])
                   (List.map
                      (fun field -> print_object_field ~state field cmt_tbl)
                      fields);
               ]);
          Doc.trailing_comma;
          Doc.soft_line;
          Doc.rbrace;
        ]
  in
  if inline then doc else Doc.group doc

and print_tuple_type ?inline_record_definitions ~state ~inline
    (types : Parsetree.core_type list) cmt_tbl =
  let tuple =
    Doc.concat
      [
        Doc.lparen;
        Doc.indent
          (Doc.concat
             [
               Doc.soft_line;
               Doc.join
                 ~sep:(Doc.concat [Doc.comma; Doc.line])
                 (List.map
                    (fun typexpr ->
                      print_typ_expr ?inline_record_definitions ~state typexpr
                        cmt_tbl)
                    types);
             ]);
        Doc.trailing_comma;
        Doc.soft_line;
        Doc.rparen;
      ]
  in
  if inline == false then Doc.group tuple else tuple

and print_object_field ~state (field : Parsetree.object_field) cmt_tbl =
  match field with
  | Otag (label_loc, attrs, typ) ->
    let lbl =
      let doc = Doc.text ("\"" ^ label_loc.txt ^ "\"") in
      print_comments doc cmt_tbl label_loc.loc
    in
    let doc =
      Doc.concat
        [
          print_attributes ~state ~loc:label_loc.loc attrs cmt_tbl;
          lbl;
          Doc.text ": ";
          print_typ_expr ~state typ cmt_tbl;
        ]
    in
    let cmt_loc = {label_loc.loc with loc_end = typ.ptyp_loc.loc_end} in
    print_comments doc cmt_tbl cmt_loc
  | Oinherit typexpr ->
    Doc.concat [Doc.dotdotdot; print_typ_expr ~state typexpr cmt_tbl]

(* es6 arrow type arg
 * type t = (~foo: string, ~bar: float=?, unit) => unit
 * i.e. ~foo: string, ~bar: float *)
and print_type_parameter ?inline_record_definitions ~state parameter cmt_tbl =
  let attrs, lbl, value_doc, end_loc =
    match parameter with
    | Parsetree.Parg_type {attrs; lbl; typ} ->
      ( attrs,
        lbl,
        print_typ_expr ?inline_record_definitions ~state typ cmt_tbl,
        typ.ptyp_loc )
    | Parsetree.Parg_fixed {attrs; lbl; value; loc} ->
      (* Comments go around [@as(...) _], as for the [_] it is written with. *)
      let loc = Ast_fixed_arg.underscore_loc loc in
      let as_doc, _ =
        print_attribute ~state
          (Ast_fixed_arg.to_attribute {value with loc = Location.none})
          cmt_tbl
      in
      ( attrs,
        lbl,
        print_comments
          (Doc.group (Doc.concat [as_doc; Doc.space; Doc.text "_"]))
          cmt_tbl loc,
        loc )
  in
  (* Converting .ml code to .res requires processing uncurried attributes *)
  let attrs = print_attributes ~state attrs cmt_tbl in
  let label =
    match lbl with
    | Asttypes.Nolabel -> Doc.nil
    | Labelled {txt = lbl} ->
      Doc.concat [Doc.text "~"; print_ident_like lbl; Doc.text ": "]
    | Optional {txt = lbl} ->
      Doc.concat [Doc.text "~"; print_ident_like lbl; Doc.text ": "]
  in
  let optional_indicator =
    match lbl with
    | Nolabel | Labelled _ -> Doc.nil
    | Optional _ -> Doc.text "=?"
  in
  let loc = {(Asttypes.get_lbl_loc lbl) with loc_end = end_loc.loc_end} in
  let doc = Doc.group (Doc.concat [attrs; label; value_doc]) in
  (* [loc] ends before [=?]. *)
  print_comments_before_marker doc cmt_tbl loc optional_indicator

and print_value_binding ~state ~rec_flag (vb : Parsetree.value_binding) cmt_tbl
    i =
  let has_unwrap = ref false in
  let attrs =
    Ast_helper.Vb.binding_attributes vb
    |> List.filter_map (function
      | {Asttypes.txt = "let.unwrap"}, _ ->
        has_unwrap := true;
        None
      | attr -> Some attr)
  in
  let attrs = print_attributes ~state ~loc:vb.pvb_pat.ppat_loc attrs cmt_tbl in
  let header =
    if i == 0 then
      Doc.concat [Doc.text (if !has_unwrap then "let? " else "let "); rec_flag]
    else Doc.text "and "
  in
  match vb with
  | {
   pvb_pat = pattern;
   pvb_expr = expr;
   pvb_constraint = Some {pvc_newtypes; pvc_type};
  } ->
    let newtypes =
      Doc.join ~sep:Doc.space
        (List.map
           (fun ({Asttypes.txt; loc} : string Asttypes.loc) ->
             print_comments (print_ident_like txt) cmt_tbl loc)
           pvc_newtypes)
    in
    let pattern_doc = print_pattern ~state pattern cmt_tbl in
    let typ_doc = print_typ_expr ~state pvc_type cmt_tbl in
    let expr_doc =
      print_expression_with_comments_and_parens ~state expr cmt_tbl
    in
    (* Keep `let f: type a. t = body` on one line up to the body's first
       line break when it fits; otherwise break after `:` and `=`. The
       attributes stay outside, so that [fits] measures from the `let`. *)
    Doc.concat
      [
        attrs;
        Doc.custom_layout
          [
            (* not a group: a group would be marked broken by the body's line
               breaks, and [fits] would then accept a header that overflows *)
            Doc.concat
              [
                header;
                pattern_doc;
                Doc.text ": type ";
                newtypes;
                Doc.dot;
                Doc.space;
                typ_doc;
                Doc.text " = ";
                expr_doc;
              ];
            Doc.group
              (Doc.concat
                 [
                   header;
                   pattern_doc;
                   Doc.text ":";
                   Doc.indent
                     (Doc.concat
                        [
                          Doc.line;
                          Doc.text "type ";
                          newtypes;
                          Doc.dot;
                          Doc.space;
                          typ_doc;
                          Doc.text " =";
                          Doc.line;
                          expr_doc;
                        ]);
                 ]);
          ];
      ]
  | {
   pvb_pat =
     {
       ppat_desc =
         Ppat_constraint (pattern, ({ptyp_desc = Ptyp_poly _} as pat_typ));
     };
   pvb_expr = {pexp_desc = Pexp_fun {newtypes = _ :: _}} as expr;
  } -> (
    let _, parameters, return_expr = Parsetree_viewer.fun_expr expr in
    let abstract_type =
      match parameters with
      | [NewTypes {locs = vars}] ->
        Doc.concat
          [
            Doc.text "type ";
            Doc.join ~sep:Doc.space
              (List.map (fun var -> Doc.text var.Asttypes.txt) vars);
            Doc.dot;
          ]
      | _ -> Doc.nil
    in
    match return_expr.pexp_desc with
    | Pexp_constraint (expr, typ) ->
      Doc.group
        (Doc.concat
           [
             attrs;
             header;
             print_pattern ~state pattern cmt_tbl;
             Doc.text ":";
             Doc.indent
               (Doc.concat
                  [
                    Doc.line;
                    abstract_type;
                    Doc.space;
                    print_typ_expr ~state typ cmt_tbl;
                    Doc.text " =";
                    Doc.concat
                      [
                        Doc.line;
                        print_expression_with_comments_and_parens ~state expr
                          cmt_tbl;
                      ];
                  ]);
           ])
    | _ ->
      (* Example:
       * let cancel_and_collect_callbacks:
       *   'a 'u 'c. (list<packed_callbacks>, promise<'a, 'u, 'c>) => list<packed_callbacks> =         *  (type x, callbacks_accumulator, p: promise<_, _, c>)
       *)
      Doc.group
        (Doc.concat
           [
             attrs;
             header;
             print_pattern ~state pattern cmt_tbl;
             Doc.text ":";
             Doc.indent
               (Doc.concat
                  [
                    Doc.line;
                    abstract_type;
                    Doc.space;
                    print_typ_expr ~state pat_typ cmt_tbl;
                    Doc.text " =";
                    Doc.concat
                      [
                        Doc.line;
                        print_expression_with_comments_and_parens ~state expr
                          cmt_tbl;
                      ];
                  ]);
           ]))
  | _ ->
    let opt_braces, expr = Parsetree_viewer.process_braces vb.pvb_expr in
    let printed_expr =
      let doc = print_expression_with_comments ~state vb.pvb_expr cmt_tbl in
      match Parens.expr vb.pvb_expr with
      | Parens.Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc expr braces
      | Nothing -> doc
    in
    let pattern_has_trailing_line_comment =
      has_any_trailing_line_comment cmt_tbl vb.pvb_pat.ppat_loc
    in
    let pattern_doc = print_pattern ~state vb.pvb_pat cmt_tbl in
    let equal_doc =
      if pattern_has_trailing_line_comment then
        Doc.indent (Doc.concat [Doc.hard_line; Doc.equal])
      else Doc.text " ="
    in
    (*
     * we want to optimize the layout of one pipe:
     *   let tbl = data->Array.reduce((map, curr) => {
     *     ...
     *   })
     * important is that we don't do this for multiple pipes:
     *   let decoratorTags =
     *     items
     *     ->Array.filter(items => {items.category === Decorators})
     *     ->Array.map(...)
     * Multiple pipes chained together lend themselves more towards the last layout.
     *)
    if Parsetree_viewer.is_single_pipe_expr vb.pvb_expr then
      Doc.custom_layout
        [
          Doc.group
            (Doc.concat
               [attrs; header; pattern_doc; equal_doc; Doc.space; printed_expr]);
          Doc.group
            (Doc.concat
               [
                 attrs;
                 header;
                 pattern_doc;
                 equal_doc;
                 Doc.indent (Doc.concat [Doc.line; printed_expr]);
               ]);
        ]
    else
      let should_indent =
        match opt_braces with
        | Some _ -> false
        | _ -> (
          Parsetree_viewer.is_binary_expression expr
          ||
          match vb.pvb_expr with
          | {pexp_attributes = []; pexp_desc = Pexp_ternary (if_expr, _, _)} ->
            Parsetree_viewer.is_binary_expression if_expr
            || if_expr.pexp_attributes <> []
          | {pexp_desc = Pexp_tagged_template _} -> false
          | {pexp_desc = Pexp_jsx_element _} -> true
          | e -> e.pexp_attributes <> [] || Parsetree_viewer.is_array_access e)
      in
      Doc.group
        (Doc.concat
           [
             attrs;
             header;
             pattern_doc;
             equal_doc;
             (if should_indent then
                Doc.indent (Doc.concat [Doc.line; printed_expr])
              else Doc.concat [Doc.space; printed_expr]);
           ])

and print_package_type ~state ~print_module_keyword_and_parens
    (package_type : Parsetree.package_type) cmt_tbl =
  let doc =
    match package_type with
    | longident_loc, [] ->
      Doc.group (Doc.concat [print_longident_location longident_loc cmt_tbl])
    | longident_loc, package_constraints ->
      Doc.group
        (Doc.concat
           [
             print_longident_location longident_loc cmt_tbl;
             print_package_constraints ~state package_constraints cmt_tbl;
             Doc.soft_line;
           ])
  in
  if print_module_keyword_and_parens then
    Doc.concat [Doc.text "module("; doc; Doc.rparen]
  else doc

and print_package_constraints ~state package_constraints cmt_tbl =
  Doc.concat
    [
      Doc.text " with";
      Doc.indent
        (Doc.concat
           [
             Doc.line;
             Doc.join ~sep:Doc.line
               (List.mapi
                  (fun i pc ->
                    let longident, typexpr = pc in
                    let cmt_loc =
                      {
                        longident.Asttypes.loc with
                        loc_end = typexpr.Parsetree.ptyp_loc.loc_end;
                      }
                    in
                    let doc = print_package_constraint ~state i cmt_tbl pc in
                    print_comments doc cmt_tbl cmt_loc)
                  package_constraints);
           ]);
    ]

and print_package_constraint ~state i cmt_tbl (longident_loc, typ) =
  let prefix = if i == 0 then Doc.text "type " else Doc.text "and type " in
  Doc.concat
    [
      prefix;
      print_longident_location longident_loc cmt_tbl;
      Doc.text " = ";
      print_typ_expr ~state typ cmt_tbl;
    ]

and print_extension ~state ~at_module_lvl (string_loc, payload) cmt_tbl =
  let txt = string_loc.Location.txt in
  let ext_name =
    let doc =
      Doc.concat
        [
          Doc.text "%";
          (if at_module_lvl then Doc.text "%" else Doc.nil);
          Doc.text txt;
        ]
    in
    print_comments doc cmt_tbl string_loc.Location.loc
  in
  Doc.group (Doc.concat [ext_name; print_payload ~state payload cmt_tbl])

and print_pattern_args ~state (patterns : Parsetree.pattern list) cmt_tbl =
  match patterns with
  | [] -> Doc.nil
  | [
   {
     ppat_loc;
     ppat_desc = Ppat_construct ({txt = Longident.Lident "()"}, _);
     ppat_attributes = [];
   };
  ] ->
    Doc.concat [Doc.lparen; print_comments_inside cmt_tbl ppat_loc; Doc.rparen]
  | [{ppat_desc = Ppat_tuple []; ppat_loc = loc}] ->
    Doc.concat [Doc.lparen; print_comments_inside cmt_tbl loc; Doc.rparen]
  | _ :: _ :: _ ->
    Doc.concat
      [
        Doc.lparen;
        Doc.indent
          (Doc.concat
             [
               Doc.soft_line;
               Doc.join
                 ~sep:(Doc.concat [Doc.comma; Doc.line])
                 (List.map
                    (fun pat -> print_pattern ~state pat cmt_tbl)
                    patterns);
             ]);
        Doc.trailing_comma;
        Doc.soft_line;
        Doc.rparen;
      ]
  | [arg] ->
    let arg_doc = print_pattern ~state arg cmt_tbl in
    let should_hug = Parsetree_viewer.is_huggable_pattern arg in
    Doc.concat
      [
        Doc.lparen;
        (if should_hug then arg_doc
         else
           Doc.concat
             [
               Doc.indent (Doc.concat [Doc.soft_line; arg_doc]);
               Doc.trailing_comma;
               Doc.soft_line;
             ]);
        Doc.rparen;
      ]

and print_pattern ~state (p : Parsetree.pattern) cmt_tbl =
  let pattern_without_attributes =
    match p.ppat_desc with
    | Ppat_any -> Doc.text "_"
    | Ppat_var var -> print_ident_like var.txt
    | Ppat_constant c -> print_constant c
    | Ppat_tuple patterns ->
      Doc.group
        (Doc.concat
           [
             Doc.lparen;
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    Doc.join
                      ~sep:(Doc.concat [Doc.text ","; Doc.line])
                      (List.map
                         (fun pat -> print_pattern ~state pat cmt_tbl)
                         patterns);
                  ]);
             Doc.trailing_comma;
             Doc.soft_line;
             Doc.rparen;
           ])
    | Ppat_array [] ->
      Doc.concat
        [Doc.lbracket; print_comments_inside cmt_tbl p.ppat_loc; Doc.rbracket]
    | Ppat_array patterns ->
      Doc.group
        (Doc.concat
           [
             Doc.text "[";
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    Doc.join
                      ~sep:(Doc.concat [Doc.text ","; Doc.line])
                      (List.map
                         (fun pat -> print_pattern ~state pat cmt_tbl)
                         patterns);
                  ]);
             Doc.trailing_comma;
             Doc.soft_line;
             Doc.text "]";
           ])
    | Ppat_construct ({txt = Longident.Lident "()"}, _) ->
      Doc.concat
        [Doc.lparen; print_comments_inside cmt_tbl p.ppat_loc; Doc.rparen]
    | Ppat_construct ({txt = Longident.Lident "[]"}, _) ->
      Doc.concat
        [Doc.text "list{"; print_comments_inside cmt_tbl p.ppat_loc; Doc.rbrace]
    | Ppat_construct ({txt = Longident.Lident "::"}, _) ->
      let patterns, tail =
        Parsetree_viewer.collect_patterns_from_list_construct [] p
      in
      let should_hug =
        match (patterns, tail) with
        | [pat], {ppat_desc = Ppat_construct ({txt = Longident.Lident "[]"}, _)}
          when Parsetree_viewer.is_huggable_pattern pat ->
          true
        | _ -> false
      in
      let children =
        Doc.concat
          [
            (if should_hug then Doc.nil else Doc.soft_line);
            Doc.join
              ~sep:(Doc.concat [Doc.text ","; Doc.line])
              (List.map (fun pat -> print_pattern ~state pat cmt_tbl) patterns);
            (match tail.Parsetree.ppat_desc with
            | Ppat_construct ({txt = Longident.Lident "[]"}, _) -> Doc.nil
            | _ ->
              (* Taken before [print_pattern] prints the other comments *)
              let leading =
                print_leading_comments Doc.nil cmt_tbl.leading tail.ppat_loc
              in
              Doc.concat
                [
                  Doc.text ",";
                  Doc.line;
                  leading;
                  Doc.text "...";
                  print_pattern ~state tail cmt_tbl;
                ]);
          ]
      in
      Doc.group
        (Doc.concat
           [
             Doc.text "list{";
             (if should_hug then children
              else
                Doc.concat
                  [
                    Doc.indent children;
                    Doc.if_breaks (Doc.text ",") Doc.nil;
                    Doc.soft_line;
                  ]);
             Doc.rbrace;
           ])
    | Ppat_construct (constr_name, {txt = constructor_args}) ->
      let constr_name = print_longident_location constr_name cmt_tbl in
      let args_doc = print_pattern_args ~state constructor_args cmt_tbl in
      Doc.group (Doc.concat [constr_name; args_doc])
    | Ppat_variant (label, {txt = variant_args}) ->
      let variant_name =
        Doc.concat [Doc.text "#"; print_poly_var_ident label]
      in
      let args_doc = print_pattern_args ~state variant_args cmt_tbl in
      Doc.group (Doc.concat [variant_name; args_doc])
    | Ppat_variant_spread ident ->
      Doc.concat [Doc.text "..."; print_ident_path ident cmt_tbl]
    | Ppat_type ident ->
      Doc.concat [Doc.text "#..."; print_ident_path ident cmt_tbl]
    | Ppat_dict [] ->
      Doc.concat
        [Doc.text "dict{"; print_comments_inside cmt_tbl p.ppat_loc; Doc.rbrace]
    | Ppat_dict rows ->
      (* Its own group, as when it was a record pattern with an attribute *)
      Doc.group
        (Doc.concat
           [
             Doc.text "dict{";
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    Doc.join
                      ~sep:(Doc.concat [Doc.text ","; Doc.line])
                      (Ext_list.map rows (fun row ->
                           print_pattern_dict_row ~state row cmt_tbl));
                  ]);
             Doc.if_breaks (Doc.text ",") Doc.nil;
             Doc.soft_line;
             Doc.rbrace;
           ])
    | Ppat_record ([], Open, None) ->
      Doc.concat [Doc.lbrace; Doc.text "_"; Doc.rbrace]
    | Ppat_record (rows, open_flag, rest) ->
      let print_rest_pattern rest_pat =
        let doc =
          match rest_pat.Parsetree.rest_type with
          | Some typ ->
            Doc.concat
              [
                Doc.text "...";
                print_typ_expr ~state typ cmt_tbl;
                Doc.text " as ";
                print_string_loc rest_pat.rest_name cmt_tbl;
              ]
          | None ->
            Doc.concat
              [Doc.text "..."; print_string_loc rest_pat.rest_name cmt_tbl]
        in
        print_comments doc cmt_tbl rest_pat.rest_loc
      in
      Doc.group
        (Doc.concat
           [
             Doc.lbrace;
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    Doc.join
                      ~sep:(Doc.concat [Doc.text ","; Doc.line])
                      (List.map
                         (fun row ->
                           print_pattern_record_row ~state row cmt_tbl)
                         rows);
                    (match rest with
                    | Some rest_pat ->
                      Doc.concat
                        [
                          (if rows <> [] then Doc.concat [Doc.text ","; Doc.line]
                           else Doc.nil);
                          print_rest_pattern rest_pat;
                        ]
                    | None -> (
                      match open_flag with
                      | Open ->
                        Doc.concat [Doc.text ","; Doc.line; Doc.text "_"]
                      | Closed -> Doc.nil));
                  ]);
             Doc.if_breaks (Doc.text ",") Doc.nil;
             Doc.soft_line;
             Doc.rbrace;
           ])
    | Ppat_exception p ->
      let needs_parens =
        match p.ppat_desc with
        | Ppat_or (_, _) | Ppat_alias (_, _) -> true
        | _ -> false
      in
      let pat =
        let p = print_pattern ~state p cmt_tbl in
        if needs_parens then Doc.concat [Doc.text "("; p; Doc.text ")"] else p
      in
      Doc.group (Doc.concat [Doc.text "exception"; Doc.line; pat])
    | Ppat_or _ ->
      (* Blue | Red | Green -> [Blue; Red; Green] *)
      let or_chain = Parsetree_viewer.collect_or_pattern_chain p in
      let docs =
        List.mapi
          (fun i pat ->
            let pattern_doc = print_pattern ~state pat cmt_tbl in
            Doc.concat
              [
                (if i == 0 then Doc.nil else Doc.concat [Doc.line; Doc.text "| "]);
                (match pat.ppat_desc with
                (* (Blue | Red) | (Green | Black) | White *)
                | Ppat_or _ -> add_parens pattern_doc
                | _ -> pattern_doc);
              ])
          or_chain
      in
      let is_spread_over_multiple_lines =
        match (or_chain, List.rev or_chain) with
        | first :: _, last :: _ ->
          first.ppat_loc.loc_start.pos_lnum < last.ppat_loc.loc_end.pos_lnum
        | _ -> false
      in
      Doc.breakable_group ~force_break:is_spread_over_multiple_lines
        (Doc.concat docs)
    | Ppat_extension ext ->
      print_extension ~state ~at_module_lvl:false ext cmt_tbl
    | Ppat_alias (p, alias_loc) ->
      let needs_parens =
        match p.ppat_desc with
        | Ppat_or (_, _) | Ppat_alias (_, _) -> true
        (* Attributes before [x as z] belong to the alias *)
        | _ -> p.ppat_attributes <> []
      in
      let rendered_pattern =
        let p = print_pattern ~state p cmt_tbl in
        if needs_parens then Doc.concat [Doc.text "("; p; Doc.text ")"] else p
      in
      Doc.concat
        [rendered_pattern; Doc.text " as "; print_string_loc alias_loc cmt_tbl]
    (* Note: module(P : S) is represented as *)
    (* Ppat_constraint(Ppat_unpack, Ptyp_package) *)
    | Ppat_constraint
        ( {ppat_desc = Ppat_unpack string_loc},
          {ptyp_desc = Ptyp_package package_type; ptyp_loc} ) ->
      Doc.concat
        [
          Doc.text "module(";
          print_comments (Doc.text string_loc.txt) cmt_tbl string_loc.loc;
          Doc.text ": ";
          print_comments
            (print_package_type ~state ~print_module_keyword_and_parens:false
               package_type cmt_tbl)
            cmt_tbl ptyp_loc;
          Doc.rparen;
        ]
    | Ppat_constraint (pattern, typ) ->
      Doc.concat
        [
          print_pattern ~state pattern cmt_tbl;
          Doc.text ": ";
          print_typ_expr ~state typ cmt_tbl;
        ]
    (* Note: module(P : S) is represented as *)
    (* Ppat_constraint(Ppat_unpack, Ptyp_package) *)
    | Ppat_unpack string_loc ->
      Doc.concat
        [
          Doc.text "module(";
          print_comments (Doc.text string_loc.txt) cmt_tbl string_loc.loc;
          Doc.rparen;
        ]
    | Ppat_interval (a, b) ->
      Doc.concat [print_constant a; Doc.text " .. "; print_constant b]
  in
  let doc =
    match p.ppat_attributes with
    | [] -> pattern_without_attributes
    | attrs ->
      Doc.group
        (Doc.concat
           [print_attributes ~state attrs cmt_tbl; pattern_without_attributes])
  in
  print_comments doc cmt_tbl p.ppat_loc

and print_pattern_record_row ~state row cmt_tbl =
  match row with
  (* punned {x}*)
  | {
   lid = {Location.txt = Longident.Lident ident} as longident;
   x = {Parsetree.ppat_desc = Ppat_var {txt; _}; ppat_attributes};
   opt;
  }
    when ident = txt ->
    Doc.concat
      [
        (if opt then Doc.text "?" else Doc.nil);
        print_attributes ~state ppat_attributes cmt_tbl;
        print_lident_path longident cmt_tbl;
      ]
  | {lid = longident; x = pattern; opt} ->
    let loc_for_comments =
      {longident.loc with loc_end = pattern.Parsetree.ppat_loc.loc_end}
    in
    let rhs_doc =
      let doc = print_pattern ~state pattern cmt_tbl in
      let doc =
        if Parens.pattern_record_row_rhs pattern then add_parens doc else doc
      in
      if opt then Doc.concat [Doc.text "?"; doc] else doc
    in
    let doc =
      Doc.group
        (Doc.concat
           [
             print_lident_path longident cmt_tbl;
             Doc.text ":";
             (if Parsetree_viewer.is_huggable_pattern pattern then
                Doc.concat [Doc.space; rhs_doc]
              else Doc.indent (Doc.concat [Doc.line; rhs_doc]));
           ])
    in
    print_comments doc cmt_tbl loc_for_comments

and print_pattern_dict_row ~state
    ({pdp_key = key; pdp_pattern = pattern; pdp_optional = opt} :
      Parsetree.dict_pattern_entry) cmt_tbl =
  let loc_for_comments = {key.loc with loc_end = pattern.ppat_loc.loc_end} in
  let rhs_doc =
    let doc = print_pattern ~state pattern cmt_tbl in
    let doc =
      if Parens.pattern_record_row_rhs pattern then add_parens doc else doc
    in
    if opt then Doc.concat [Doc.text "?"; doc] else doc
  in
  let lbl_doc =
    print_comments
      (Doc.concat
         [Doc.text "\""; print_longident (Lident key.txt); Doc.text "\""])
      cmt_tbl key.loc
  in
  let doc =
    Doc.group
      (Doc.concat
         [
           lbl_doc;
           Doc.text ":";
           (if Parsetree_viewer.is_huggable_pattern pattern then
              Doc.concat [Doc.space; rhs_doc]
            else Doc.indent (Doc.concat [Doc.line; rhs_doc]));
         ])
  in
  print_comments doc cmt_tbl loc_for_comments

and print_expression_with_comments ~state expr cmt_tbl : Doc.t =
  let doc = print_expression ~state expr cmt_tbl in
  print_comments doc cmt_tbl expr.Parsetree.pexp_loc

and print_expression_with_comments_and_parens ~state expr cmt_tbl =
  let doc = print_expression_with_comments ~state expr cmt_tbl in
  match Parens.expr expr with
  | Parens.Parenthesized -> add_parens doc
  | Braced braces -> print_braces doc expr braces
  | Nothing -> doc

and print_expression_args ~state (args : Parsetree.expression list) cmt_tbl =
  let print_arg expr =
    let doc = print_expression_with_comments ~state expr cmt_tbl in
    match Parens.expr_allowing_coercion expr with
    | Parens.Parenthesized -> add_parens doc
    | Braced braces -> print_braces doc expr braces
    | Nothing -> doc
  in
  match args with
  | [] -> Doc.nil
  | [{pexp_desc = Pexp_construct ({txt = Longident.Lident "()"}, _)}] ->
    Doc.text "()"
  | _ :: _ :: _ ->
    Doc.concat
      [
        Doc.lparen;
        Doc.indent
          (Doc.concat
             [
               Doc.soft_line;
               Doc.join
                 ~sep:(Doc.concat [Doc.comma; Doc.line])
                 (List.map print_arg args);
             ]);
        Doc.trailing_comma;
        Doc.soft_line;
        Doc.rparen;
      ]
  | [arg] ->
    let arg_doc = print_arg arg in
    let should_hug = Parsetree_viewer.is_huggable_expression arg in
    Doc.concat
      [
        Doc.lparen;
        (if should_hug then arg_doc
         else
           Doc.concat
             [
               Doc.indent (Doc.concat [Doc.soft_line; arg_doc]);
               Doc.trailing_comma;
               Doc.soft_line;
             ]);
        Doc.rparen;
      ]

(* The operand of [switch], [try], [if], [while] or a loop, which is followed
   by more code on the same line. A line comment still pending at its end
   would move after that code, into the block, so the operand goes into
   parentheses with the comment before the [)]. *)
and print_operand_before_brace doc =
  if Doc.has_pending_line_suffix doc then add_operand_parens doc else doc

(* An operand followed by a block, see [print_operand_before_brace], with the
   parentheses or braces it needs *)
and print_block_operand ~state expr cmt_tbl =
  let doc = print_expression_with_comments ~state expr cmt_tbl in
  print_operand_before_brace
    (match Parens.expr expr with
    | Parens.Parenthesized -> add_operand_parens doc
    | Braced braces -> print_braces doc expr braces
    | Nothing -> doc)

(* Parentheses around such an operand, or around one that needs them, such as
   a coercion. They break when a line comment is still pending at the end of
   the operand, so that the comment stays before the [)]. *)
and add_operand_parens doc =
  if Doc.has_pending_line_suffix doc then
    Doc.breakable_group ~force_break:true
      (Doc.concat
         [
           Doc.lparen;
           Doc.indent (Doc.concat [Doc.soft_line; doc]);
           Doc.soft_line;
           Doc.rparen;
         ])
  else add_parens doc

and print_if_chain ~state pexp_attributes ifs else_expr cmt_tbl =
  let if_docs =
    Doc.join ~sep:Doc.space
      (List.mapi
         (fun i (outer_loc, if_expr, then_expr) ->
           let if_txt = if i > 0 then Doc.text "else if " else Doc.text "if " in
           let doc =
             let condition =
               if Parsetree_viewer.is_block_expr if_expr then
                 print_expression_block ~state ~braces:true if_expr cmt_tbl
               else
                 let doc =
                   print_expression_with_comments ~state if_expr cmt_tbl
                 in
                 match Parens.expr if_expr with
                 | Parens.Parenthesized -> add_operand_parens doc
                 | Braced braces -> print_braces doc if_expr braces
                 | Nothing -> Doc.if_breaks (add_parens doc) doc
             in
             Doc.concat
               [
                 if_txt;
                 print_operand_before_brace (Doc.group condition);
                 Doc.space;
                 (let then_expr =
                    match Parsetree_viewer.process_braces then_expr with
                    (* Redundant braces, as in [if c { {y} }]: the branch is
                       printed in the if's own braces, so these are dropped *)
                    | Some _, expr -> expr
                    | _ -> then_expr
                  in
                  print_expression_block ~state ~braces:true then_expr cmt_tbl);
               ]
           in
           print_leading_comments doc cmt_tbl.leading outer_loc)
         ifs)
  in
  let else_doc =
    match else_expr with
    | None -> Doc.nil
    | Some expr ->
      let _, expr = Parsetree_viewer.process_braces expr in
      Doc.concat
        [
          Doc.text " else ";
          print_expression_block ~state ~braces:true expr cmt_tbl;
        ]
  in
  Doc.concat
    [print_attributes ~state pexp_attributes cmt_tbl; if_docs; else_doc]

and print_assignment_rhs ~operator rhs rhs_doc =
  (* Delimited expressions handle their own indentation. Binary expressions
     and switches can break after the assignment operator. *)
  let should_indent =
    (not (Parsetree_viewer.is_braced_expr rhs))
    && (Parsetree_viewer.is_binary_expression rhs
       ||
       match rhs.pexp_desc with
       | Pexp_match _ -> true
       | _ -> false)
  in
  Doc.concat
    [
      Doc.text operator;
      (if should_indent then
         Doc.group (Doc.indent (Doc.concat [Doc.line; rhs_doc]))
       else Doc.concat [Doc.space; rhs_doc]);
    ]

and print_object_set_expr ~state obj member rhs cmt_tbl =
  let rhs_doc =
    let doc = print_expression_with_comments ~state rhs cmt_tbl in
    match Parens.expr rhs with
    | Parens.Parenthesized -> add_parens doc
    | Braced braces -> print_braces doc rhs braces
    | Nothing -> doc
  in
  Doc.group
    (Doc.concat
       [
         print_object_get_doc ~state obj member cmt_tbl;
         print_assignment_rhs ~operator:" =" rhs rhs_doc;
       ])

and print_object_get_doc ~state parent_expr (label : string Location.loc)
    cmt_tbl =
  let parent_doc =
    let doc = print_expression_with_comments ~state parent_expr cmt_tbl in
    match Parens.unary_expr_operand parent_expr with
    | Parens.Parenthesized -> add_parens doc
    | Braced braces -> print_braces doc parent_expr braces
    | Nothing -> doc
  in
  let member =
    let member_doc = print_comments (Doc.text label.txt) cmt_tbl label.loc in
    Doc.concat [Doc.text "\""; member_doc; Doc.text "\""]
  in
  Doc.group (Doc.concat [parent_doc; Doc.lbracket; member; Doc.rbracket])

and print_expression ~state (e : Parsetree.expression) cmt_tbl =
  let force_pipe_breaks =
    match e.pexp_desc with
    | Pexp_braces {expr = inner; braces_loc} ->
      braces_loc.loc_start.pos_lnum + 1 < inner.pexp_loc.loc_start.pos_lnum
    | _ -> false
  in
  let rec unwrap_braces_with_attributes attrs (e : Parsetree.expression) =
    match e.pexp_desc with
    | Pexp_braces {expr = inner} ->
      unwrap_braces_with_attributes (attrs @ e.pexp_attributes) inner
    | _ when attrs = [] -> e
    | _ -> {e with pexp_attributes = attrs @ e.pexp_attributes}
  in
  let e = unwrap_braces_with_attributes [] e in
  let printed_expression =
    match e.pexp_desc with
    | Pexp_braces {expr = inner} -> print_expression ~state inner cmt_tbl
    | Pexp_fun
        {
          params =
            [
              {
                p_lbl = Nolabel;
                p_default = None;
                p_pat = {ppat_desc = Ppat_var {txt = "__x"}};
              };
            ];
          body = {pexp_desc = Pexp_apply _};
        } ->
      (* (__x) => f(a, __x, c) -----> f(a, _, c)  *)
      print_expression_with_comments ~state
        (Parsetree_viewer.rewrite_underscore_apply e)
        cmt_tbl
    | Pexp_fun _ -> print_pexp_fun ~state ~in_callback:NoCallback e cmt_tbl
    | Parsetree.Pexp_constant c -> print_constant c
    | Pexp_jsx_element
        (Jsx_fragment
           {
             jsx_fragment_opening = o;
             jsx_fragment_children = children;
             jsx_fragment_closing = c;
           }) ->
      print_jsx_fragment ~state o children c e.pexp_loc cmt_tbl
    | Pexp_jsx_element
        (Jsx_unary_element
           {
             jsx_unary_element_tag_name = tag_name;
             jsx_unary_element_props = props;
           }) ->
      print_jsx_unary_tag ~state tag_name props e.pexp_loc cmt_tbl
    | Pexp_jsx_element
        (Jsx_container_element
           {
             jsx_container_element_tag_name_start = tag_name;
             jsx_container_element_opening_tag_end = opening_greater_than;
             jsx_container_element_props = props;
             jsx_container_element_children = children;
             jsx_container_element_closing_tag = closing_tag;
           }) ->
      print_jsx_container_tag ~state tag_name opening_greater_than props
        children closing_tag e.pexp_loc cmt_tbl
    | Pexp_construct ({txt = Longident.Lident "()"}, _) -> Doc.text "()"
    | Pexp_construct ({txt = Longident.Lident "[]"}, _) ->
      Doc.concat
        [Doc.text "list{"; print_comments_inside cmt_tbl e.pexp_loc; Doc.rbrace]
    | Pexp_construct ({txt = Longident.Lident "::"}, _) ->
      let expressions, spread = Parsetree_viewer.collect_list_expressions e in
      let spread_doc =
        match spread with
        | Some expr ->
          Doc.concat
            [
              Doc.text ",";
              Doc.line;
              print_spread_with_comments ~state expr cmt_tbl;
            ]
        | None -> Doc.nil
      in
      Doc.group
        (Doc.concat
           [
             Doc.text "list{";
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    Doc.join
                      ~sep:(Doc.concat [Doc.text ","; Doc.line])
                      (List.map
                         (fun expr ->
                           let doc =
                             print_expression_with_comments ~state expr cmt_tbl
                           in
                           match Parens.expr_allowing_coercion expr with
                           | Parens.Parenthesized -> add_parens doc
                           | Braced braces -> print_braces doc expr braces
                           | Nothing -> doc)
                         expressions);
                    spread_doc;
                  ]);
             Doc.trailing_comma;
             Doc.soft_line;
             Doc.rbrace;
           ])
    | Pexp_construct (longident_loc, {txt = args}) ->
      let constr = print_longident_location longident_loc cmt_tbl in
      let args = print_expression_args ~state args cmt_tbl in
      Doc.group (Doc.concat [constr; args])
    | Pexp_ident ({txt = Longident.Lident "_"} as path) ->
      (* The `_` placeholder of underscore apply sugar, see
         [Parsetree_viewer.rewrite_underscore_apply]. *)
      print_comments (Doc.text "_") cmt_tbl path.loc
    | Pexp_ident path -> print_lident_path path cmt_tbl
    | Pexp_tuple exprs ->
      Doc.group
        (Doc.concat
           [
             Doc.lparen;
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    Doc.join
                      ~sep:(Doc.concat [Doc.text ","; Doc.line])
                      (List.map
                         (fun expr ->
                           let doc =
                             print_expression_with_comments ~state expr cmt_tbl
                           in
                           match Parens.expr_allowing_coercion expr with
                           | Parens.Parenthesized -> add_parens doc
                           | Braced braces -> print_braces doc expr braces
                           | Nothing -> doc)
                         exprs);
                  ]);
             Doc.if_breaks (Doc.text ",") Doc.nil;
             Doc.soft_line;
             Doc.rparen;
           ])
    | Pexp_array [] ->
      Doc.concat
        [Doc.lbracket; print_comments_inside cmt_tbl e.pexp_loc; Doc.rbracket]
    | Pexp_array exprs ->
      Doc.group
        (Doc.concat
           [
             Doc.lbracket;
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    Doc.join
                      ~sep:(Doc.concat [Doc.text ","; Doc.line])
                      (List.map
                         (fun expr ->
                           let doc =
                             print_expression_with_comments ~state expr cmt_tbl
                           in
                           match Parens.expr_allowing_coercion expr with
                           | Parens.Parenthesized -> add_parens doc
                           | Braced braces -> print_braces doc expr braces
                           | Nothing -> doc)
                         exprs);
                  ]);
             Doc.trailing_comma;
             Doc.soft_line;
             Doc.rbracket;
           ])
    | Pexp_variant (label, {txt = args}) ->
      let variant_name =
        Doc.concat [Doc.text "#"; print_poly_var_ident label]
      in
      let args = print_expression_args ~state args cmt_tbl in
      Doc.group (Doc.concat [variant_name; args])
    | Pexp_record (rows, spread_expr) ->
      if rows = [] then
        Doc.concat
          [Doc.lbrace; print_comments_inside cmt_tbl e.pexp_loc; Doc.rbrace]
      else
        let spread =
          match spread_expr with
          | None -> Doc.nil
          | Some ({pexp_desc} as expr) ->
            let doc =
              match pexp_desc with
              | Pexp_ident {txt = expr} -> print_lident expr
              | _ -> print_expression ~state expr cmt_tbl
            in
            let doc_with_spread =
              Doc.concat
                [
                  Doc.dotdotdot;
                  (match Parens.expr_allowing_coercion expr with
                  | Parens.Parenthesized -> add_parens doc
                  | Braced braces -> print_braces doc expr braces
                  | Nothing -> doc);
                ]
            in
            Doc.concat
              [
                print_comments doc_with_spread cmt_tbl expr.Parsetree.pexp_loc;
                Doc.comma;
                Doc.line;
              ]
        in
        (* If the record is written over multiple lines, break automatically
         * `let x = {a: 1, b: 3}` -> same line, break when line-width exceeded
         * `let x = {
         *   a: 1,
         *   b: 2,
         *  }` -> record is written on multiple lines, break the group *)
        let force_break =
          match (spread_expr, rows) with
          | Some expr, _ ->
            (* If there's a spread, compare with spread expression's location *)
            e.pexp_loc.loc_start.pos_lnum < expr.pexp_loc.loc_start.pos_lnum
          | None, first_row :: _ ->
            (* Otherwise, compare with the first row's location *)
            e.pexp_loc.loc_start.pos_lnum < first_row.lid.loc.loc_start.pos_lnum
          | None, [] -> false
        in
        let punning_allowed =
          match (spread_expr, rows) with
          | None, [_] -> false (* disallow punning for single-element records *)
          | _ -> true
        in
        Doc.breakable_group ~force_break
          (Doc.concat
             [
               Doc.lbrace;
               Doc.indent
                 (Doc.concat
                    [
                      Doc.soft_line;
                      spread;
                      Doc.join
                        ~sep:(Doc.concat [Doc.text ","; Doc.line])
                        (List.map
                           (fun row ->
                             print_expression_record_row ~state row cmt_tbl
                               punning_allowed)
                           rows);
                    ]);
               Doc.trailing_comma;
               Doc.soft_line;
               Doc.rbrace;
             ])
    | Pexp_object_literal fields ->
      (* If the object is written over multiple lines, break automatically
       * `let x = {"a": 1, "b": 3}` -> same line, break when line-width exceeded
       * `let x = {
       *   "a": 1,
       *   "b": 2,
       *  }` -> object is written on multiple lines, break the group *)
      let loc = e.pexp_loc in
      let force_break = loc.loc_start.pos_lnum < loc.loc_end.pos_lnum in
      Doc.breakable_group ~force_break
        (Doc.concat
           [
             Doc.lbrace;
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    Doc.join
                      ~sep:(Doc.concat [Doc.text ","; Doc.line])
                      (Ext_list.map fields
                         (fun ((s : string Asttypes.loc), e) ->
                           print_bs_object_row ~state
                             (Location.mkloc (Longident.Lident s.txt) s.loc, e)
                             cmt_tbl));
                  ]);
             Doc.trailing_comma;
             Doc.soft_line;
             Doc.rbrace;
           ])
    | Pexp_extension extension ->
      print_extension ~state ~at_module_lvl:false extension cmt_tbl
    | Pexp_raw {kind; name_loc; source} ->
      print_extension ~state ~at_module_lvl:false
        (Ast_raw.to_extension
           ~name:(Ast_raw.extension_name kind)
           ~name_loc source)
        cmt_tbl
    | Pexp_todo {name_loc; message} ->
      print_extension ~state ~at_module_lvl:false
        (Ast_todo.to_extension ~name_loc message)
        cmt_tbl
    | Pexp_regexp {pattern; flags} -> Doc.text ("/" ^ pattern ^ "/" ^ flags)
    | Pexp_template {source_segments; values} ->
      print_template_literal ~state ~source_segments ~values cmt_tbl
    | Pexp_tagged_template {tag; raw_sources; values} ->
      print_tagged_template_literal ~state ~tag ~raw_sources ~values cmt_tbl
    | Pexp_spread (kind, elements) ->
      print_spread_expr ~state kind elements cmt_tbl
    | Pexp_apply _ ->
      if Parsetree_viewer.is_unary_expression e then
        print_unary_expression ~state e cmt_tbl
      else if Parsetree_viewer.is_binary_expression e then
        print_binary_expression ~state ~force_pipe_breaks e cmt_tbl
      else print_pexp_apply ~state e cmt_tbl
    | Pexp_dict entries when Parsetree_viewer.dict_has_spread entries ->
      print_spread_dict_expr ~state
        (Parsetree_viewer.dict_expr_parts ~loc:e.pexp_loc entries)
        e cmt_tbl
    | Pexp_dict entries ->
      Doc.concat
        [
          Doc.text "dict{";
          print_comments_inside cmt_tbl e.pexp_loc;
          print_literal_dict_expr ~state
            (Parsetree_viewer.dict_expr_rows ~loc:e.pexp_loc entries)
            cmt_tbl;
          Doc.rbrace;
        ]
    | Pexp_field (expr, longident_loc) ->
      let lhs =
        let doc = print_expression_with_comments ~state expr cmt_tbl in
        match Parens.field_expr expr with
        | Parens.Parenthesized -> add_parens doc
        | Braced braces -> print_braces doc expr braces
        | Nothing -> doc
      in
      Doc.concat [lhs; Doc.dot; print_lident_path longident_loc cmt_tbl]
    | Pexp_setfield (expr1, longident_loc, expr2) ->
      print_set_field_expr ~state e.pexp_attributes expr1 longident_loc expr2
        e.pexp_loc cmt_tbl
    | Pexp_ternary (_condition, _consequent, _alternate) ->
      let parts, alternate = Parsetree_viewer.collect_ternary_parts e in
      let ternary_doc =
        match parts with
        | (condition1, consequent1) :: rest ->
          Doc.group
            (Doc.concat
               [
                 print_ternary_operand ~is_condition:true ~state condition1
                   cmt_tbl;
                 Doc.indent
                   (Doc.concat
                      [
                        Doc.line;
                        Doc.indent
                          (Doc.concat
                             [
                               Doc.text "? ";
                               print_ternary_operand ~state consequent1 cmt_tbl;
                             ]);
                        Doc.concat
                          (List.map
                             (fun (condition, consequent) ->
                               Doc.concat
                                 [
                                   Doc.line;
                                   Doc.text ": ";
                                   print_ternary_operand ~is_condition:true
                                     ~state condition cmt_tbl;
                                   Doc.line;
                                   Doc.text "? ";
                                   print_ternary_operand ~state consequent
                                     cmt_tbl;
                                 ])
                             rest);
                        Doc.line;
                        Doc.text ": ";
                        Doc.indent
                          (print_ternary_operand ~state alternate cmt_tbl);
                      ]);
               ])
        | _ -> Doc.nil
      in
      let attrs = e.pexp_attributes in
      let needs_parens = attrs <> [] in
      Doc.concat
        [
          print_attributes ~state attrs cmt_tbl;
          (if needs_parens then add_parens ternary_doc else ternary_doc);
        ]
    | Pexp_ifthenelse (_ifExpr, _thenExpr, _elseExpr) ->
      let ifs, else_expr = Parsetree_viewer.collect_if_expressions e in
      print_if_chain ~state e.pexp_attributes ifs else_expr cmt_tbl
    | Pexp_break -> Doc.text "break"
    | Pexp_continue -> Doc.text "continue"
    | Pexp_while (expr1, expr2) ->
      let condition =
        let doc = print_expression_with_comments ~state expr1 cmt_tbl in
        match Parens.expr expr1 with
        | Parens.Parenthesized -> add_operand_parens doc
        | Braced braces -> print_braces doc expr1 braces
        | Nothing -> doc
      in
      Doc.breakable_group ~force_break:true
        (Doc.concat
           [
             Doc.text "while ";
             print_operand_before_brace
               (match Parens.expr expr1 with
               | Parens.Parenthesized -> condition
               | _ when Parsetree_viewer.is_block_expr expr1 -> condition
               | _ -> Doc.group (Doc.if_breaks (add_parens condition) condition));
             Doc.space;
             print_expression_block ~state ~braces:true expr2 cmt_tbl;
           ])
    | Pexp_for (pattern, from_expr, to_expr, direction_flag, body) ->
      Doc.breakable_group ~force_break:true
        (Doc.concat
           [
             Doc.text "for ";
             print_pattern ~state pattern cmt_tbl;
             Doc.text " in ";
             print_block_operand ~state from_expr cmt_tbl;
             print_direction_flag direction_flag;
             print_block_operand ~state to_expr cmt_tbl;
             Doc.space;
             print_expression_block ~state ~braces:true body cmt_tbl;
           ])
    | Pexp_for_of (pattern, array_expr, body) ->
      Doc.breakable_group ~force_break:true
        (Doc.concat
           [
             Doc.text "for ";
             print_pattern ~state pattern cmt_tbl;
             Doc.text " of ";
             print_block_operand ~state array_expr cmt_tbl;
             Doc.space;
             print_expression_block ~state ~braces:true body cmt_tbl;
           ])
    | Pexp_for_await_of (pattern, iterable_expr, body) ->
      Doc.breakable_group ~force_break:true
        (Doc.concat
           [
             Doc.text "for await ";
             print_pattern ~state pattern cmt_tbl;
             Doc.text " of ";
             print_block_operand ~state iterable_expr cmt_tbl;
             Doc.space;
             print_expression_block ~state ~braces:true body cmt_tbl;
           ])
    | Pexp_constraint
        ( {pexp_desc = Pexp_pack mod_expr},
          {ptyp_desc = Ptyp_package package_type; ptyp_loc} )
      when Parens.mod_pack_constraint mod_expr ->
      (* [module((M: S1): S2)] and [module(await (await M): S)] would parse as
         functors, so this keeps the general form
         [(module((M: S1)): module(S2))] *)
      Doc.concat
        [
          Doc.lparen;
          Doc.text "module(";
          print_mod_expr_constraint_parens ~state mod_expr cmt_tbl;
          Doc.text "): ";
          print_comments
            (print_package_type ~state ~print_module_keyword_and_parens:true
               package_type cmt_tbl)
            cmt_tbl ptyp_loc;
          Doc.rparen;
        ]
    | Pexp_constraint
        ( {pexp_desc = Pexp_pack mod_expr},
          {ptyp_desc = Ptyp_package package_type; ptyp_loc} ) ->
      Doc.group
        (Doc.concat
           [
             Doc.text "module(";
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    print_mod_expr_constraint_parens ~state mod_expr cmt_tbl;
                    Doc.text ": ";
                    print_comments
                      (print_package_type ~state
                         ~print_module_keyword_and_parens:false package_type
                         cmt_tbl)
                      cmt_tbl ptyp_loc;
                  ]);
             Doc.soft_line;
             Doc.rparen;
           ])
    | Pexp_constraint (expr, typ) ->
      let expr_doc =
        let doc = print_expression_with_comments ~state expr cmt_tbl in
        match Parens.expr expr with
        | Parens.Parenthesized -> add_parens doc
        | Braced braces -> print_braces doc expr braces
        | Nothing -> doc
      in
      Doc.concat [expr_doc; Doc.text ": "; print_typ_expr ~state typ cmt_tbl]
    | Pexp_letmodule ({txt = _modName}, _modExpr, _expr) ->
      print_expression_block ~state ~braces:true e cmt_tbl
    | Pexp_letexception (_extensionConstructor, _expr) ->
      print_expression_block ~state ~braces:true e cmt_tbl
    | Pexp_assert expr ->
      let expr = print_expression_with_comments ~state expr cmt_tbl in
      Doc.concat [Doc.text "assert("; expr; Doc.text ")"]
    | Pexp_open (_overrideFlag, _longidentLoc, _expr) ->
      print_expression_block ~state ~braces:true e cmt_tbl
    | Pexp_pack mod_expr ->
      Doc.group
        (Doc.concat
           [
             Doc.text "module(";
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    print_mod_expr_constraint_parens ~state mod_expr cmt_tbl;
                  ]);
             Doc.soft_line;
             Doc.rparen;
           ])
    | Pexp_sequence _ -> print_expression_block ~state ~braces:true e cmt_tbl
    | Pexp_let _ -> print_expression_block ~state ~braces:true e cmt_tbl
    | Pexp_try (expr, cases, finally) ->
      let expr_doc = print_block_operand ~state expr cmt_tbl in
      let catch_doc =
        match cases with
        | [] -> Doc.nil
        | _ :: _ ->
          Doc.concat [Doc.text " catch "; print_cases ~state cases cmt_tbl]
      in
      let finally_doc =
        match finally with
        | None -> Doc.nil
        | Some finally ->
          Doc.concat
            [
              Doc.text " finally ";
              print_expression_block ~state ~braces:true finally cmt_tbl;
            ]
      in
      Doc.concat [Doc.text "try "; expr_doc; catch_doc; finally_doc]
    | Pexp_match (expr, cases) ->
      let expr_doc = print_block_operand ~state expr cmt_tbl in
      Doc.concat
        [
          Doc.text "switch ";
          expr_doc;
          Doc.space;
          print_cases ~state cases cmt_tbl;
        ]
    | Pexp_coerce (expr, typ) ->
      let doc_expr =
        print_expression_with_comments_and_parens ~state expr cmt_tbl
      in
      let doc_typ = print_typ_expr ~state typ cmt_tbl in
      let doc = Doc.concat [doc_expr; Doc.text " :> "; doc_typ] in
      (* Keep attributes on the coercion rather than its operand. *)
      if e.pexp_attributes <> [] then add_parens doc else doc
    | Pexp_object_get (parent_expr, label) ->
      print_object_get_doc ~state parent_expr label cmt_tbl
    | Pexp_object_set (obj, member, rhs) ->
      print_object_set_expr ~state obj member rhs cmt_tbl
    | Pexp_await e ->
      let printed_expression =
        print_expression_with_comments ~state e cmt_tbl
      in
      let rhs =
        match
          Parens.assert_or_await_expr_rhs ~in_await:true
            (Parsetree_viewer.unwrap_braces e)
        with
        | Parens.Parenthesized -> add_parens printed_expression
        | Braced braces -> print_braces printed_expression e braces
        | Nothing -> printed_expression
      in
      Doc.concat [Doc.text "await "; rhs]
  in
  let should_print_its_own_attributes =
    match e.pexp_desc with
    | Pexp_fun _ when Parsetree_viewer.is_underscore_apply_sugar e -> false
    | Pexp_apply _ | Pexp_fun _ | Pexp_setfield _ | Pexp_ifthenelse _
    | Pexp_ternary _ ->
      true
    | Pexp_jsx_element _ -> true
    | _ -> false
  in
  match e.pexp_attributes with
  | [] -> printed_expression
  | attrs when not should_print_its_own_attributes ->
    Doc.group
      (Doc.concat [print_attributes ~state attrs cmt_tbl; printed_expression])
  | _ -> printed_expression

and print_pexp_fun ~state ~in_callback e cmt_tbl =
  let async, parameters, return_expr = Parsetree_viewer.fun_expr e in
  let attrs_on_arrow = e.pexp_attributes in
  let return_expr, typ_constraint =
    match return_expr.pexp_desc with
    | Pexp_braces
        {
          expr = {pexp_desc = Pexp_constraint (expr, typ)} as constrained;
          braces_loc;
        } ->
      ( Ast_helper.Exp.braces ~braces_loc
          ~attrs:(constrained.pexp_attributes @ return_expr.pexp_attributes)
          expr,
        Some typ )
    | Pexp_constraint (expr, typ) ->
      ( {
          expr with
          pexp_attributes =
            List.concat [expr.pexp_attributes; return_expr.pexp_attributes];
        },
        Some typ )
    | _ -> (return_expr, None)
  in
  let parameters_doc =
    print_expr_fun_parameters ~state ~in_callback ~async
      ~has_constraint:
        (match typ_constraint with
        | Some _ -> true
        | None -> false)
      parameters cmt_tbl
  in
  let return_should_indent =
    match return_expr.pexp_desc with
    | Pexp_sequence _ | Pexp_let _ | Pexp_letmodule _ | Pexp_letexception _
    | Pexp_open _
    | Pexp_jsx_element (Jsx_fragment _) ->
      false
    | _ -> true
  in
  let return_expr_doc =
    let opt_braces, _ = Parsetree_viewer.process_braces return_expr in
    let should_inline =
      match (return_expr.pexp_desc, opt_braces) with
      | _, Some _ -> true
      | ( ( Pexp_array _ | Pexp_tuple _
          | Pexp_construct (_, {txt = _ :: _})
          | Pexp_record _ ),
          _ ) ->
        true
      | _ -> false
    in
    let return_doc =
      let doc = print_expression_with_comments ~state return_expr cmt_tbl in
      match Parens.expr return_expr with
      | Parens.Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc return_expr braces
      | Nothing -> doc
    in
    if should_inline then Doc.concat [Doc.space; return_doc]
    else
      Doc.group
        (if return_should_indent then
           Doc.concat
             [
               Doc.indent (Doc.concat [Doc.line; return_doc]);
               (match in_callback with
               | FitsOnOneLine | ArgumentsFitOnOneLine -> Doc.soft_line
               | _ -> Doc.nil);
             ]
         else Doc.concat [Doc.space; return_doc])
  in
  let typ_constraint_doc =
    match typ_constraint with
    | Some typ ->
      let typ_doc =
        let doc = print_typ_expr ~state typ cmt_tbl in
        if Parens.arrow_return_typ_expr typ then add_parens doc else doc
      in
      Doc.concat [Doc.text ": "; typ_doc]
    | _ -> Doc.nil
  in
  let doc =
    Doc.concat
      [
        print_attributes ~state ~inline:true attrs_on_arrow cmt_tbl;
        parameters_doc;
        typ_constraint_doc;
        Doc.text " =>";
        return_expr_doc;
      ]
  in
  match in_callback with
  | NoCallback -> Doc.group doc
  | FitsOnOneLine | ArgumentsFitOnOneLine -> doc

and print_ternary_operand ?(is_condition = false) ~state expr cmt_tbl =
  let doc = print_expression_with_comments ~state expr cmt_tbl in
  match Parens.ternary_operand ~is_condition expr with
  | Parens.Parenthesized -> add_parens doc
  | Braced braces -> print_braces doc expr braces
  | Nothing -> doc

and print_set_field_expr ~state attrs lhs longident_loc rhs loc cmt_tbl =
  let rhs_doc =
    let doc = print_expression_with_comments ~state rhs cmt_tbl in
    match Parens.expr rhs with
    | Parens.Parenthesized -> add_parens doc
    | Braced braces -> print_braces doc rhs braces
    | Nothing -> doc
  in
  let lhs_doc =
    let doc = print_expression_with_comments ~state lhs cmt_tbl in
    match Parens.field_expr lhs with
    | Parens.Parenthesized -> add_parens doc
    | Braced braces -> print_braces doc lhs braces
    | Nothing -> doc
  in
  let doc =
    Doc.group
      (Doc.concat
         [
           lhs_doc;
           Doc.dot;
           print_lident_path longident_loc cmt_tbl;
           print_assignment_rhs ~operator:" =" rhs rhs_doc;
         ])
  in
  let doc =
    match attrs with
    | [] -> doc
    | attrs ->
      Doc.group (Doc.concat [print_attributes ~state attrs cmt_tbl; doc])
  in
  print_comments doc cmt_tbl loc

and print_template_literal ~state ~source_segments ~values cmt_tbl =
  let strings =
    List.map (fun {Asttypes.txt} -> print_string_contents txt) source_segments
  in
  let values =
    List.map
      (fun expr ->
        let doc = print_expression_with_comments ~state expr cmt_tbl in
        let doc =
          match Parens.expr expr with
          | Parens.Parenthesized -> add_parens doc
          | Braced braces -> print_braces doc expr braces
          | Nothing -> doc
        in
        Doc.group (Doc.concat [Doc.text "${"; Doc.indent doc; Doc.rbrace]))
      values
  in
  let content = interleave_template_parts strings values in
  Doc.concat [Doc.text "`"; content; Doc.text "`"]

and print_tagged_template_literal ~state ~tag ~raw_sources ~values cmt_tbl =
  let strings =
    List.map (fun {Asttypes.txt} -> print_string_contents txt) raw_sources
  in
  let values =
    List.map
      (fun x ->
        Doc.concat
          [
            Doc.text "${";
            print_expression_with_comments ~state x cmt_tbl;
            Doc.text "}";
          ])
      values
  in

  let content = interleave_template_parts strings values in

  let tag_doc = print_expression_with_comments ~state tag cmt_tbl in
  Doc.concat [tag_doc; Doc.text "`"; content; Doc.text "`"]

and print_unary_expression ~state expr cmt_tbl =
  let print_unary_operator op =
    Doc.text
      (match op with
      | "~+" -> "+"
      | "~+." -> "+."
      | "~-" -> "-"
      | "~-." -> "-."
      | "~~~" -> "~~~"
      | "not" -> "!"
      | _ -> assert false)
  in
  match expr.pexp_desc with
  | Pexp_apply
      {
        funct = {pexp_desc = Pexp_ident {txt = Longident.Lident operator}};
        args = [(Nolabel, operand)];
      } ->
    let printed_operand =
      let doc = print_expression_with_comments ~state operand cmt_tbl in
      match Parens.unary_expr_operand operand with
      | Parens.Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc operand braces
      | Nothing -> doc
    in
    let doc = Doc.concat [print_unary_operator operator; printed_operand] in
    print_comments doc cmt_tbl expr.pexp_loc
  | _ -> assert false

and print_binary_expression ~state ~force_pipe_breaks
    (expr : Parsetree.expression) cmt_tbl =
  let print_binary_operator ~inline_rhs operator =
    let spacing_before_operator =
      if operator = "->" then Doc.soft_line else Doc.space
    in
    let spacing_after_operator =
      if operator = "->" then Doc.nil
      else if inline_rhs then Doc.space
      else Doc.line
    in
    Doc.concat
      [spacing_before_operator; Doc.text operator; spacing_after_operator]
  in
  let print_operand ~is_lhs ~is_multiline expr parent_operator =
    let rec flatten ~is_lhs ~is_multiline expr parent_operator =
      if Parsetree_viewer.is_binary_expression expr then
        match expr with
        | {
         pexp_desc =
           Pexp_apply
             {
               funct = {pexp_desc = Pexp_ident {txt = Longident.Lident operator}};
               args = [(_, left); (_, right)];
             };
        } ->
          if
            Parsetree_viewer.flattenable_operators parent_operator operator
            && expr.pexp_attributes = []
          then
            let left_printed =
              flatten ~is_lhs:true ~is_multiline left operator
            in
            let right_printed =
              let right_attrs = right.pexp_attributes in
              let doc =
                print_expression_with_comments ~state
                  {right with pexp_attributes = []}
                  cmt_tbl
              in
              let doc =
                if Parens.flatten_operand_rhs parent_operator right then
                  Doc.concat [Doc.lparen; doc; Doc.rparen]
                else doc
              in
              let doc =
                Doc.concat [print_attributes ~state right_attrs cmt_tbl; doc]
              in
              match right_attrs with
              | [] -> doc
              | _ -> add_parens doc
            in
            let doc =
              if Parsetree_viewer.expr_is_await expr then
                let parens =
                  Res_parens.binary_operator_inside_await_needs_parens operator
                in
                Doc.concat
                  [
                    Doc.lparen;
                    Doc.text "await ";
                    (if parens then Doc.lparen else Doc.nil);
                    left_printed;
                    print_binary_operator ~inline_rhs:false operator;
                    right_printed;
                    (if parens then Doc.rparen else Doc.nil);
                    Doc.rparen;
                  ]
              else
                match operator with
                | "->" when is_multiline || force_pipe_breaks ->
                  (* If the pipe-chain is written over multiple lines, break automatically
                   * `let x = a->b->c -> same line, break when line-width exceeded
                   * `let x = a->
                   *   b->c` -> pipe-chain is written on multiple lines, break the group *)
                  Doc.breakable_group ~force_break:true
                    (Doc.concat
                       [
                         left_printed;
                         print_binary_operator ~inline_rhs:false operator;
                         right_printed;
                       ])
                | _ ->
                  Doc.concat
                    [
                      left_printed;
                      print_binary_operator ~inline_rhs:false operator;
                      right_printed;
                    ]
            in

            let doc =
              if (not is_lhs) && Parens.rhs_binary_expr_operand operator expr
              then Doc.concat [Doc.lparen; doc; Doc.rparen]
              else doc
            in
            print_comments doc cmt_tbl expr.pexp_loc
          else
            let attrs = expr.pexp_attributes in
            let doc =
              print_expression_with_comments ~state
                {expr with pexp_attributes = []}
                cmt_tbl
            in
            let doc =
              if
                Parens.sub_binary_expr_operand parent_operator operator
                || attrs <> []
                   && (Parsetree_viewer.is_binary_expression expr
                      || Parsetree_viewer.is_ternary_expr expr)
              then Doc.concat [Doc.lparen; doc; Doc.rparen]
              else doc
            in
            Doc.concat [print_attributes ~state attrs cmt_tbl; doc]
        | _ -> assert false
      else
        match expr.pexp_desc with
        | Pexp_setfield (lhs, field, rhs) ->
          let doc =
            print_set_field_expr ~state expr.pexp_attributes lhs field rhs
              expr.pexp_loc cmt_tbl
          in
          if is_lhs then add_parens doc else doc
        | Pexp_object_set (obj, member, rhs) ->
          let doc = print_object_set_expr ~state obj member rhs cmt_tbl in
          let doc =
            match expr.pexp_attributes with
            | [] -> doc
            | attrs ->
              Doc.group
                (Doc.concat [print_attributes ~state attrs cmt_tbl; doc])
          in
          if is_lhs then add_parens doc else doc
        | _ -> (
          let doc = print_expression_with_comments ~state expr cmt_tbl in
          let parens =
            match expr.pexp_desc with
            | Pexp_fun _ when parent_operator = ":=" && not is_lhs ->
              Parens.expr expr
            | _ -> Parens.binary_expr_operand ~is_lhs expr
          in
          match parens with
          | Parens.Parenthesized -> add_parens doc
          | Braced braces -> print_braces doc expr braces
          | Nothing -> doc)
    in
    if
      parent_operator = ":=" && (not is_lhs)
      && Parsetree_viewer.is_braced_expr expr
    then
      let doc = print_expression_with_comments ~state expr cmt_tbl in
      match Parens.expr expr with
      | Braced braces -> print_braces doc expr braces
      | Parenthesized -> add_parens doc
      | Nothing -> doc
    else flatten ~is_lhs ~is_multiline expr parent_operator
  in
  match expr.pexp_desc with
  | Pexp_apply
      {
        funct = {pexp_desc = Pexp_ident {txt = Longident.Lident ("->" as op)}};
        args = [(Nolabel, lhs); (Nolabel, rhs)];
      }
    when not
           (Parsetree_viewer.is_binary_expression lhs
           || Parsetree_viewer.is_binary_expression rhs
           || print_attributes ~state expr.pexp_attributes cmt_tbl <> Doc.nil)
    ->
    let lhs_has_comment_below = has_comment_below cmt_tbl lhs.pexp_loc in
    let lhs_doc = print_operand ~is_lhs:true ~is_multiline:false lhs op in
    (* For pipe RHS, use pipe-specific rewrite to omit redundant first underscore *)
    let rhs =
      if op = "->" then Parsetree_viewer.rewrite_underscore_apply_in_pipe rhs
      else rhs
    in
    let rhs_doc = print_operand ~is_lhs:false ~is_multiline:false rhs op in
    Doc.group
      (Doc.concat
         [
           print_attributes ~state expr.pexp_attributes cmt_tbl;
           lhs_doc;
           (match (lhs_has_comment_below, op) with
           | true, "->" -> Doc.concat [Doc.soft_line; Doc.text "->"]
           | false, "->" -> Doc.text "->"
           | _ -> Doc.nil);
           rhs_doc;
         ])
  | Pexp_apply
      {
        funct = {pexp_desc = Pexp_ident {txt = Longident.Lident operator}};
        args = [(Nolabel, lhs); (Nolabel, rhs)];
      } ->
    let is_multiline =
      lhs.pexp_loc.loc_start.pos_lnum < rhs.pexp_loc.loc_start.pos_lnum
    in

    let right =
      let rhs_doc =
        print_operand
          ~is_lhs:(Parsetree_viewer.is_rhs_binary_operator operator)
          ~is_multiline rhs operator
      in
      if operator = ":=" then print_assignment_rhs ~operator:" :=" rhs rhs_doc
      else
        let operator_with_rhs =
          Doc.concat
            [
              print_binary_operator
                ~inline_rhs:(Parsetree_viewer.should_inline_rhs_binary_expr rhs)
                operator;
              rhs_doc;
            ]
        in
        if Parsetree_viewer.should_indent_binary_expr expr then
          Doc.group (Doc.indent operator_with_rhs)
        else operator_with_rhs
    in
    let doc =
      Doc.breakable_group
        ~force_break:(force_pipe_breaks && operator = "->")
        (Doc.concat
           [
             print_operand
               ~is_lhs:(not @@ Parsetree_viewer.is_rhs_binary_operator operator)
               ~is_multiline lhs operator;
             right;
           ])
    in
    Doc.group
      (Doc.concat
         [
           print_attributes ~state expr.pexp_attributes cmt_tbl;
           (match Parens.binary_expr expr with
           | Braced braces_loc -> print_braces doc expr braces_loc
           | Parenthesized -> add_parens doc
           | Nothing -> doc);
         ])
  | _ -> Doc.nil

and print_spread_expr ~state kind elements cmt_tbl =
  let expr_doc expr =
    let doc = print_expression ~state expr cmt_tbl in
    match Parens.expr_allowing_coercion expr with
    | Parens.Parenthesized -> add_parens doc
    | Braced braces -> print_braces doc expr braces
    | Nothing -> doc
  in
  let element_doc = function
    | Parsetree.Pspread_item expr ->
      print_comments (expr_doc expr) cmt_tbl expr.pexp_loc
    | Pspread expr -> print_spread_with_comments ~state expr cmt_tbl
  in
  Doc.group
    (Doc.concat
       [
         (match kind with
         | Spread_array -> Doc.lbracket
         | Spread_list -> Doc.text "list{");
         Doc.indent
           (Doc.concat
              [
                Doc.soft_line;
                Doc.join
                  ~sep:(Doc.concat [Doc.text ","; Doc.line])
                  (List.map element_doc elements);
              ]);
         Doc.trailing_comma;
         Doc.soft_line;
         (match kind with
         | Spread_array -> Doc.rbracket
         | Spread_list -> Doc.rbrace);
       ])

(* callExpr(arg1, arg2) *)
and print_pexp_apply ~state expr cmt_tbl =
  match expr.pexp_desc with
  | Pexp_apply
      {
        funct = {pexp_desc = Pexp_ident {txt = Longident.Lident "##"}};
        args = [(Nolabel, parent_expr); (Nolabel, member_expr)];
      } ->
    let parent_doc =
      let doc = print_expression_with_comments ~state parent_expr cmt_tbl in
      match Parens.unary_expr_operand parent_expr with
      | Parens.Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc parent_expr braces
      | Nothing -> doc
    in
    let member =
      let member_doc =
        match member_expr.pexp_desc with
        | Pexp_ident lident ->
          print_comments
            (print_longident lident.txt)
            cmt_tbl member_expr.pexp_loc
        | _ -> print_expression_with_comments ~state member_expr cmt_tbl
      in
      Doc.concat [Doc.text "\""; member_doc; Doc.text "\""]
    in
    Doc.group
      (Doc.concat
         [
           print_attributes ~state expr.pexp_attributes cmt_tbl;
           parent_doc;
           Doc.lbracket;
           member;
           Doc.rbracket;
         ])
  | Pexp_apply
      {
        funct =
          {
            pexp_desc = Pexp_ident {txt = Longident.Ldot (Lident "Array", "get")};
          };
        args = [(Nolabel, parent_expr); (Nolabel, member_expr)];
      }
    when not (Parsetree_viewer.is_rewritten_underscore_apply_sugar parent_expr)
    ->
    (* Don't print the Array.get(_, 0) sugar a.k.a. (__x) => Array.get(__x, 0) as _[0] *)
    let member =
      let member_doc =
        let doc = print_expression_with_comments ~state member_expr cmt_tbl in
        match Parens.expr_allowing_coercion member_expr with
        | Parens.Parenthesized -> add_parens doc
        | Braced braces -> print_braces doc member_expr braces
        | Nothing -> doc
      in
      let should_inline =
        match member_expr.pexp_desc with
        | Pexp_constant _ | Pexp_ident _ | Pexp_braces _ -> true
        | _ -> false
      in
      if should_inline then member_doc
      else
        Doc.concat
          [Doc.indent (Doc.concat [Doc.soft_line; member_doc]); Doc.soft_line]
    in
    let parent_doc =
      let doc = print_expression_with_comments ~state parent_expr cmt_tbl in
      match Parens.unary_expr_operand parent_expr with
      | Parens.Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc parent_expr braces
      | Nothing -> doc
    in
    Doc.group
      (Doc.concat
         [
           print_attributes ~state expr.pexp_attributes cmt_tbl;
           parent_doc;
           Doc.lbracket;
           member;
           Doc.rbracket;
         ])
  | Pexp_apply
      {
        funct =
          {
            pexp_desc = Pexp_ident {txt = Longident.Ldot (Lident "Array", "set")};
          };
        args =
          [
            (Nolabel, parent_expr);
            (Nolabel, member_expr);
            (Nolabel, target_expr);
          ];
      } ->
    let member =
      let member_doc =
        let doc = print_expression_with_comments ~state member_expr cmt_tbl in
        match Parens.expr_allowing_coercion member_expr with
        | Parens.Parenthesized -> add_parens doc
        | Braced braces -> print_braces doc member_expr braces
        | Nothing -> doc
      in
      let should_inline =
        match member_expr.pexp_desc with
        | Pexp_constant _ | Pexp_ident _ | Pexp_braces _ -> true
        | _ -> false
      in
      if should_inline then member_doc
      else
        Doc.concat
          [Doc.indent (Doc.concat [Doc.soft_line; member_doc]); Doc.soft_line]
    in
    let should_indent_target_expr =
      if Parsetree_viewer.is_braced_expr target_expr then false
      else
        Parsetree_viewer.is_binary_expression target_expr
        ||
        match target_expr with
        | {pexp_attributes = []; pexp_desc = Pexp_ternary (if_expr, _, _)} ->
          Parsetree_viewer.is_binary_expression if_expr
          || if_expr.pexp_attributes <> []
        | e -> e.pexp_attributes <> [] || Parsetree_viewer.is_array_access e
    in
    let target_expr =
      let doc = print_expression_with_comments ~state target_expr cmt_tbl in
      match Parens.expr target_expr with
      | Parens.Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc target_expr braces
      | Nothing -> doc
    in
    let parent_doc =
      let doc = print_expression_with_comments ~state parent_expr cmt_tbl in
      match Parens.unary_expr_operand parent_expr with
      | Parens.Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc parent_expr braces
      | Nothing -> doc
    in
    Doc.group
      (Doc.concat
         [
           print_attributes ~state expr.pexp_attributes cmt_tbl;
           parent_doc;
           Doc.lbracket;
           member;
           Doc.rbracket;
           Doc.text " =";
           (if should_indent_target_expr then
              Doc.indent (Doc.concat [Doc.line; target_expr])
            else Doc.concat [Doc.space; target_expr]);
         ])
  | Pexp_apply {funct = call_expr; args; partial} ->
    let args =
      List.map
        (fun (lbl, arg) -> (lbl, Parsetree_viewer.rewrite_underscore_apply arg))
        args
    in
    let attrs = expr.pexp_attributes in
    let args =
      if partial then
        let dummy = Ast_helper.Exp.constant ~attrs (Ast_helper.Const.int 0) in
        args @ [(Asttypes.Labelled {txt = "..."; loc = Location.none}, dummy)]
      else args
    in
    let call_expr_doc =
      let doc = print_expression_with_comments ~state call_expr cmt_tbl in
      match Parens.call_expr call_expr with
      | Parens.Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc call_expr braces
      | Nothing -> doc
    in
    let requires_regular_layout =
      List.exists (argument_requires_regular_layout cmt_tbl) args
    in
    let args_doc, maybe_break_parent =
      if
        (not requires_regular_layout)
        && Parsetree_viewer.requires_special_callback_printing_first_arg args
      then
        ( print_arguments_with_callback_in_first_position ~state ~partial args
            cmt_tbl,
          Doc.nil )
      else if
        (not requires_regular_layout)
        && Parsetree_viewer.requires_special_callback_printing_last_arg args
      then
        let args_doc =
          print_arguments_with_callback_in_last_position ~state ~partial args
            cmt_tbl
        in
        (* Propagate breaks from the callback layout to enclosing groups, such
         * as an array containing multiline calls. See Doc.will_break and
         * https://github.com/rescript-lang/syntax/issues/111. *)
        let maybe_break_parent =
          if Doc.will_break args_doc then Doc.break_parent else Doc.nil
        in
        (args_doc, maybe_break_parent)
      else (print_arguments ~state ~partial args cmt_tbl, Doc.nil)
    in
    Doc.concat
      [
        maybe_break_parent;
        print_attributes ~state attrs cmt_tbl;
        call_expr_doc;
        args_doc;
      ]
  | _ -> assert false

and print_jsx_unary_tag ~state tag_name props expr_loc cmt_tbl =
  let name = print_jsx_name tag_name.txt in
  let formatted_props = print_jsx_props ~state props cmt_tbl in
  let tag_loc = tag_name.loc in
  let tag_has_trailing_comment = has_trailing_comments cmt_tbl tag_loc in
  let tag_has_no_props = List.length props == 0 in
  let closing_token_loc =
    Parsetree_viewer.unary_element_closing_token expr_loc
  in
  let props_doc =
    if tag_has_no_props then
      if has_leading_comments cmt_tbl closing_token_loc then Doc.soft_line
      else if tag_has_trailing_comment then Doc.nil
      else Doc.space
    else
      Doc.concat
        [
          Doc.indent
            (Doc.concat
               [Doc.line; Doc.group (Doc.join ~sep:Doc.line formatted_props)]);
          Doc.line;
        ]
  in
  let opening_tag =
    print_comments (Doc.concat [Doc.less_than; name]) cmt_tbl tag_loc
  in
  let opening_tag_doc =
    if tag_has_trailing_comment && not tag_has_no_props then
      Doc.indent opening_tag
    else opening_tag
  in
  let closing_tag_doc =
    print_comments (Doc.text "/>") cmt_tbl closing_token_loc
  in
  Doc.group
    (Doc.concat
       [
         opening_tag_doc;
         props_doc;
         (if tag_has_trailing_comment && tag_has_no_props then Doc.space
          else Doc.nil);
         closing_tag_doc;
       ])

(* Standalone JSX comments are trivia, not expression children. Keep their
   delimiters inside braces so future literal text cannot absorb them. *)
and join_jsx_items items =
  let rec loop = function
    | [] -> Doc.nil
    | [(_, doc)] -> doc
    | (loc, doc) :: ((next_loc, _) :: _ as rest) ->
      let separator =
        if
          next_loc.Location.loc_start.pos_lnum
          > loc.Location.loc_end.pos_lnum + 1
        then Doc.concat [Doc.hard_line; Doc.hard_line]
        else Doc.hard_line
      in
      Doc.concat [doc; separator; loop rest]
  in
  loop items

and jsx_comment_items comments =
  let comments = List.map Comment.to_block_if_safe comments in
  let comment_loc comment =
    Option.value (Comment.jsx_container comment) ~default:(Comment.loc comment)
  in
  let rec group_comments acc previous = function
    | comment :: rest
      when Comment.jsx_container previous = Comment.jsx_container comment
           && (Option.is_some (Comment.jsx_container comment)
              || (Comment.loc comment).loc_start.pos_lnum
                 <= (Comment.loc previous).loc_end.pos_lnum + 1) ->
      group_comments (comment :: acc) comment rest
    | rest -> (List.rev acc, rest)
  in
  let rec print_comments = function
    | [] -> Doc.nil
    | comment :: rest -> (
      let doc =
        if Comment.is_single_line_comment comment then
          Doc.concat [Doc.text ("//" ^ Comment.txt comment); Doc.break_parent]
        else print_multiline_comment_content (Comment.txt comment)
      in
      match rest with
      | [] -> doc
      | next :: _ ->
        let diff =
          (Comment.loc next).loc_start.pos_lnum
          - (Comment.loc comment).loc_end.pos_lnum
        in
        let sep =
          if diff > 1 then Doc.concat [Doc.hard_line; Doc.hard_line]
          else if diff > 0 || Comment.is_single_line_comment comment then
            Doc.hard_line
          else Doc.line
        in
        Doc.concat [doc; sep; print_comments rest])
  in
  let rec loop = function
    | [] -> []
    | comment :: rest ->
      let group, rest = group_comments [comment] comment rest in
      let loc = comment_loc comment in
      let last = comment_loc (List.hd (List.rev group)) in
      ({loc with loc_end = last.loc_end}, add_braces (print_comments group))
      :: loop rest
  in
  loop comments

and print_jsx_comment_container comments_tbl loc =
  match Hashtbl.find_opt comments_tbl loc with
  | None -> Doc.nil
  | Some comments ->
    Hashtbl.remove comments_tbl loc;
    join_jsx_items (jsx_comment_items comments)

and print_jsx_container_tag ~state tag_name
    (opening_greater_than : Lexing.position) props
    (children : Parsetree.jsx_children)
    (closing_tag : Parsetree.jsx_closing_container_tag option)
    (pexp_loc : Location.t) cmt_tbl =
  let name = print_jsx_name tag_name.txt in
  let opening_greater_than_loc =
    {
      Warnings.loc_start = opening_greater_than;
      loc_end = opening_greater_than;
      loc_ghost = false;
    }
  in
  let opening_greater_than_doc =
    print_comments Doc.greater_than cmt_tbl opening_greater_than_loc
  in
  let formatted_props = print_jsx_props ~state props cmt_tbl in
  (* <div className="test" /> *)
  let has_children =
    match children with
    | _ :: _ -> true
    | [] -> false
  in
  let line_sep = get_line_sep_for_jsx_children children in
  let indent_children doc =
    Doc.concat [Doc.indent (Doc.concat [line_sep; doc]); line_sep]
  in

  (* comments between the opening and closing tag *)
  let has_comments_inside = has_comments_inside cmt_tbl pexp_loc in
  let closing_element_doc =
    match closing_tag with
    | None -> Doc.nil
    | Some closing_tag ->
      let closing_tag_loc =
        Parsetree_viewer.container_element_closing_tag_loc closing_tag
      in
      let closing_name =
        print_jsx_name closing_tag.jsx_closing_container_tag_name.txt
      in
      print_comments
        (Doc.concat [Doc.text "</"; closing_name; Doc.greater_than])
        cmt_tbl closing_tag_loc
  in
  Doc.group
    (Doc.concat
       [
         Doc.group
           (Doc.concat
              [
                (* Opening tag name and props *)
                (let tag_loc = tag_name.loc in

                 let opening_tag_name_doc =
                   print_comments
                     (Doc.concat [Doc.less_than; name])
                     cmt_tbl tag_loc
                 in
                 let props_block_doc =
                   if List.length formatted_props == 0 then Doc.nil
                   else
                     Doc.indent
                       (Doc.concat
                          [
                            Doc.line;
                            Doc.group (Doc.join formatted_props ~sep:Doc.line);
                          ])
                 in
                 let after_name_and_props_doc =
                   (* if the element name has a single comment on the same line, force newline before '>' *)
                   if has_trailing_single_line_comment cmt_tbl tag_loc then
                     Doc.concat [Doc.hard_line; opening_greater_than_doc]
                   else Doc.concat [Doc.soft_line; opening_greater_than_doc]
                 in
                 Doc.concat
                   [
                     opening_tag_name_doc;
                     props_block_doc;
                     after_name_and_props_doc;
                   ]);
              ]);
         Doc.concat
           [
             (if has_children then
                indent_children (print_jsx_children ~state children cmt_tbl)
              else if not has_comments_inside then Doc.soft_line
              else
                indent_children
                  (print_jsx_comment_container cmt_tbl.inside pexp_loc));
             closing_element_doc;
           ];
       ])

and print_jsx_fragment ~state (opening_greater_than : Lexing.position)
    (children : Parsetree.jsx_children) (closing_lesser_than : Lexing.position)
    (fragment_loc : Warnings.loc) cmt_tbl =
  let opening =
    let loc : Location.t = {fragment_loc with loc_end = opening_greater_than} in
    print_comments (Doc.text "<>") cmt_tbl loc
  in
  let closing =
    let loc : Location.t =
      {fragment_loc with loc_start = closing_lesser_than}
    in
    print_comments (Doc.text "</>") cmt_tbl loc
  in
  let has_children =
    match children with
    | [] -> false
    | _ :: _ -> true
  in
  let line_sep = get_line_sep_for_jsx_children children in
  Doc.group
    (Doc.concat
       [
         opening;
         (let doc =
            if has_children then print_jsx_children ~state children cmt_tbl
            else print_jsx_comment_container cmt_tbl.inside fragment_loc
          in
          if Doc.is_nil doc then doc
          else Doc.concat [Doc.indent (Doc.concat [line_sep; doc]); line_sep]);
         closing;
       ])

and get_line_sep_for_jsx_children (children : Parsetree.jsx_children) =
  (* Single children stay inline when they fit, otherwise indent between the
     tags. Literal JSX text will need to ignore this formatting whitespace. *)
  if
    List.length children > 1
    || List.exists
         (function
           | {Parsetree.pexp_desc = Pexp_jsx_element _} -> true
           | _ -> false)
         children
  then Doc.hard_line
  else Doc.soft_line

and print_jsx_children ~state (children : Parsetree.jsx_children) cmt_tbl =
  let open Parsetree in
  let get_loc (expr : Parsetree.expression) =
    match Parsetree_viewer.process_braces expr with
    | None, _ -> expr.pexp_loc
    | Some loc, _ -> loc
  in
  let print_expr (expr : Parsetree.expression) =
    let loc = get_loc expr in
    match expr.pexp_desc with
    | Pexp_jsx_element _ -> print_expression_with_comments ~state expr cmt_tbl
    | _ ->
      let has_line_comment =
        has_leading_line_comment cmt_tbl loc
        || has_any_trailing_line_comment cmt_tbl loc
        || has_leading_line_comment cmt_tbl expr.pexp_loc
        || has_any_trailing_line_comment cmt_tbl expr.pexp_loc
      in
      let has_comments =
        has_leading_comments cmt_tbl loc
        || has_trailing_comments cmt_tbl loc
        || has_leading_comments cmt_tbl expr.pexp_loc
        || has_trailing_comments cmt_tbl expr.pexp_loc
      in
      (* Consume comments before printing subnodes that may share these
         locations. Remaining comments belong inside the expression's braces. *)
      let leading = print_leading_comments Doc.nil cmt_tbl.leading loc in
      let inner_leading =
        print_leading_comments Doc.nil cmt_tbl.leading expr.pexp_loc
      in
      let inner_trailing =
        print_trailing_comments Doc.nil cmt_tbl.trailing expr.pexp_loc
      in
      let trailing = print_trailing_comments Doc.nil cmt_tbl.trailing loc in
      let rec print_child_expr expr =
        match expr.pexp_desc with
        | Pexp_braces {expr = inner}
          when Parsetree_viewer.is_block_expr inner && expr.pexp_attributes = []
          ->
          print_child_expr inner
        | Pexp_let _ | Pexp_sequence _ | Pexp_letexception _ | Pexp_letmodule _
        | Pexp_open _
          when expr.pexp_attributes = [] ->
          print_expression_block ~state ~braces:false expr cmt_tbl
        | _ ->
          let doc = print_expression_with_comments ~state expr cmt_tbl in
          if Parens.braced_expr expr then add_parens doc else doc
      in
      let expr_doc = print_child_expr expr in
      let wrap doc =
        if has_comments || Parsetree_viewer.is_block_expr expr then
          add_braces doc
        else Doc.concat [Doc.lbrace; doc; Doc.rbrace]
      in
      wrap
        (Doc.concat
           [
             leading;
             inner_leading;
             expr_doc;
             inner_trailing;
             trailing;
             (if has_line_comment then Doc.break_parent else Doc.nil);
           ])
  in
  let items =
    List.concat_map
      (fun expr ->
        let loc = get_loc expr in
        List.iter
          (fun tbl ->
            List.iter
              (fun key ->
                match Hashtbl.find_opt tbl key with
                | None -> ()
                | Some comments ->
                  Hashtbl.replace tbl key
                    (List.map Comment.to_block_if_safe comments))
              (if loc = expr.pexp_loc then [loc] else [loc; expr.pexp_loc]))
          [cmt_tbl.leading; cmt_tbl.trailing];
        let standalone comment =
          Option.is_some (Comment.jsx_container comment)
          ||
          match expr.pexp_desc with
          | Pexp_jsx_element _ -> true
          | Pexp_braces _ ->
            let c = Comment.loc comment in
            c.loc_end.pos_cnum <= loc.loc_start.pos_cnum
            || c.loc_start.pos_cnum >= loc.loc_end.pos_cnum
          | _ -> (Comment.loc comment).loc_start.pos_lnum > loc.loc_end.pos_lnum
        in
        let extract ~leading tbl key =
          match Hashtbl.find_opt tbl key with
          | None -> []
          | Some comments ->
            (* Only retain comments adjacent to the expression, so extracting
               a standalone container cannot reorder intervening comments. *)
            let rec split = function
              | comment :: rest when not (standalone comment) ->
                let inside, outside = split rest in
                (comment :: inside, outside)
              | outside -> ([], outside)
            in
            let inside, outside =
              if leading then
                let inside, outside = split (List.rev comments) in
                (List.rev inside, List.rev outside)
              else split comments
            in
            if inside = [] then Hashtbl.remove tbl key
            else Hashtbl.replace tbl key inside;
            outside
        in
        let extract_both ~leading tbl =
          let outer = extract ~leading tbl loc in
          if loc = expr.pexp_loc then outer
          else outer @ extract ~leading tbl expr.pexp_loc
        in
        let leading = extract_both ~leading:true cmt_tbl.leading in
        let trailing = extract_both ~leading:false cmt_tbl.trailing in
        let item_loc =
          (* Comments retained inside an expression occupy lines too. *)
          let loc_start =
            match get_first_leading_comment cmt_tbl loc with
            | Some comment -> (Comment.loc comment).loc_start
            | None -> loc.loc_start
          in
          let loc_end =
            List.fold_left
              (fun end_pos comment ->
                let comment_end = (Comment.loc comment).loc_end in
                if comment_end.pos_cnum > end_pos.Lexing.pos_cnum then
                  comment_end
                else end_pos)
              loc.loc_end
              (Option.value (Hashtbl.find_opt cmt_tbl.trailing loc) ~default:[])
          in
          {loc with loc_start; loc_end}
        in
        jsx_comment_items leading
        @ [(item_loc, print_expr expr)]
        @ jsx_comment_items trailing)
      children
  in
  join_jsx_items items

and print_jsx_prop ~state prop cmt_tbl =
  let open Parsetree in
  let prop_loc = Parsetree_viewer.get_jsx_prop_loc prop in
  let doc =
    match prop with
    | JSXPropPunning (is_optional, name) ->
      (* We don't print any comments here because they will be attached to the entire prop_loc *)
      if is_optional then Doc.concat [Doc.question; print_ident_like name.txt]
      else print_ident_like name.txt
    | JSXPropValue (name, is_optional, value) ->
      let has_trailing_comment_after_name =
        has_trailing_single_line_comment cmt_tbl name.loc
      in
      let value_doc =
        let leading_line_comment_present =
          (* A leading comment on a braced application may be attached to
             the function or first argument rather than the wrapper. *)
          match
            ( Parens.jsx_prop_expr value,
              (Parsetree_viewer.unwrap_braces value).pexp_desc )
          with
          | ( Braced _,
              Parsetree.Pexp_apply {funct = fun_expr; args = (_, head_arg) :: _}
            ) ->
            has_leading_line_comment cmt_tbl fun_expr.pexp_loc
            || has_leading_line_comment cmt_tbl head_arg.pexp_loc
          | _ -> has_leading_line_comment cmt_tbl value.pexp_loc
        in
        let doc = print_expression_with_comments ~state value cmt_tbl in
        match Parens.jsx_prop_expr value with
        | Parenthesized | Braced _ ->
          (* {(20: int)} make sure that we also protect the expression inside *)
          let inner_doc =
            if Parens.braced_expr value then add_parens doc else doc
          in
          let multiline_before_value =
            match value.pexp_desc with
            | Pexp_braces {expr = inner; braces_loc} ->
              braces_loc.loc_start.pos_lnum + 1
              < inner.pexp_loc.loc_start.pos_lnum
            | _ -> false
          in
          if leading_line_comment_present || multiline_before_value then
            add_braces ~force_break:true inner_doc
          else Doc.concat [Doc.lbrace; inner_doc; Doc.rbrace]
        | _ -> doc
      in
      let doc =
        Doc.concat
          [
            print_comments (print_ident_like name.txt) cmt_tbl name.loc;
            Doc.equal;
            (if is_optional then Doc.question else Doc.nil);
            (if has_trailing_comment_after_name then Doc.hard_line else Doc.nil);
            Doc.group value_doc;
          ]
      in
      print_comments doc cmt_tbl value.pexp_loc
    | JSXPropSpreading (_, value) ->
      Doc.group
        (Doc.concat
           [
             Doc.lbrace;
             Doc.dotdotdot;
             print_expression_with_comments_and_parens ~state value cmt_tbl;
             Doc.rbrace;
           ])
  in
  print_comments doc cmt_tbl prop_loc

and print_jsx_props ~state props cmt_tbl : Doc.t list =
  props |> List.map (fun prop -> print_jsx_prop ~state prop cmt_tbl)

and print_jsx_name (tag_name : Parsetree.jsx_tag_name) =
  match tag_name with
  | Parsetree.JsxTagInvalid invalid ->
    (* Preserve exactly what the parser recorded as invalid *)
    Doc.text invalid
  | Parsetree.JsxLowerTag name ->
    print_ident_like ~allow_uident:true ~allow_hyphen:true name
  | Parsetree.JsxQualifiedLowerTag {path; name} ->
    let upper_segs = Longident.flatten path in
    let printed_upper =
      upper_segs |> List.map (print_ident_like ~allow_uident:true)
    in
    let printed_lower =
      print_ident_like ~allow_uident:true ~allow_hyphen:true name
    in
    Doc.join ~sep:Doc.dot (printed_upper @ [printed_lower])
  | Parsetree.JsxUpperTag path ->
    let segs = Longident.flatten path in
    let printed = segs |> List.map (print_ident_like ~allow_uident:true) in
    Doc.join ~sep:Doc.dot printed

and print_callback_label = function
  | Asttypes.Nolabel -> Doc.nil
  | Asttypes.Labelled {txt} ->
    Doc.concat [Doc.tilde; print_ident_like txt; Doc.equal]
  | Asttypes.Optional {txt} ->
    Doc.concat [Doc.tilde; print_ident_like txt; Doc.equal; Doc.question]

and print_arguments_with_callback_in_first_position ~state ~partial args cmt_tbl
    =
  (* Printing consumes comments from the table. Each alternative layout needs
   * its own copy so it can print the same subtree with all its comments. *)
  let state = State.next_custom_layout state in
  let cmt_tbl_copy = Comment_table.copy cmt_tbl in
  let callback, printed_args =
    match args with
    | (lbl, expr) :: args ->
      let lbl_doc = print_callback_label lbl in
      let callback =
        Doc.concat
          [
            lbl_doc;
            print_pexp_fun ~state ~in_callback:FitsOnOneLine expr cmt_tbl;
          ]
      in
      let callback = lazy (print_comments callback cmt_tbl expr.pexp_loc) in
      let printed_args =
        lazy
          (Doc.join
             ~sep:(Doc.concat [Doc.comma; Doc.line])
             (List.map (fun arg -> print_argument ~state arg cmt_tbl) args))
      in
      (callback, printed_args)
    | _ -> assert false
  in

  (* Thing.map((arg1, arg2) => MyModuleBlah.toList(argument), foo) *)
  (* Thing.map((arg1, arg2) => {
   *   MyModuleBlah.toList(argument)
   * }, longArgumet, veryLooooongArgument)
   *)
  let fits_on_one_line =
    lazy
      (Doc.concat
         [
           Doc.lparen;
           Lazy.force callback;
           Doc.comma;
           Doc.line;
           Lazy.force printed_args;
           Doc.rparen;
         ])
  in

  (* Thing.map(
   *   (param1, parm2) => doStuff(param1, parm2),
   *   arg1,
   *   arg2,
   *   arg3,
   * )
   *)
  let break_all_args =
    lazy (print_arguments ~state ~partial args cmt_tbl_copy)
  in

  (* Sometimes one of the non-callback arguments will break.
   * There might be a single line comment in there, or a multiline string etc.
   * showDialog(
   *   ~onConfirm={() => ()},
   *   `
   *   Do you really want to leave this workspace?
   *   Some more text with detailed explanations...
   *   `,
   *   ~danger=true,
   *   // comment   --> here a single line comment
   *   ~confirmText="Yes, I am sure!",
   *  )
   * In this case, we always want the arguments broken over multiple lines,
   * like a normal function call.
   *)
  if state |> State.should_break_callback then Lazy.force break_all_args
  else if Doc.will_break (Lazy.force printed_args) then
    Lazy.force break_all_args
  else
    Doc.custom_layout [Lazy.force fits_on_one_line; Lazy.force break_all_args]

and print_arguments_with_callback_in_last_position ~state ~partial args cmt_tbl
    =
  (* Printing consumes comments from the table. Each alternative layout needs
   * its own copy so it can print the same subtree with all its comments. *)
  let state = state |> State.next_custom_layout in
  let cmt_tbl_copy = Comment_table.copy cmt_tbl in
  let cmt_tbl_copy2 = Comment_table.copy cmt_tbl in
  let rec loop acc args =
    match args with
    | [] -> (lazy Doc.nil, lazy Doc.nil, lazy Doc.nil)
    | [(lbl, expr)] ->
      let lbl_doc = print_callback_label lbl in
      let callback_fits_on_one_line =
        lazy
          (let pexp_fun_doc =
             print_pexp_fun ~state ~in_callback:FitsOnOneLine expr cmt_tbl
           in
           let doc = Doc.concat [lbl_doc; pexp_fun_doc] in
           print_comments doc cmt_tbl expr.pexp_loc)
      in
      let callback_arguments_fits_on_one_line =
        lazy
          (let pexp_fun_doc =
             print_pexp_fun ~state ~in_callback:ArgumentsFitOnOneLine expr
               cmt_tbl_copy
           in
           let doc = Doc.concat [lbl_doc; pexp_fun_doc] in
           print_comments doc cmt_tbl_copy expr.pexp_loc)
      in
      ( lazy (Doc.concat (List.rev acc)),
        callback_fits_on_one_line,
        callback_arguments_fits_on_one_line )
    | arg :: args ->
      let arg_doc = print_argument ~state arg cmt_tbl in
      loop (Doc.line :: Doc.comma :: arg_doc :: acc) args
  in
  let printed_args, callback, callback2 = loop [] args in

  (* Thing.map(foo, (arg1, arg2) => MyModuleBlah.toList(argument)) *)
  let fits_on_one_line =
    lazy
      (Doc.concat
         [Doc.lparen; Lazy.force printed_args; Lazy.force callback; Doc.rparen])
  in

  (* Thing.map(longArgumet, veryLooooongArgument, (arg1, arg2) =>
   *   MyModuleBlah.toList(argument)
   * )
   *)
  let arguments_fit_on_one_line =
    lazy
      (Doc.concat
         [
           Doc.lparen;
           Lazy.force printed_args;
           Doc.breakable_group ~force_break:true (Lazy.force callback2);
           Doc.rparen;
         ])
  in

  (* Thing.map(
   *   arg1,
   *   arg2,
   *   arg3,
   *   (param1, parm2) => doStuff(param1, parm2)
   * )
   *)
  let break_all_args =
    lazy (print_arguments ~state ~partial args cmt_tbl_copy2)
  in

  (* Sometimes one of the non-callback arguments will break.
   * There might be a single line comment in there, or a multiline string etc.
   * showDialog(
   *   `
   *   Do you really want to leave this workspace?
   *   Some more text with detailed explanations...
   *   `,
   *   ~danger=true,
   *   // comment   --> here a single line comment
   *   ~confirmText="Yes, I am sure!",
   *   ~onConfirm={() => ()},
   *  )
   * In this case, we always want the arguments broken over multiple lines,
   * like a normal function call.
   *)
  if state |> State.should_break_callback then Lazy.force break_all_args
  else if Doc.will_break (Lazy.force printed_args) then
    Lazy.force break_all_args
  else
    Doc.custom_layout
      [
        Lazy.force fits_on_one_line;
        Lazy.force arguments_fit_on_one_line;
        Lazy.force break_all_args;
      ]

and print_arguments ~state ~partial
    (args : (Asttypes.arg_label * Parsetree.expression) list) cmt_tbl =
  match args with
  | [
   ( Nolabel,
     {
       pexp_desc = Pexp_construct ({txt = Longident.Lident "()"}, _);
       pexp_loc = loc;
     } );
  ] ->
    if has_leading_line_comment cmt_tbl loc then
      let cmt = print_comments Doc.nil cmt_tbl loc in
      Doc.concat
        [
          Doc.lparen;
          Doc.indent (Doc.group (Doc.concat [Doc.soft_line; cmt]));
          Doc.rparen;
        ]
    else Doc.text "()"
  | [(Nolabel, arg)] when Parsetree_viewer.is_huggable_expression arg ->
    let arg_doc =
      let doc = print_expression_with_comments ~state arg cmt_tbl in
      match Parens.expr_allowing_coercion arg with
      | Parens.Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc arg braces
      | Nothing -> doc
    in
    Doc.concat [Doc.lparen; arg_doc; Doc.rparen]
  | args ->
    (* Flush a callback's line comment before closing the argument list, so
     * reparsing cannot attach it to an enclosing call instead. *)
    let force_break =
      List.exists
        (fun ((_, arg) as argument) ->
          Parsetree_viewer.is_fun_expr arg
          && (has_any_trailing_line_comment cmt_tbl
                (Parsetree_viewer.argument_loc argument)
             || has_any_trailing_line_comment cmt_tbl arg.pexp_loc))
        args
    in
    (* Avoid printing trailing comma when there is ... in function application *)
    let printed_args =
      List.map (fun arg -> print_argument ~state arg cmt_tbl) args
    in
    Doc.breakable_group ~force_break
      (Doc.concat
         [
           Doc.lparen;
           Doc.indent
             (Doc.concat
                [
                  Doc.soft_line;
                  Doc.join ~sep:(Doc.concat [Doc.comma; Doc.line]) printed_args;
                ]);
           (if partial then Doc.nil else Doc.trailing_comma);
           Doc.soft_line;
           Doc.rparen;
         ])

(*
 * argument ::=
 *   | _                            (* syntax sugar *)
 *   | expr
 *   | expr : type
 *   | ~ label-name
 *   | ~ label-name
 *   | ~ label-name ?
 *   | ~ label-name =   expr
 *   | ~ label-name =   _           (* syntax sugar *)
 *   | ~ label-name =   expr : type
 *   | ~ label-name = ? expr
 *   | ~ label-name = ? _           (* syntax sugar *)
 *   | ~ label-name = ? expr : type *)
and print_argument ~state (arg_lbl, arg) cmt_tbl =
  match (arg_lbl, arg) with
  (* ~a (punned)*)
  | ( Labelled {txt = lbl; loc = l0},
      {
        pexp_attributes = [];
        pexp_desc = Pexp_ident {txt = Longident.Lident name};
      } )
    when lbl = name ->
    let loc = {l0 with loc_end = arg.pexp_loc.loc_end} in
    let doc = Doc.concat [Doc.tilde; print_ident_like lbl] in
    print_comments doc cmt_tbl loc
  (* ~a: int (punned)*)
  | ( Labelled {txt = lbl; loc = l0},
      {
        pexp_desc =
          Pexp_constraint
            ({pexp_desc = Pexp_ident {txt = Longident.Lident name}}, typ);
        pexp_attributes = [];
      } )
    when lbl = name ->
    let loc = {l0 with loc_end = arg.pexp_loc.loc_end} in
    let doc =
      Doc.concat
        [
          Doc.tilde;
          print_ident_like lbl;
          Doc.text ": ";
          print_typ_expr ~state typ cmt_tbl;
        ]
    in
    print_comments doc cmt_tbl loc
  (* ~a? (optional lbl punned)*)
  | ( Optional {txt = lbl; loc},
      {
        pexp_desc = Pexp_ident {txt = Longident.Lident name};
        pexp_attributes = [];
      } )
    when lbl = name ->
    let doc = Doc.concat [Doc.tilde; print_ident_like lbl; Doc.question] in
    print_comments doc cmt_tbl loc
  | _lbl, expr ->
    let arg_loc, printed_lbl, dotdotdot =
      match arg_lbl with
      | Nolabel -> (expr.pexp_loc, Doc.nil, false)
      | Labelled {txt = "..."; loc} ->
        let arg_loc = loc in
        let doc = Doc.text "..." in
        (loc, print_comments doc cmt_tbl arg_loc, true)
      | Labelled {txt = lbl; loc} ->
        let arg_loc = loc in
        let doc = Doc.concat [Doc.tilde; print_ident_like lbl; Doc.equal] in
        (loc, print_comments doc cmt_tbl arg_loc, false)
      | Optional {txt = lbl; loc} ->
        let arg_loc = loc in
        let doc =
          Doc.concat [Doc.tilde; print_ident_like lbl; Doc.equal; Doc.question]
        in
        (loc, print_comments doc cmt_tbl arg_loc, false)
    in
    let printed_expr =
      let doc = print_expression_with_comments ~state expr cmt_tbl in
      match Parens.expr_allowing_coercion expr with
      | Parenthesized -> add_parens doc
      | Braced braces -> print_braces doc expr braces
      | Nothing -> doc
    in
    let loc = {arg_loc with loc_end = expr.pexp_loc.loc_end} in
    let doc =
      if dotdotdot then printed_lbl else Doc.concat [printed_lbl; printed_expr]
    in
    print_comments doc cmt_tbl loc

and print_cases ~state (cases : Parsetree.case list) cmt_tbl =
  Doc.breakable_group ~force_break:true
    (Doc.concat
       [
         Doc.lbrace;
         Doc.concat
           [
             Doc.line;
             print_list
               ~get_loc:(fun n ->
                 {
                   n.Parsetree.pc_lhs.ppat_loc with
                   loc_end =
                     (match Parsetree_viewer.process_braces n.pc_rhs with
                     | None, _ -> n.pc_rhs.pexp_loc.loc_end
                     | Some loc, _ -> loc.Location.loc_end);
                 })
               ~print:(print_case ~state) ~nodes:cases cmt_tbl;
           ];
         Doc.line;
         Doc.rbrace;
       ])

and print_case ~state (case : Parsetree.case) cmt_tbl =
  let is_block_rhs = Parsetree_viewer.is_block_expr case.pc_rhs in
  let rhs =
    if is_block_rhs then
      print_expression_block ~state ~braces:false case.pc_rhs cmt_tbl
    else
      let doc = print_expression_with_comments ~state case.pc_rhs cmt_tbl in
      match Parens.expr case.pc_rhs with
      | Parenthesized -> add_parens doc
      | _ -> doc
  in

  let guard =
    match case.pc_guard with
    | None -> Doc.nil
    | Some expr ->
      Doc.group
        (Doc.concat
           [
             Doc.line;
             Doc.text "if ";
             print_expression_with_comments_and_parens ~state expr cmt_tbl;
           ])
  in
  let should_inline_rhs =
    if is_block_rhs then false
    else
      match case.pc_rhs.pexp_desc with
      | Pexp_construct ({txt = Longident.Lident ("()" | "true" | "false")}, _)
      | Pexp_constant _ | Pexp_ident _ ->
        true
      | _ when Parsetree_viewer.is_huggable_rhs case.pc_rhs -> true
      | _ -> false
  in
  let should_indent_pattern =
    match case.pc_lhs.ppat_desc with
    | Ppat_or _ -> false
    | _ -> true
  in
  let pattern_doc =
    let doc = print_pattern ~state case.pc_lhs cmt_tbl in
    match case.pc_lhs.ppat_desc with
    | Ppat_constraint _ -> add_parens doc
    | _ -> doc
  in
  let content =
    Doc.concat
      [
        (if should_indent_pattern then Doc.indent pattern_doc else pattern_doc);
        Doc.indent guard;
        Doc.text " =>";
        Doc.indent
          (Doc.concat
             [(if should_inline_rhs then Doc.space else Doc.line); rhs]);
      ]
  in
  Doc.group (Doc.concat [Doc.text "| "; content])

and print_expr_fun_parameters ~state ~in_callback ~async ~has_constraint
    parameters cmt_tbl =
  match parameters with
  (* let f = _ => () *)
  | [
   Parsetree_viewer.Parameter
     {
       attrs = [];
       lbl = Nolabel;
       default_expr = None;
       pat = {Parsetree.ppat_desc = Ppat_any; ppat_loc; ppat_attributes = []};
     };
  ] ->
    let any =
      let doc = if has_constraint then Doc.text "(_)" else Doc.text "_" in
      print_comments doc cmt_tbl ppat_loc
    in
    if async then add_async any else any
  (* let f = a => () *)
  | [
   Parsetree_viewer.Parameter
     {
       attrs = [];
       lbl = Nolabel;
       default_expr = None;
       pat =
         {
           Parsetree.ppat_desc = Ppat_var string_loc;
           Parsetree.ppat_attributes = attrs;
         };
     };
  ] ->
    let txt_doc =
      let var = print_ident_like string_loc.txt in
      let var =
        match attrs with
        | [] -> if has_constraint then add_parens var else var
        | attrs ->
          let attrs = print_attributes ~state attrs cmt_tbl in
          add_parens (Doc.concat [attrs; var])
      in
      if async then add_async var else var
    in
    print_comments txt_doc cmt_tbl string_loc.loc
  (* let f = () => () *)
  | [
   Parsetree_viewer.Parameter
     {
       attrs = [];
       lbl = Nolabel;
       default_expr = None;
       pat =
         {
           ppat_desc =
             Ppat_construct ({txt = Longident.Lident "()"; loc}, {txt = []});
           ppat_attributes = [];
         };
     };
  ] ->
    let doc =
      let lparen_rparen = Doc.text "()" in
      if async then add_async lparen_rparen else lparen_rparen
    in
    print_comments doc cmt_tbl loc
  (* let f = (~greeting, ~from as hometown, ~x=?) => () *)
  | parameters ->
    let in_callback =
      match in_callback with
      | FitsOnOneLine -> true
      | _ -> false
    in
    let maybe_async_lparen =
      let lparen = Doc.lparen in
      if async then add_async lparen else lparen
    in
    let should_hug = Parsetree_viewer.parameters_should_hug parameters in
    let printed_paramaters =
      Doc.concat
        [
          (if should_hug || in_callback then Doc.nil else Doc.soft_line);
          Doc.join
            ~sep:(Doc.concat [Doc.comma; Doc.line])
            (List.map
               (fun p -> print_exp_fun_parameter ~state p cmt_tbl)
               parameters);
        ]
    in
    Doc.group
      (Doc.concat
         [
           maybe_async_lparen;
           (if should_hug || in_callback then printed_paramaters
            else
              Doc.concat
                [
                  Doc.indent printed_paramaters;
                  Doc.trailing_comma;
                  Doc.soft_line;
                ]);
           Doc.rparen;
         ])

and print_exp_fun_parameter ~state parameter cmt_tbl =
  match parameter with
  | Parsetree_viewer.NewTypes {attrs; locs = lbls} ->
    Doc.group
      (Doc.concat
         [
           print_attributes ~state attrs cmt_tbl;
           Doc.text "type ";
           (* XX *)
           Doc.join ~sep:Doc.space
             (List.map
                (fun lbl ->
                  print_comments
                    (print_ident_like lbl.Asttypes.txt)
                    cmt_tbl lbl.Asttypes.loc)
                lbls);
         ])
  | Parameter {attrs; lbl; default_expr; pat = pattern} ->
    let attrs = print_attributes ~state attrs cmt_tbl in
    (* =defaultValue *)
    let default_expr_doc =
      match default_expr with
      | Some expr ->
        Doc.concat
          [Doc.text "="; print_expression_with_comments ~state expr cmt_tbl]
      | None -> Doc.nil
    in
    (* ~from as hometown
     * ~from                   ->  punning *)
    let label_with_pattern =
      match (lbl, pattern) with
      | Nolabel, pattern -> print_pattern ~state pattern cmt_tbl
      | ( (Labelled {txt = lbl} | Optional {txt = lbl}),
          {ppat_desc = Ppat_var string_loc; ppat_attributes} )
        when lbl = string_loc.txt ->
        (* ~d *)
        print_comments
          (Doc.concat
             [
               print_attributes ~state ppat_attributes cmt_tbl;
               Doc.text "~";
               print_ident_like lbl;
             ])
          cmt_tbl pattern.ppat_loc
      | ( (Labelled {txt = lbl} | Optional {txt = lbl}),
          {
            ppat_desc =
              Ppat_constraint
                (({ppat_desc = Ppat_var {txt}} as var_pattern), typ);
            ppat_attributes;
          } )
        when lbl = txt ->
        (* ~d: e *)
        print_comments
          (Doc.concat
             [
               print_attributes ~state ppat_attributes cmt_tbl;
               print_comments
                 (Doc.concat [Doc.text "~"; print_ident_like lbl])
                 cmt_tbl var_pattern.ppat_loc;
               Doc.text ": ";
               print_typ_expr ~state typ cmt_tbl;
             ])
          cmt_tbl pattern.ppat_loc
      | (Labelled {txt = lbl} | Optional {txt = lbl}), pattern ->
        (* ~b as c: the parser puts attributes before [~b] on [c] *)
        Doc.concat
          [
            print_attributes ~state pattern.ppat_attributes cmt_tbl;
            Doc.text "~";
            print_ident_like lbl;
            Doc.text " as ";
            print_pattern ~state {pattern with ppat_attributes = []} cmt_tbl;
          ]
    in
    let optional_label_suffix =
      match (lbl, default_expr) with
      | Optional _, None -> Doc.text "=?"
      | _ -> Doc.nil
    in
    let doc =
      Doc.group (Doc.concat [attrs; label_with_pattern; default_expr_doc])
    in
    let lbl_loc = Asttypes.get_lbl_loc lbl in
    let cmt_loc =
      match default_expr with
      | None -> {lbl_loc with loc_end = pattern.ppat_loc.loc_end}
      | Some expr -> {lbl_loc with loc_end = expr.pexp_loc.loc_end}
    in
    (* Without a default, [cmt_loc] ends before [=?]. *)
    print_comments_before_marker doc cmt_tbl cmt_loc optional_label_suffix

and print_expression_block ~state ~braces expr cmt_tbl =
  let expr = Parsetree_viewer.unwrap_braces expr in
  (* Include attributes and leading comments when preserving blank lines, but
     look up comments using the original expression location. *)
  let statement_row (expr : Parsetree.expression) doc =
    let loc =
      match get_first_leading_comment cmt_tbl expr.pexp_loc with
      | Some comment ->
        {(Comment.loc comment) with loc_end = expr.pexp_loc.loc_end}
      | None -> (
        match expr.pexp_attributes with
        | ({loc}, _) :: _ -> {expr.pexp_loc with loc_start = loc.loc_start}
        | [] -> expr.pexp_loc)
    in
    (loc, print_comments doc cmt_tbl expr.pexp_loc)
  in
  let rec collect_rows ~protect_regexp acc expr =
    match expr.Parsetree.pexp_desc with
    | Parsetree.Pexp_letmodule (mod_name, mod_expr, expr2) ->
      let name =
        let doc = Doc.text mod_name.txt in
        print_comments doc cmt_tbl mod_name.loc
      in
      let name, mod_expr =
        match mod_expr.pmod_desc with
        | Pmod_constraint (mod_expr2, mod_type)
          when not (Parsetree_viewer.mod_expr_has_attributes mod_expr) ->
          let name =
            Doc.concat
              [name; Doc.text ": "; print_mod_type ~state mod_type cmt_tbl]
          in
          (name, mod_expr2)
        | _ -> (name, mod_expr)
      in
      let let_module_doc =
        Doc.concat
          [
            Doc.text "module ";
            name;
            Doc.text " = ";
            print_mod_expr_constraint_parens ~state mod_expr cmt_tbl;
          ]
      in
      let loc = {expr.pexp_loc with loc_end = mod_expr.pmod_loc.loc_end} in
      collect_rows ~protect_regexp:false ((loc, let_module_doc) :: acc) expr2
    | Pexp_letexception (extension_constructor, expr2) ->
      let loc =
        let loc =
          {expr.pexp_loc with loc_end = extension_constructor.pext_loc.loc_end}
        in
        match get_first_leading_comment cmt_tbl loc with
        | None -> loc
        | Some comment ->
          let cmt_loc = Comment.loc comment in
          {cmt_loc with loc_end = loc.loc_end}
      in
      let let_exception_doc =
        print_exception_def ~state extension_constructor cmt_tbl
      in
      collect_rows ~protect_regexp:false ((loc, let_exception_doc) :: acc) expr2
    | Pexp_open (override_flag, longident_loc, expr2) ->
      let open_doc =
        Doc.concat
          [
            Doc.text "open";
            print_override_flag override_flag;
            Doc.space;
            print_longident_location longident_loc cmt_tbl;
          ]
      in
      let loc = {expr.pexp_loc with loc_end = longident_loc.loc.loc_end} in
      collect_rows ~protect_regexp:false ((loc, open_doc) :: acc) expr2
    | Pexp_sequence (expr1, expr2) ->
      let expr_doc =
        let doc = print_expression ~state expr1 cmt_tbl in
        print_statement_expr ~protect_regexp expr1 (Parens.expr expr1) doc
      in
      collect_rows ~protect_regexp:true
        (statement_row expr1 expr_doc :: acc)
        expr2
    | Pexp_let (rec_flag, value_bindings, expr2) -> (
      let loc =
        let loc =
          match (value_bindings, List.rev value_bindings) with
          | vb :: _, last_vb :: _ ->
            {vb.pvb_loc with loc_end = last_vb.pvb_loc.loc_end}
          | _ -> Location.none
        in
        match get_first_leading_comment cmt_tbl loc with
        | None -> loc
        | Some comment ->
          let cmt_loc = Comment.loc comment in
          {cmt_loc with loc_end = loc.loc_end}
      in
      let rec_flag =
        match rec_flag with
        | Asttypes.Nonrecursive -> Doc.nil
        | Asttypes.Recursive -> Doc.text "rec "
      in
      let let_doc =
        print_value_bindings ~state ~rec_flag value_bindings cmt_tbl
      in
      (* let () = {
       *   let () = foo()
       *   ()
       * }
       * We don't need to print the () on the last line of the block
       *)
      match expr2.pexp_desc with
      | Pexp_construct ({txt = Longident.Lident "()"}, _) ->
        List.rev ((loc, let_doc) :: acc)
      | _ -> collect_rows ~protect_regexp:true ((loc, let_doc) :: acc) expr2)
    | _ ->
      let expr_doc =
        let doc = print_expression ~state expr cmt_tbl in
        print_statement_expr ~protect_regexp expr (Parens.expr expr) doc
      in
      List.rev (statement_row expr expr_doc :: acc)
  in
  let rows = collect_rows ~protect_regexp:false [] expr in
  let block =
    print_list ~get_loc:fst ~nodes:rows
      ~print:(fun (_, doc) _ -> doc)
      ~force_break:true cmt_tbl
  in
  Doc.breakable_group ~force_break:true
    (if braces then
       Doc.concat
         [
           Doc.lbrace;
           Doc.indent (Doc.concat [Doc.line; block]);
           Doc.line;
           Doc.rbrace;
         ]
     else block)

(*
 * // user types:
 * let f = (a, b) => { a + b }
 *
 * // printer: everything is on one line
 * let f = (a, b) => { a + b }
 *
 * // user types: over multiple lines
 * let f = (a, b) => {
 *   a + b
 * }
 *
 * // printer: over multiple lines
 * let f = (a, b) => {
 *   a + b
 * }
 *)
and print_braces doc expr braces_loc =
  let over_multiple_lines =
    let open Location in
    braces_loc.loc_end.pos_lnum > braces_loc.loc_start.pos_lnum
  in
  match (Parsetree_viewer.unwrap_braces expr).Parsetree.pexp_desc with
  | Pexp_letmodule _ | Pexp_letexception _ | Pexp_let _ | Pexp_open _
  | Pexp_sequence _ ->
    (* already has braces *)
    doc
  | _ ->
    Doc.breakable_group ~force_break:over_multiple_lines
      (Doc.concat
         [
           Doc.lbrace;
           Doc.indent
             (Doc.concat
                [
                  Doc.soft_line;
                  (if Parens.braced_expr expr then add_parens doc else doc);
                ]);
           Doc.soft_line;
           Doc.rbrace;
         ])

and print_override_flag override_flag =
  match override_flag with
  | Asttypes.Override -> Doc.text "!"
  | Fresh -> Doc.nil

and print_direction_flag flag =
  match flag with
  | Asttypes.Downto -> Doc.text " downto "
  | Asttypes.Upto -> Doc.text " to "

and print_expression_record_row ~state {lid = lbl; x = expr; opt = optional}
    cmt_tbl punning_allowed =
  let cmt_loc = {lbl.loc with loc_end = expr.pexp_loc.loc_end} in
  let doc =
    Doc.group
      (match expr.pexp_desc with
      | Pexp_ident {txt = Lident key; loc = _keyLoc}
        when punning_allowed && Longident.last lbl.txt = key ->
        (* print punned field *)
        Doc.concat
          [
            print_attributes ~state expr.pexp_attributes cmt_tbl;
            (if optional then Doc.text "?" else Doc.nil);
            print_lident_path lbl cmt_tbl;
          ]
      | _ ->
        Doc.concat
          [
            print_lident_path lbl cmt_tbl;
            Doc.text ": ";
            (if optional then Doc.text "?" else Doc.nil);
            (let doc = print_expression_with_comments ~state expr cmt_tbl in
             match Parens.expr_record_row_rhs ~optional expr with
             | Parens.Parenthesized -> add_parens doc
             | Braced braces -> print_braces doc expr braces
             | Nothing -> doc);
          ])
  in
  print_comments doc cmt_tbl cmt_loc

and print_bs_object_row ~state (lbl, expr) cmt_tbl =
  let cmt_loc = {lbl.loc with loc_end = expr.pexp_loc.loc_end} in
  let lbl_doc =
    let doc =
      Doc.concat [Doc.text "\""; print_longident lbl.txt; Doc.text "\""]
    in
    print_comments doc cmt_tbl lbl.loc
  in
  let doc =
    Doc.concat
      [
        lbl_doc;
        Doc.text ": ";
        (let doc = print_expression_with_comments ~state expr cmt_tbl in
         match Parens.expr expr with
         | Parens.Parenthesized -> add_parens doc
         | Braced braces -> print_braces doc expr braces
         | Nothing -> doc);
      ]
  in
  print_comments doc cmt_tbl cmt_loc

and print_doc_comments ~state ?(sep = Doc.hard_line) cmt_tbl attrs =
  Doc.concat
    [
      Doc.group
        (Doc.join_with_sep
           (List.map (fun attr -> print_attribute ~state attr cmt_tbl) attrs));
      sep;
    ]

(* The optional loc indicates whether we need to print the attributes in
 * relation to some location. In practise this means the following:
 *  `@attr type t = string` -> on the same line, print on the same line
 *  `@attr
 *   type t = string` -> attr is on prev line, print the attributes
 *   with a line break between, we respect the users' original layout *)
and print_attributes ?loc ?(inline = false) ~state
    (attrs : Parsetree.attributes) cmt_tbl =
  match attrs with
  | [] -> Doc.nil
  | attrs ->
    let comment_attrs, attrs =
      Parsetree_viewer.partition_doc_comment_attributes attrs
    in
    let line_break =
      match loc with
      | None -> Doc.line
      | Some loc -> (
        match List.rev attrs with
        | ({loc = first_loc}, _) :: _
          when loc.loc_start.pos_lnum > first_loc.loc_end.pos_lnum ->
          Doc.hard_line
        | _ ->
          let has_comment_attrs = not (comment_attrs = []) in
          if has_comment_attrs then Doc.space else Doc.line)
    in
    let comment_doc =
      match comment_attrs with
      | [] -> Doc.nil
      | comment_attrs -> print_doc_comments ~state cmt_tbl comment_attrs
    in
    let attrs_doc =
      match attrs with
      | [] -> Doc.nil
      | _ ->
        Doc.concat
          [
            (* A doc comment here follows an attribute and stays on its line *)
            Doc.group
              (Doc.join ~sep:Doc.line
                 (List.map
                    (fun attr -> fst (print_attribute ~state attr cmt_tbl))
                    attrs));
            (if inline then Doc.space else line_break);
          ]
    in
    Doc.concat [comment_doc; attrs_doc]

and print_payload ~state (payload : Parsetree.payload) cmt_tbl =
  match payload with
  | PStr [] -> Doc.nil
  | PStr [{pstr_desc = Pstr_eval (expr, attrs)}] ->
    let expr_doc =
      print_expression_with_comments_and_parens ~state expr cmt_tbl
    in
    let needs_parens =
      match attrs with
      | [] -> false
      | _ -> true
    in
    let should_hug = Parsetree_viewer.is_huggable_expression expr in
    if should_hug then
      Doc.concat
        [
          Doc.lparen;
          print_attributes ~state attrs cmt_tbl;
          (if needs_parens then add_parens expr_doc else expr_doc);
          Doc.rparen;
        ]
    else
      Doc.concat
        [
          Doc.lparen;
          Doc.indent
            (Doc.concat
               [
                 Doc.soft_line;
                 print_attributes ~state attrs cmt_tbl;
                 (if needs_parens then add_parens expr_doc else expr_doc);
               ]);
          Doc.soft_line;
          Doc.rparen;
        ]
  | PStr [({pstr_desc = Pstr_value (_recFlag, _bindings)} as si)] ->
    add_parens (print_structure_item ~state si cmt_tbl)
  | PStr structure -> add_parens (print_structure ~state structure cmt_tbl)
  | PTyp typ ->
    Doc.concat
      [
        Doc.lparen;
        Doc.text ":";
        Doc.indent (Doc.concat [Doc.line; print_typ_expr ~state typ cmt_tbl]);
        Doc.soft_line;
        Doc.rparen;
      ]
  | PPat (pat, opt_expr) ->
    let when_doc =
      match opt_expr with
      | Some expr ->
        Doc.concat
          [
            Doc.line;
            Doc.text "if ";
            print_expression_with_comments_and_parens ~state expr cmt_tbl;
          ]
      | None -> Doc.nil
    in
    Doc.concat
      [
        Doc.lparen;
        Doc.indent
          (Doc.concat
             [
               Doc.soft_line;
               Doc.text "? ";
               print_pattern ~state pat cmt_tbl;
               when_doc;
             ]);
        Doc.soft_line;
        Doc.rparen;
      ]
  | PSig signature ->
    Doc.concat
      [
        Doc.lparen;
        Doc.text ":";
        Doc.indent
          (Doc.concat [Doc.line; print_signature ~state signature cmt_tbl]);
        Doc.soft_line;
        Doc.rparen;
      ]

and print_attribute ?(standalone = false) ~state
    ((id, payload) : Parsetree.attribute) cmt_tbl =
  match (id, payload) with
  | ( {txt = "res.doc"},
      PStr
        [
          {
            pstr_desc =
              Pstr_eval ({pexp_desc = Pexp_constant (Pconst_string payload)}, _);
          };
        ] ) ->
    ( Doc.concat
        [
          Doc.text (if standalone then "/***" else "/**");
          Doc.text (String_literal.string_semantic payload);
          Doc.text "*/";
        ],
      Doc.hard_line )
  | _ ->
    ( Doc.group
        (Doc.concat
           [
             Doc.text (if standalone then "@@" else "@");
             Doc.text id.txt;
             print_payload ~state payload cmt_tbl;
           ]),
      Doc.line )

and print_mod_expr ~state mod_expr cmt_tbl =
  let doc =
    match mod_expr.pmod_desc with
    | Pmod_ident longident_loc -> print_longident_location longident_loc cmt_tbl
    | Pmod_structure [] ->
      let should_break =
        mod_expr.pmod_loc.loc_start.pos_lnum
        < mod_expr.pmod_loc.loc_end.pos_lnum
      in
      Doc.breakable_group ~force_break:should_break
        (Doc.concat
           [
             Doc.lbrace;
             print_comments_inside cmt_tbl mod_expr.pmod_loc;
             Doc.rbrace;
           ])
    | Pmod_structure structure ->
      Doc.breakable_group ~force_break:true
        (Doc.concat
           [
             Doc.lbrace;
             Doc.indent
               (Doc.concat
                  [Doc.soft_line; print_structure ~state structure cmt_tbl]);
             Doc.soft_line;
             Doc.rbrace;
           ])
    | Pmod_unpack expr ->
      let should_hug =
        match (Parsetree_viewer.unwrap_braces expr).pexp_desc with
        | Pexp_let _ -> true
        | Pexp_constraint (inner, {ptyp_desc = Ptyp_package _})
          when Parsetree_viewer.is_block_expr inner ->
          true
        | _ -> false
      in
      let expr, module_constraint =
        match expr.pexp_desc with
        | Pexp_constraint
            (expr, {ptyp_desc = Ptyp_package package_type; ptyp_loc}) ->
          let package_doc =
            let doc =
              print_package_type ~state ~print_module_keyword_and_parens:false
                package_type cmt_tbl
            in
            print_comments doc cmt_tbl ptyp_loc
          in
          let type_doc =
            Doc.group
              (Doc.concat
                 [Doc.text ":"; Doc.indent (Doc.concat [Doc.line; package_doc])])
          in
          (expr, type_doc)
        | _ -> (expr, Doc.nil)
      in
      let unpack_doc =
        Doc.group
          (Doc.concat
             [
               print_expression_with_comments_and_parens ~state expr cmt_tbl;
               module_constraint;
             ])
      in
      Doc.group
        (Doc.concat
           [
             Doc.text "unpack(";
             (if should_hug then unpack_doc
              else
                Doc.concat
                  [
                    Doc.indent (Doc.concat [Doc.soft_line; unpack_doc]);
                    Doc.soft_line;
                  ]);
             Doc.rparen;
           ])
    | Pmod_extension extension ->
      print_extension ~state ~at_module_lvl:false extension cmt_tbl
    | Pmod_apply _ ->
      let args, call_expr = Parsetree_viewer.mod_expr_apply mod_expr in
      let is_unit_sugar =
        match args with
        | [{pmod_desc = Pmod_structure []; pmod_attributes = []}] -> true
        | _ -> false
      in
      let should_hug =
        match args with
        | [
         {
           pmod_desc =
             Pmod_structure _ | Pmod_await {pmod_desc = Pmod_structure _};
         };
        ] ->
          true
        | _ -> false
      in
      let call_expr_doc =
        let doc = print_mod_expr ~state call_expr cmt_tbl in
        if Parens.mod_apply_callee call_expr then add_mod_expr_parens doc
        else doc
      in
      Doc.group
        (Doc.concat
           [
             call_expr_doc;
             (if is_unit_sugar then
                print_mod_apply_arg ~state
                  (List.hd args [@doesNotRaise])
                  cmt_tbl
              else
                Doc.concat
                  [
                    Doc.lparen;
                    (if should_hug then
                       print_mod_apply_arg ~state
                         (List.hd args [@doesNotRaise])
                         cmt_tbl
                     else
                       Doc.indent
                         (Doc.concat
                            [
                              Doc.soft_line;
                              Doc.join
                                ~sep:(Doc.concat [Doc.comma; Doc.line])
                                (List.map
                                   (fun mod_arg ->
                                     print_mod_apply_arg ~state mod_arg cmt_tbl)
                                   args);
                            ]));
                    (if not should_hug then
                       Doc.concat [Doc.trailing_comma; Doc.soft_line]
                     else Doc.nil);
                    Doc.rparen;
                  ]);
           ])
    | Pmod_constraint (inner, mod_type) ->
      let doc =
        Doc.concat
          [
            print_mod_expr ~state inner cmt_tbl;
            Doc.text ": ";
            print_mod_type ~state mod_type cmt_tbl;
          ]
      in
      (* [@attr (M: S)]: without parens, the attributes would apply to [M] *)
      if Parsetree_viewer.mod_expr_has_attributes mod_expr then
        add_mod_expr_parens doc
      else doc
    | Pmod_functor _ -> print_mod_functor ~state mod_expr cmt_tbl
    | Pmod_await inner ->
      let inner_doc = print_mod_expr ~state inner cmt_tbl in
      let inner_doc =
        if Parens.mod_await_operand inner then add_mod_expr_parens inner_doc
        else inner_doc
      in
      (* [@attr await M] does not parse: an await's attributes come after
         [await], like a functor's on its first parameter *)
      Doc.concat
        [
          Doc.text "await ";
          print_mod_expr_attributes ~state mod_expr cmt_tbl;
          inner_doc;
        ]
  in
  let doc =
    match mod_expr.pmod_desc with
    (* A functor's attributes belong to its first parameter, see
       [print_mod_functor], an await's are printed above *)
    | Pmod_functor _ | Pmod_await _ -> doc
    | _ -> Doc.concat [print_mod_expr_attributes ~state mod_expr cmt_tbl; doc]
  in
  print_comments doc cmt_tbl mod_expr.pmod_loc

and print_mod_functor ~state mod_expr cmt_tbl =
  let parameters, return_mod_expr =
    Parsetree_viewer.mod_expr_functor mod_expr
  in
  let return_constraint, return_mod_expr =
    match return_mod_expr.pmod_desc with
    | Pmod_constraint (mod_expr, mod_type)
      when not (Parsetree_viewer.mod_expr_has_attributes return_mod_expr) ->
      let constraint_doc =
        let doc = print_mod_type ~state mod_type cmt_tbl in
        if Parens.mod_expr_functor_constraint mod_type then add_parens doc
        else doc
      in
      let mod_constraint = Doc.concat [Doc.text ": "; constraint_doc] in
      (mod_constraint, print_mod_expr_constraint_parens ~state mod_expr cmt_tbl)
    | _ -> (Doc.nil, print_mod_expr ~state return_mod_expr cmt_tbl)
  in
  let parameters_doc =
    match parameters with
    | [(attrs, {txt = "*"}, None)] ->
      Doc.group
        (Doc.concat [print_attributes ~state attrs cmt_tbl; Doc.text "()"])
    | [([], {txt = lbl}, None)] -> Doc.text lbl
    | parameters ->
      Doc.group
        (Doc.concat
           [
             Doc.lparen;
             Doc.indent
               (Doc.concat
                  [
                    Doc.soft_line;
                    Doc.join
                      ~sep:(Doc.concat [Doc.comma; Doc.line])
                      (List.map
                         (fun param ->
                           print_mod_functor_param ~state param cmt_tbl)
                         parameters);
                  ]);
             Doc.trailing_comma;
             Doc.soft_line;
             Doc.rparen;
           ])
  in
  Doc.group
    (Doc.concat
       [parameters_doc; return_constraint; Doc.text " => "; return_mod_expr])

and print_mod_functor_param ~state (attrs, lbl, opt_mod_type) cmt_tbl =
  let cmt_loc =
    match opt_mod_type with
    | None -> lbl.Asttypes.loc
    | Some mod_type ->
      {lbl.loc with loc_end = mod_type.Parsetree.pmty_loc.loc_end}
  in
  let attrs = print_attributes ~state attrs cmt_tbl in
  let lbl_doc =
    let doc = if lbl.txt = "*" then Doc.text "()" else Doc.text lbl.txt in
    print_comments doc cmt_tbl lbl.loc
  in
  let doc =
    Doc.group
      (Doc.concat
         [
           attrs;
           lbl_doc;
           (match opt_mod_type with
           | None -> Doc.nil
           | Some mod_type ->
             Doc.concat [Doc.text ": "; print_mod_type ~state mod_type cmt_tbl]);
         ])
  in
  print_comments doc cmt_tbl cmt_loc

(* A module expression's attributes, doc comments first, on one line with
   it: unlike before a declaration, a line break here would leave the module
   at the start of the next line *)
and print_mod_expr_attributes ~state (mod_expr : Parsetree.module_expr) cmt_tbl
    =
  match mod_expr.pmod_attributes with
  | [] -> Doc.nil
  | attrs ->
    let doc_comments, attrs =
      Parsetree_viewer.partition_doc_comment_attributes attrs
    in
    Doc.concat
      (List.map
         (fun attr ->
           Doc.concat [fst (print_attribute ~state attr cmt_tbl); Doc.space])
         (doc_comments @ attrs))

and print_mod_apply_arg ~state mod_expr cmt_tbl =
  match mod_expr with
  | {pmod_desc = Pmod_structure []; pmod_attributes = []} -> Doc.text "()"
  | _ ->
    let doc = print_mod_expr ~state mod_expr cmt_tbl in
    (* The parser doesn't accept a doc comment at the start of an argument *)
    if mod_expr_starts_with_doc_comment mod_expr then add_mod_expr_parens doc
    else doc

(* A constraint without attributes needs parens where [M: S] would not parse
   or would mean something else: after [module M: T =], in a functor's
   result, after [module type of] and inside [module(...)]. With attributes
   it prints its own. *)
and print_mod_expr_constraint_parens ~state mod_expr cmt_tbl =
  let doc = print_mod_expr ~state mod_expr cmt_tbl in
  if Parens.mod_constraint mod_expr then add_mod_expr_parens doc else doc

and print_exception_def ~state (constr : Parsetree.extension_constructor)
    cmt_tbl =
  let kind =
    match constr.pext_kind with
    | Pext_rebind longident ->
      Doc.indent
        (Doc.concat
           [Doc.text " ="; Doc.line; print_longident_location longident cmt_tbl])
    | Pext_decl (Pcstr_tuple [], None) -> Doc.nil
    | Pext_decl (args, gadt) ->
      let gadt_doc =
        match gadt with
        | Some typ ->
          Doc.concat [Doc.text ": "; print_typ_expr ~state typ cmt_tbl]
        | None -> Doc.nil
      in
      Doc.concat
        [
          print_constructor_arguments ~name_loc:constr.pext_name.loc ~state
            ~indent:false args cmt_tbl;
          gadt_doc;
        ]
  in
  let name =
    print_comments (Doc.text constr.pext_name.txt) cmt_tbl constr.pext_name.loc
  in
  let doc =
    Doc.group
      (Doc.concat
         [
           print_attributes ~state constr.pext_attributes cmt_tbl;
           Doc.text "exception ";
           name;
           kind;
         ])
  in
  print_comments doc cmt_tbl constr.pext_loc

and print_extension_constructor ~state
    (constr : Parsetree.extension_constructor) cmt_tbl i =
  let attrs = print_attributes ~state constr.pext_attributes cmt_tbl in
  let bar =
    if i > 0 then Doc.text "| " else Doc.if_breaks (Doc.text "| ") Doc.nil
  in
  let kind =
    match constr.pext_kind with
    | Pext_rebind longident ->
      Doc.indent
        (Doc.concat
           [Doc.text " ="; Doc.line; print_longident_location longident cmt_tbl])
    | Pext_decl (Pcstr_tuple [], None) -> Doc.nil
    | Pext_decl (args, gadt) ->
      let gadt_doc =
        match gadt with
        | Some typ ->
          Doc.concat [Doc.text ": "; print_typ_expr ~state typ cmt_tbl]
        | None -> Doc.nil
      in
      Doc.concat
        [
          print_constructor_arguments ~name_loc:constr.pext_name.loc ~state
            ~indent:false args cmt_tbl;
          gadt_doc;
        ]
  in
  let name =
    print_comments (Doc.text constr.pext_name.txt) cmt_tbl constr.pext_name.loc
  in
  Doc.concat [bar; Doc.group (Doc.concat [attrs; name; kind])]

let print_type_params params = print_type_params ~state:(State.init ()) params
let print_typ_expr t = print_typ_expr ~state:(State.init ()) t
let print_expression e = print_expression ~state:(State.init ()) e
let print_pattern p = print_pattern ~state:(State.init ()) p
let print_attribute a t = fst (print_attribute ~state:(State.init ()) a t)

let implementation_doc (s : Parsetree.structure) ~comments =
  let cmt_tbl = Comment_table.make () in
  Comment_table.walk_structure s cmt_tbl comments;
  print_structure ~state:(State.init ()) s cmt_tbl

let interface_doc (s : Parsetree.signature) ~comments =
  let cmt_tbl = Comment_table.make () in
  Comment_table.walk_signature s cmt_tbl comments;
  print_signature ~state:(State.init ()) s cmt_tbl

let print_implementation ?(width = default_print_width) ?(newline = "\n")
    (s : Parsetree.structure) ~comments =
  Doc.to_string ~newline ~width (implementation_doc s ~comments) ^ newline

let print_interface ?(width = default_print_width) ?(newline = "\n")
    (s : Parsetree.signature) ~comments =
  Doc.to_string ~newline ~width (interface_doc s ~comments) ^ newline

let print_structure s t = print_structure ~state:(State.init ()) s t