Napkinscript.re

module MiniBuffer: {
  type t;
  let add_char: (t, char) => unit;
  let add_string: (t, string) => unit;
  let contents: t => string;
  let create: int => t;
  let flush_newline: t => unit;
  let length: t => int;
  let unsafe_get: (t, int) => char;
} = {
  type t = {
    mutable buffer: bytes,
    mutable position: int,
    mutable length: int,
  };

  let create = n => {
    let n =
      if (n < 1) {
        1;
      } else {
        n;
      };
    let s = ([@doesNotRaise] Bytes.create)(n);
    {buffer: s, position: 0, length: n};
  };

  let contents = b => Bytes.sub_string(b.buffer, 0, b.position);

  let unsafe_get = (b, ofs) => Bytes.unsafe_get(b.buffer, ofs);

  let length = b => b.position;

  /* Can't be called directly, don't add to the interface */
  let resize_internal = (b, more) => {
    let len = b.length;
    let new_len = ref(len);
    while (b.position + more > new_len^) {
      new_len := 2 * new_len^;
    };
    if (new_len^ > Sys.max_string_length) {
      if (b.position + more <= Sys.max_string_length) {
        new_len := Sys.max_string_length;
      };
    };
    let new_buffer = ([@doesNotRaise] Bytes.create)(new_len^);
    /* PR#6148: let's keep using [blit] rather than [unsafe_blit] in
       this tricky function that is slow anyway. */
    [@doesNotRaise] Bytes.blit(b.buffer, 0, new_buffer, 0, b.position);
    b.buffer = new_buffer;
    b.length = new_len^;
  };

  let add_char = (b, c) => {
    let pos = b.position;
    if (pos >= b.length) {
      resize_internal(b, 1);
    };
    Bytes.unsafe_set(b.buffer, pos, c);
    b.position = pos + 1;
  };

  let add_string = (b, s) => {
    let len = String.length(s);
    let new_position = b.position + len;
    if (new_position > b.length) {
      resize_internal(b, len);
    };
    [@doesNotRaise] Bytes.blit_string(s, 0, b.buffer, b.position, len);
    b.position = new_position;
  };

  /* adds newline and trims all preceding whitespace */
  let flush_newline = b => {
    let position = ref(b.position);
    while (Bytes.unsafe_get(b.buffer, position^ - 1) == ' ' && position^ >= 0) {
      position := position^ - 1;
    };
    b.position = position^;
    add_char(b, '\n');
  };
};

module Doc = {
  type mode =
    | Break
    | Flat;

  type lineStyle =
    | Classic /* fits? -> replace with space */
    | Soft /* fits? -> replaced with nothing */
    | Hard; /* always included, forces breaks in parents */

  type t =
    | Nil
    | Text(string)
    | Concat(list(t))
    | Indent(t)
    | IfBreaks({
        yes: t,
        no: t,
      })
    | LineSuffix(t)
    | LineBreak(lineStyle)
    | Group({
        shouldBreak: bool,
        doc: t,
      })
    | CustomLayout(list(t))
    | BreakParent;
  /* | Cursor */

  let nil = Nil;
  let line = LineBreak(Classic);
  let hardLine = LineBreak(Hard);
  let softLine = LineBreak(Soft);
  let text = s => Text(s);
  let concat = l => Concat(l);
  let indent = d => Indent(d);
  let ifBreaks = (t, f) => IfBreaks({yes: t, no: f});
  let lineSuffix = d => LineSuffix(d);
  let group = d => Group({shouldBreak: false, doc: d});
  let breakableGroup = (~forceBreak, d) =>
    Group({shouldBreak: forceBreak, doc: d});
  let customLayout = gs => CustomLayout(gs);
  let breakParent = BreakParent;
  /* let cursor = Cursor */

  let space = Text(" ");
  let comma = Text(",");
  let dot = Text(".");
  let dotdot = Text("..");
  let dotdotdot = Text("...");
  let lessThan = Text("<");
  let greaterThan = Text(">");
  let lbrace = Text("{");
  let rbrace = Text("}");
  let lparen = Text("(");
  let rparen = Text(")");
  let lbracket = Text("[");
  let rbracket = Text("]");
  let question = Text("?");
  let tilde = Text("~");
  let equal = Text("=");
  let trailingComma = IfBreaks({yes: comma, no: nil});
  let doubleQuote = Text("\"");

  let propagateForcedBreaks = doc => {
    let rec walk = doc =>
      switch (doc) {
      | Text(_)
      | Nil
      | LineSuffix(_) => (false, doc)
      | BreakParent => (true, Nil)
      | LineBreak(Hard) => (true, doc)
      | LineBreak(Classic | Soft) => (false, doc)
      | Indent(children) =>
        let (childForcesBreak, newChildren) = walk(children);
        (childForcesBreak, Indent(newChildren));
      | IfBreaks({yes: trueDoc, no: falseDoc}) =>
        let (falseForceBreak, falseDoc) = walk(falseDoc);
        if (falseForceBreak) {
          let (_, trueDoc) = walk(trueDoc);
          (true, trueDoc);
        } else {
          let (forceBreak, trueDoc) = walk(trueDoc);
          (forceBreak, IfBreaks({yes: trueDoc, no: falseDoc}));
        };
      | Group({shouldBreak: forceBreak, doc: children}) =>
        let (childForcesBreak, newChildren) = walk(children);
        let shouldBreak = forceBreak || childForcesBreak;
        (shouldBreak, Group({shouldBreak, doc: newChildren}));
      | Concat(children) =>
        let (forceBreak, newChildren) =
          List.fold_left(
            ((forceBreak, newChildren), child) => {
              let (childForcesBreak, newChild) = walk(child);
              (forceBreak || childForcesBreak, [newChild, ...newChildren]);
            },
            (false, []),
            children,
          );

        (forceBreak, Concat(List.rev(newChildren)));
      | CustomLayout(children) =>
        /* When using CustomLayout, we don't want to propagate forced breaks
         * from the children up. By definition it picks the first layout that fits
         * otherwise it takes the last of the list.
         * However we do want to propagate forced breaks in the sublayouts. They
         * might need to be broken. We just don't propagate them any higher here */
        let children =
          switch (walk(Concat(children))) {
          | (_, Concat(children)) => children
          | _ => assert(false)
          };

        (false, CustomLayout(children));
      };

    let (_, processedDoc) = walk(doc);
    processedDoc;
  };

  let join = (~sep, docs) => {
    let rec loop = (acc, sep, docs) =>
      switch (docs) {
      | [] => List.rev(acc)
      | [x] => List.rev([x, ...acc])
      | [x, ...xs] => loop([sep, x, ...acc], sep, xs)
      };

    Concat(loop([], sep, docs));
  };

  let rec fits = (w, doc) =>
    switch (doc) {
    | _ when w < 0 => false
    | [] => true
    | [(_ind, _mode, Text(txt)), ...rest] =>
      fits(w - String.length(txt), rest)
    | [(ind, mode, Indent(doc)), ...rest] =>
      fits(w, [(ind + 2, mode, doc), ...rest])
    | [(_ind, Flat, LineBreak(break)), ...rest] =>
      if (break == Hard) {
        true;
      } else {
        let w =
          if (break == Classic) {
            w - 1;
          } else {
            w;
          };
        fits(w, rest);
      }
    | [(_ind, _mode, Nil), ...rest] => fits(w, rest)
    | [(_ind, Break, LineBreak(_break)), ..._rest] => true
    | [(ind, mode, Group({shouldBreak: forceBreak, doc})), ...rest] =>
      let mode = if (forceBreak) {Break} else {mode};
      fits(w, [(ind, mode, doc), ...rest]);
    | [(ind, mode, IfBreaks({yes: breakDoc, no: flatDoc})), ...rest] =>
      if (mode == Break) {
        fits(w, [(ind, mode, breakDoc), ...rest]);
      } else {
        fits(w, [(ind, mode, flatDoc), ...rest]);
      }
    | [(ind, mode, Concat(docs)), ...rest] =>
      let ops = List.map(doc => (ind, mode, doc), docs);
      fits(w, List.append(ops, rest));
    /* | (_ind, _mode, Cursor)::rest -> fits w rest */
    | [(_ind, _mode, LineSuffix(_)), ...rest] => fits(w, rest)
    | [(_ind, _mode, BreakParent), ...rest] => fits(w, rest)
    | [(ind, mode, CustomLayout([hd, ..._])), ...rest] =>
      /* TODO: if we have nested custom layouts, what we should do here? */
      fits(w, [(ind, mode, hd), ...rest])
    | [(_ind, _mode, CustomLayout(_)), ...rest] => fits(w, rest)
    };

  let toString = (~width, doc) => {
    let doc = propagateForcedBreaks(doc);
    let buffer = MiniBuffer.create(1000);

    let rec process = (~pos, lineSuffices, stack) =>
      switch (stack) {
      | [(ind, mode, doc) as cmd, ...rest] =>
        switch (doc) {
        | Nil
        | BreakParent => process(~pos, lineSuffices, rest)
        | Text(txt) =>
          MiniBuffer.add_string(buffer, txt);
          process(~pos=String.length(txt) + pos, lineSuffices, rest);
        | LineSuffix(doc) =>
          process(~pos, [(ind, mode, doc), ...lineSuffices], rest)
        | Concat(docs) =>
          let ops = List.map(doc => (ind, mode, doc), docs);
          process(~pos, lineSuffices, List.append(ops, rest));
        | Indent(doc) =>
          process(~pos, lineSuffices, [(ind + 2, mode, doc), ...rest])
        | IfBreaks({yes: breakDoc, no: flatDoc}) =>
          if (mode == Break) {
            process(~pos, lineSuffices, [(ind, mode, breakDoc), ...rest]);
          } else {
            process(~pos, lineSuffices, [(ind, mode, flatDoc), ...rest]);
          }
        | LineBreak(lineStyle) =>
          if (mode == Break) {
            switch (lineSuffices) {
            | [] =>
              MiniBuffer.flush_newline(buffer);
              MiniBuffer.add_string(
                buffer,
                [@doesNotRaise] String.make(ind, ' '),
              );
              process(~pos=ind, [], rest);
            | _docs =>
              process(
                ~pos=ind,
                [],
                List.concat([List.rev(lineSuffices), [cmd, ...rest]]),
              )
            };
          } else /* mode = Flat */ {
            let pos =
              switch (lineStyle) {
              | Classic =>
                MiniBuffer.add_string(buffer, " ");
                pos + 1;
              | Hard =>
                MiniBuffer.flush_newline(buffer);
                0;
              | Soft => pos
              };

            process(~pos, lineSuffices, rest);
          }
        | Group({shouldBreak, doc}) =>
          if (shouldBreak || !fits(width - pos, [(ind, Flat, doc), ...rest])) {
            process(~pos, lineSuffices, [(ind, Break, doc), ...rest]);
          } else {
            process(~pos, lineSuffices, [(ind, Flat, doc), ...rest]);
          }
        | CustomLayout(docs) =>
          let rec findGroupThatFits = groups =>
            switch (groups) {
            | [] => Nil
            | [lastGroup] => lastGroup
            | [doc, ...docs] =>
              if (fits(width - pos, [(ind, Flat, doc), ...rest])) {
                doc;
              } else {
                findGroupThatFits(docs);
              }
            };

          let doc = findGroupThatFits(docs);
          process(~pos, lineSuffices, [(ind, Flat, doc), ...rest]);
        }
      | [] =>
        switch (lineSuffices) {
        | [] => ()
        | suffices => process(~pos=0, [], List.rev(suffices))
        }
      };

    process(~pos=0, [], [(0, Flat, doc)]);

    let len = MiniBuffer.length(buffer);
    if (len > 0 && MiniBuffer.unsafe_get(buffer, len - 1) !== '\n') {
      MiniBuffer.add_char(buffer, '\n');
    };
    MiniBuffer.contents(buffer);
  };

  [@live]
  let debug = t => {
    let rec toDoc =
      fun
      | Nil => text("nil")
      | BreakParent => text("breakparent")
      | Text(txt) => text("text(" ++ txt ++ ")")
      | LineSuffix(doc) =>
        group(
          concat([
            text("linesuffix("),
            indent(concat([line, toDoc(doc)])),
            line,
            text(")"),
          ]),
        )
      | Concat(docs) =>
        group(
          concat([
            text("concat("),
            indent(
              concat([
                line,
                join(
                  ~sep=concat([text(","), line]),
                  List.map(toDoc, docs),
                ),
              ]),
            ),
            line,
            text(")"),
          ]),
        )
      | CustomLayout(docs) =>
        group(
          concat([
            text("customLayout("),
            indent(
              concat([
                line,
                join(
                  ~sep=concat([text(","), line]),
                  List.map(toDoc, docs),
                ),
              ]),
            ),
            line,
            text(")"),
          ]),
        )
      | Indent(doc) =>
        concat([
          text("indent("),
          softLine,
          toDoc(doc),
          softLine,
          text(")"),
        ])
      | IfBreaks({yes: trueDoc, no: falseDoc}) =>
        group(
          concat([
            text("ifBreaks("),
            indent(
              concat([
                line,
                toDoc(trueDoc),
                concat([text(","), line]),
                toDoc(falseDoc),
              ]),
            ),
            line,
            text(")"),
          ]),
        )
      | LineBreak(break) => {
          let breakTxt =
            switch (break) {
            | Classic => "Classic"
            | Soft => "Soft"
            | Hard => "Hard"
            };

          text("LineBreak(" ++ breakTxt ++ ")");
        }
      | Group({shouldBreak, doc}) =>
        group(
          concat([
            text("Group("),
            indent(
              concat([
                line,
                text("shouldBreak: " ++ string_of_bool(shouldBreak)),
                concat([text(","), line]),
                toDoc(doc),
              ]),
            ),
            line,
            text(")"),
          ]),
        );

    let doc = toDoc(t);
    toString(~width=10, doc) |> print_endline;
  };
};

module Sexp: {
  type t;

  let atom: string => t;
  let list: list(t) => t;
  let toString: t => string;
} = {
  type t =
    | Atom(string)
    | List(list(t));

  let atom = s => Atom(s);
  let list = l => List(l);

  let rec toDoc = t =>
    switch (t) {
    | Atom(s) => Doc.text(s)
    | List([]) => Doc.text("()")
    | List([sexpr]) => Doc.concat([Doc.lparen, toDoc(sexpr), Doc.rparen])
    | List([hd, ...tail]) =>
      Doc.group(
        Doc.concat([
          Doc.lparen,
          toDoc(hd),
          Doc.indent(
            Doc.concat([
              Doc.line,
              Doc.join(~sep=Doc.line, List.map(toDoc, tail)),
            ]),
          ),
          Doc.rparen,
        ]),
      )
    };

  let toString = sexpr => {
    let doc = toDoc(sexpr);
    Doc.toString(~width=80, doc);
  };
};

module SexpAst: {
  let implementation: Parsetree.structure => Sexp.t;
  let interface: Parsetree.signature => Sexp.t;
} = {
  open Parsetree;

  let mapEmpty = (~f, items) =>
    switch (items) {
    | [] => [Sexp.list([])]
    | items => List.map(f, items)
    };

  let string = txt => Sexp.atom("\"" ++ txt ++ "\"");

  let char = c => Sexp.atom("'" ++ Char.escaped(c) ++ "'");

  let optChar = oc =>
    switch (oc) {
    | None => Sexp.atom("None")
    | Some(c) => Sexp.list([Sexp.atom("Some"), char(c)])
    };

  let longident = l => {
    let rec loop = l =>
      switch (l) {
      | Longident.Lident(ident) =>
        Sexp.list([Sexp.atom("Lident"), string(ident)])
      | [@implicit_arity] Longident.Ldot(lident, txt) =>
        Sexp.list([Sexp.atom("Ldot"), loop(lident), string(txt)])
      | [@implicit_arity] Longident.Lapply(l1, l2) =>
        Sexp.list([Sexp.atom("Lapply"), loop(l1), loop(l2)])
      };

    Sexp.list([Sexp.atom("longident"), loop(l)]);
  };

  let closedFlag = flag =>
    switch (flag) {
    | Asttypes.Closed => Sexp.atom("Closed")
    | Open => Sexp.atom("Open")
    };

  let directionFlag = flag =>
    switch (flag) {
    | Asttypes.Upto => Sexp.atom("Upto")
    | Downto => Sexp.atom("Downto")
    };

  let recFlag = flag =>
    switch (flag) {
    | Asttypes.Recursive => Sexp.atom("Recursive")
    | Nonrecursive => Sexp.atom("Nonrecursive")
    };

  let overrideFlag = flag =>
    switch (flag) {
    | Asttypes.Override => Sexp.atom("Override")
    | Fresh => Sexp.atom("Fresh")
    };

  let privateFlag = flag =>
    switch (flag) {
    | Asttypes.Public => Sexp.atom("Public")
    | Private => Sexp.atom("Private")
    };

  let mutableFlag = flag =>
    switch (flag) {
    | Asttypes.Immutable => Sexp.atom("Immutable")
    | Mutable => Sexp.atom("Mutable")
    };

  let variance = v =>
    switch (v) {
    | Asttypes.Covariant => Sexp.atom("Covariant")
    | Contravariant => Sexp.atom("Contravariant")
    | Invariant => Sexp.atom("Invariant")
    };

  let argLabel = lbl =>
    switch (lbl) {
    | Asttypes.Nolabel => Sexp.atom("Nolabel")
    | Labelled(txt) => Sexp.list([Sexp.atom("Labelled"), string(txt)])
    | Optional(txt) => Sexp.list([Sexp.atom("Optional"), string(txt)])
    };

  let constant = c => {
    let sexpr =
      switch (c) {
      | [@implicit_arity] Pconst_integer(txt, tag) =>
        Sexp.list([Sexp.atom("Pconst_integer"), string(txt), optChar(tag)])
      | Pconst_char(c) =>
        Sexp.list([Sexp.atom("Pconst_char"), Sexp.atom(Char.escaped(c))])
      | [@implicit_arity] Pconst_string(txt, tag) =>
        Sexp.list([
          Sexp.atom("Pconst_string"),
          string(txt),
          switch (tag) {
          | Some(txt) => Sexp.list([Sexp.atom("Some"), string(txt)])
          | None => Sexp.atom("None")
          },
        ])
      | [@implicit_arity] Pconst_float(txt, tag) =>
        Sexp.list([Sexp.atom("Pconst_float"), string(txt), optChar(tag)])
      };

    Sexp.list([Sexp.atom("constant"), sexpr]);
  };

  let rec structure = s =>
    Sexp.list([Sexp.atom("structure"), ...List.map(structureItem, s)])

  and structureItem = si => {
    let desc =
      switch (si.pstr_desc) {
      | [@implicit_arity] Pstr_eval(expr, attrs) =>
        Sexp.list([
          Sexp.atom("Pstr_eval"),
          expression(expr),
          attributes(attrs),
        ])
      | [@implicit_arity] Pstr_value(flag, vbs) =>
        Sexp.list([
          Sexp.atom("Pstr_value"),
          recFlag(flag),
          Sexp.list(mapEmpty(~f=valueBinding, vbs)),
        ])
      | Pstr_primitive(vd) =>
        Sexp.list([Sexp.atom("Pstr_primitive"), valueDescription(vd)])
      | [@implicit_arity] Pstr_type(flag, tds) =>
        Sexp.list([
          Sexp.atom("Pstr_type"),
          recFlag(flag),
          Sexp.list(mapEmpty(~f=typeDeclaration, tds)),
        ])
      | Pstr_typext(typext) =>
        Sexp.list([Sexp.atom("Pstr_type"), typeExtension(typext)])
      | Pstr_exception(ec) =>
        Sexp.list([Sexp.atom("Pstr_exception"), extensionConstructor(ec)])
      | Pstr_module(mb) =>
        Sexp.list([Sexp.atom("Pstr_module"), moduleBinding(mb)])
      | Pstr_recmodule(mbs) =>
        Sexp.list([
          Sexp.atom("Pstr_recmodule"),
          Sexp.list(mapEmpty(~f=moduleBinding, mbs)),
        ])
      | Pstr_modtype(modTypDecl) =>
        Sexp.list([
          Sexp.atom("Pstr_modtype"),
          moduleTypeDeclaration(modTypDecl),
        ])
      | Pstr_open(openDesc) =>
        Sexp.list([Sexp.atom("Pstr_open"), openDescription(openDesc)])
      | Pstr_class(_) => Sexp.atom("Pstr_class")
      | Pstr_class_type(_) => Sexp.atom("Pstr_class_type")
      | Pstr_include(id) =>
        Sexp.list([Sexp.atom("Pstr_include"), includeDeclaration(id)])
      | Pstr_attribute(attr) =>
        Sexp.list([Sexp.atom("Pstr_attribute"), attribute(attr)])
      | [@implicit_arity] Pstr_extension(ext, attrs) =>
        Sexp.list([
          Sexp.atom("Pstr_extension"),
          extension(ext),
          attributes(attrs),
        ])
      };

    Sexp.list([Sexp.atom("structure_item"), desc]);
  }

  and includeDeclaration = id =>
    Sexp.list([
      Sexp.atom("include_declaration"),
      moduleExpression(id.pincl_mod),
      attributes(id.pincl_attributes),
    ])

  and openDescription = od =>
    Sexp.list([
      Sexp.atom("open_description"),
      longident(od.popen_lid.Asttypes.txt),
      attributes(od.popen_attributes),
    ])

  and moduleTypeDeclaration = mtd =>
    Sexp.list([
      Sexp.atom("module_type_declaration"),
      string(mtd.pmtd_name.Asttypes.txt),
      switch (mtd.pmtd_type) {
      | None => Sexp.atom("None")
      | Some(modType) =>
        Sexp.list([Sexp.atom("Some"), moduleType(modType)])
      },
      attributes(mtd.pmtd_attributes),
    ])

  and moduleBinding = mb =>
    Sexp.list([
      Sexp.atom("module_binding"),
      string(mb.pmb_name.Asttypes.txt),
      moduleExpression(mb.pmb_expr),
      attributes(mb.pmb_attributes),
    ])

  and moduleExpression = me => {
    let desc =
      switch (me.pmod_desc) {
      | Pmod_ident(modName) =>
        Sexp.list([
          Sexp.atom("Pmod_ident"),
          longident(modName.Asttypes.txt),
        ])
      | Pmod_structure(s) =>
        Sexp.list([Sexp.atom("Pmod_structure"), structure(s)])
      | [@implicit_arity] Pmod_functor(lbl, optModType, modExpr) =>
        Sexp.list([
          Sexp.atom("Pmod_functor"),
          string(lbl.Asttypes.txt),
          switch (optModType) {
          | None => Sexp.atom("None")
          | Some(modType) =>
            Sexp.list([Sexp.atom("Some"), moduleType(modType)])
          },
          moduleExpression(modExpr),
        ])
      | [@implicit_arity] Pmod_apply(callModExpr, modExprArg) =>
        Sexp.list([
          Sexp.atom("Pmod_apply"),
          moduleExpression(callModExpr),
          moduleExpression(modExprArg),
        ])
      | [@implicit_arity] Pmod_constraint(modExpr, modType) =>
        Sexp.list([
          Sexp.atom("Pmod_constraint"),
          moduleExpression(modExpr),
          moduleType(modType),
        ])
      | Pmod_unpack(expr) =>
        Sexp.list([Sexp.atom("Pmod_unpack"), expression(expr)])
      | Pmod_extension(ext) =>
        Sexp.list([Sexp.atom("Pmod_extension"), extension(ext)])
      };

    Sexp.list([
      Sexp.atom("module_expr"),
      desc,
      attributes(me.pmod_attributes),
    ]);
  }

  and moduleType = mt => {
    let desc =
      switch (mt.pmty_desc) {
      | Pmty_ident(longidentLoc) =>
        Sexp.list([
          Sexp.atom("Pmty_ident"),
          longident(longidentLoc.Asttypes.txt),
        ])
      | Pmty_signature(s) =>
        Sexp.list([Sexp.atom("Pmty_signature"), signature(s)])
      | [@implicit_arity] Pmty_functor(lbl, optModType, modType) =>
        Sexp.list([
          Sexp.atom("Pmty_functor"),
          string(lbl.Asttypes.txt),
          switch (optModType) {
          | None => Sexp.atom("None")
          | Some(modType) =>
            Sexp.list([Sexp.atom("Some"), moduleType(modType)])
          },
          moduleType(modType),
        ])
      | Pmty_alias(longidentLoc) =>
        Sexp.list([
          Sexp.atom("Pmty_alias"),
          longident(longidentLoc.Asttypes.txt),
        ])
      | Pmty_extension(ext) =>
        Sexp.list([Sexp.atom("Pmty_extension"), extension(ext)])
      | Pmty_typeof(modExpr) =>
        Sexp.list([Sexp.atom("Pmty_typeof"), moduleExpression(modExpr)])
      | [@implicit_arity] Pmty_with(modType, withConstraints) =>
        Sexp.list([
          Sexp.atom("Pmty_with"),
          moduleType(modType),
          Sexp.list(mapEmpty(~f=withConstraint, withConstraints)),
        ])
      };

    Sexp.list([
      Sexp.atom("module_type"),
      desc,
      attributes(mt.pmty_attributes),
    ]);
  }

  and withConstraint = wc =>
    switch (wc) {
    | [@implicit_arity] Pwith_type(longidentLoc, td) =>
      Sexp.list([
        Sexp.atom("Pmty_with"),
        longident(longidentLoc.Asttypes.txt),
        typeDeclaration(td),
      ])
    | [@implicit_arity] Pwith_module(l1, l2) =>
      Sexp.list([
        Sexp.atom("Pwith_module"),
        longident(l1.Asttypes.txt),
        longident(l2.Asttypes.txt),
      ])
    | [@implicit_arity] Pwith_typesubst(longidentLoc, td) =>
      Sexp.list([
        Sexp.atom("Pwith_typesubst"),
        longident(longidentLoc.Asttypes.txt),
        typeDeclaration(td),
      ])
    | [@implicit_arity] Pwith_modsubst(l1, l2) =>
      Sexp.list([
        Sexp.atom("Pwith_modsubst"),
        longident(l1.Asttypes.txt),
        longident(l2.Asttypes.txt),
      ])
    }

  and signature = s =>
    Sexp.list([Sexp.atom("signature"), ...List.map(signatureItem, s)])

  and signatureItem = si => {
    let descr =
      switch (si.psig_desc) {
      | Psig_value(vd) =>
        Sexp.list([Sexp.atom("Psig_value"), valueDescription(vd)])
      | [@implicit_arity] Psig_type(flag, typeDeclarations) =>
        Sexp.list([
          Sexp.atom("Psig_type"),
          recFlag(flag),
          Sexp.list(mapEmpty(~f=typeDeclaration, typeDeclarations)),
        ])
      | Psig_typext(typExt) =>
        Sexp.list([Sexp.atom("Psig_typext"), typeExtension(typExt)])
      | Psig_exception(extConstr) =>
        Sexp.list([
          Sexp.atom("Psig_exception"),
          extensionConstructor(extConstr),
        ])
      | Psig_module(modDecl) =>
        Sexp.list([Sexp.atom("Psig_module"), moduleDeclaration(modDecl)])
      | Psig_recmodule(modDecls) =>
        Sexp.list([
          Sexp.atom("Psig_recmodule"),
          Sexp.list(mapEmpty(~f=moduleDeclaration, modDecls)),
        ])
      | Psig_modtype(modTypDecl) =>
        Sexp.list([
          Sexp.atom("Psig_modtype"),
          moduleTypeDeclaration(modTypDecl),
        ])
      | Psig_open(openDesc) =>
        Sexp.list([Sexp.atom("Psig_open"), openDescription(openDesc)])
      | Psig_include(inclDecl) =>
        Sexp.list([Sexp.atom("Psig_include"), includeDescription(inclDecl)])
      | Psig_class(_) => Sexp.list([Sexp.atom("Psig_class")])
      | Psig_class_type(_) => Sexp.list([Sexp.atom("Psig_class_type")])
      | Psig_attribute(attr) =>
        Sexp.list([Sexp.atom("Psig_attribute"), attribute(attr)])
      | [@implicit_arity] Psig_extension(ext, attrs) =>
        Sexp.list([
          Sexp.atom("Psig_extension"),
          extension(ext),
          attributes(attrs),
        ])
      };

    Sexp.list([Sexp.atom("signature_item"), descr]);
  }

  and includeDescription = id =>
    Sexp.list([
      Sexp.atom("include_description"),
      moduleType(id.pincl_mod),
      attributes(id.pincl_attributes),
    ])

  and moduleDeclaration = md =>
    Sexp.list([
      Sexp.atom("module_declaration"),
      string(md.pmd_name.Asttypes.txt),
      moduleType(md.pmd_type),
      attributes(md.pmd_attributes),
    ])

  and valueBinding = vb =>
    Sexp.list([
      Sexp.atom("value_binding"),
      pattern(vb.pvb_pat),
      expression(vb.pvb_expr),
      attributes(vb.pvb_attributes),
    ])

  and valueDescription = vd =>
    Sexp.list([
      Sexp.atom("value_description"),
      string(vd.pval_name.Asttypes.txt),
      coreType(vd.pval_type),
      Sexp.list(mapEmpty(~f=string, vd.pval_prim)),
      attributes(vd.pval_attributes),
    ])

  and typeDeclaration = td =>
    Sexp.list([
      Sexp.atom("type_declaration"),
      string(td.ptype_name.Asttypes.txt),
      Sexp.list([
        Sexp.atom("ptype_params"),
        Sexp.list(
          mapEmpty(
            ~f=
              ((typexpr, var)) =>
                Sexp.list([coreType(typexpr), variance(var)]),
            td.ptype_params,
          ),
        ),
      ]),
      Sexp.list([
        Sexp.atom("ptype_cstrs"),
        Sexp.list(
          mapEmpty(
            ~f=
              ((typ1, typ2, _loc)) =>
                Sexp.list([coreType(typ1), coreType(typ2)]),
            td.ptype_cstrs,
          ),
        ),
      ]),
      Sexp.list([Sexp.atom("ptype_kind"), typeKind(td.ptype_kind)]),
      Sexp.list([
        Sexp.atom("ptype_manifest"),
        switch (td.ptype_manifest) {
        | None => Sexp.atom("None")
        | Some(typ) => Sexp.list([Sexp.atom("Some"), coreType(typ)])
        },
      ]),
      Sexp.list([
        Sexp.atom("ptype_private"),
        privateFlag(td.ptype_private),
      ]),
      attributes(td.ptype_attributes),
    ])

  and extensionConstructor = ec =>
    Sexp.list([
      Sexp.atom("extension_constructor"),
      string(ec.pext_name.Asttypes.txt),
      extensionConstructorKind(ec.pext_kind),
      attributes(ec.pext_attributes),
    ])

  and extensionConstructorKind = kind =>
    switch (kind) {
    | [@implicit_arity] Pext_decl(args, optTypExpr) =>
      Sexp.list([
        Sexp.atom("Pext_decl"),
        constructorArguments(args),
        switch (optTypExpr) {
        | None => Sexp.atom("None")
        | Some(typ) => Sexp.list([Sexp.atom("Some"), coreType(typ)])
        },
      ])
    | Pext_rebind(longidentLoc) =>
      Sexp.list([
        Sexp.atom("Pext_rebind"),
        longident(longidentLoc.Asttypes.txt),
      ])
    }

  and typeExtension = te =>
    Sexp.list([
      Sexp.atom("type_extension"),
      Sexp.list([
        Sexp.atom("ptyext_path"),
        longident(te.ptyext_path.Asttypes.txt),
      ]),
      Sexp.list([
        Sexp.atom("ptyext_parms"),
        Sexp.list(
          mapEmpty(
            ~f=
              ((typexpr, var)) =>
                Sexp.list([coreType(typexpr), variance(var)]),
            te.ptyext_params,
          ),
        ),
      ]),
      Sexp.list([
        Sexp.atom("ptyext_constructors"),
        Sexp.list(mapEmpty(~f=extensionConstructor, te.ptyext_constructors)),
      ]),
      Sexp.list([
        Sexp.atom("ptyext_private"),
        privateFlag(te.ptyext_private),
      ]),
      attributes(te.ptyext_attributes),
    ])

  and typeKind = kind =>
    switch (kind) {
    | Ptype_abstract => Sexp.atom("Ptype_abstract")
    | Ptype_variant(constrDecls) =>
      Sexp.list([
        Sexp.atom("Ptype_variant"),
        Sexp.list(mapEmpty(~f=constructorDeclaration, constrDecls)),
      ])
    | Ptype_record(lblDecls) =>
      Sexp.list([
        Sexp.atom("Ptype_record"),
        Sexp.list(mapEmpty(~f=labelDeclaration, lblDecls)),
      ])
    | Ptype_open => Sexp.atom("Ptype_open")
    }

  and constructorDeclaration = cd =>
    Sexp.list([
      Sexp.atom("constructor_declaration"),
      string(cd.pcd_name.Asttypes.txt),
      Sexp.list([Sexp.atom("pcd_args"), constructorArguments(cd.pcd_args)]),
      Sexp.list([
        Sexp.atom("pcd_res"),
        switch (cd.pcd_res) {
        | None => Sexp.atom("None")
        | Some(typ) => Sexp.list([Sexp.atom("Some"), coreType(typ)])
        },
      ]),
      attributes(cd.pcd_attributes),
    ])

  and constructorArguments = args =>
    switch (args) {
    | Pcstr_tuple(types) =>
      Sexp.list([
        Sexp.atom("Pcstr_tuple"),
        Sexp.list(mapEmpty(~f=coreType, types)),
      ])
    | Pcstr_record(lds) =>
      Sexp.list([
        Sexp.atom("Pcstr_record"),
        Sexp.list(mapEmpty(~f=labelDeclaration, lds)),
      ])
    }

  and labelDeclaration = ld =>
    Sexp.list([
      Sexp.atom("label_declaration"),
      string(ld.pld_name.Asttypes.txt),
      mutableFlag(ld.pld_mutable),
      coreType(ld.pld_type),
      attributes(ld.pld_attributes),
    ])

  and expression = expr => {
    let desc =
      switch (expr.pexp_desc) {
      | Pexp_ident(longidentLoc) =>
        Sexp.list([
          Sexp.atom("Pexp_ident"),
          longident(longidentLoc.Asttypes.txt),
        ])
      | Pexp_constant(c) =>
        Sexp.list([Sexp.atom("Pexp_constant"), constant(c)])
      | [@implicit_arity] Pexp_let(flag, vbs, expr) =>
        Sexp.list([
          Sexp.atom("Pexp_let"),
          recFlag(flag),
          Sexp.list(mapEmpty(~f=valueBinding, vbs)),
          expression(expr),
        ])
      | Pexp_function(cases) =>
        Sexp.list([
          Sexp.atom("Pexp_function"),
          Sexp.list(mapEmpty(~f=case, cases)),
        ])
      | [@implicit_arity] Pexp_fun(argLbl, exprOpt, pat, expr) =>
        Sexp.list([
          Sexp.atom("Pexp_fun"),
          argLabel(argLbl),
          switch (exprOpt) {
          | None => Sexp.atom("None")
          | Some(expr) => Sexp.list([Sexp.atom("Some"), expression(expr)])
          },
          pattern(pat),
          expression(expr),
        ])
      | [@implicit_arity] Pexp_apply(expr, args) =>
        Sexp.list([
          Sexp.atom("Pexp_apply"),
          expression(expr),
          Sexp.list(
            mapEmpty(
              ~f=
                ((argLbl, expr)) =>
                  Sexp.list([argLabel(argLbl), expression(expr)]),
              args,
            ),
          ),
        ])
      | [@implicit_arity] Pexp_match(expr, cases) =>
        Sexp.list([
          Sexp.atom("Pexp_match"),
          expression(expr),
          Sexp.list(mapEmpty(~f=case, cases)),
        ])
      | [@implicit_arity] Pexp_try(expr, cases) =>
        Sexp.list([
          Sexp.atom("Pexp_try"),
          expression(expr),
          Sexp.list(mapEmpty(~f=case, cases)),
        ])
      | Pexp_tuple(exprs) =>
        Sexp.list([
          Sexp.atom("Pexp_tuple"),
          Sexp.list(mapEmpty(~f=expression, exprs)),
        ])
      | [@implicit_arity] Pexp_construct(longidentLoc, exprOpt) =>
        Sexp.list([
          Sexp.atom("Pexp_construct"),
          longident(longidentLoc.Asttypes.txt),
          switch (exprOpt) {
          | None => Sexp.atom("None")
          | Some(expr) => Sexp.list([Sexp.atom("Some"), expression(expr)])
          },
        ])
      | [@implicit_arity] Pexp_variant(lbl, exprOpt) =>
        Sexp.list([
          Sexp.atom("Pexp_variant"),
          string(lbl),
          switch (exprOpt) {
          | None => Sexp.atom("None")
          | Some(expr) => Sexp.list([Sexp.atom("Some"), expression(expr)])
          },
        ])
      | [@implicit_arity] Pexp_record(rows, optExpr) =>
        Sexp.list([
          Sexp.atom("Pexp_record"),
          Sexp.list(
            mapEmpty(
              ~f=
                ((longidentLoc, expr)) =>
                  Sexp.list([
                    longident(longidentLoc.Asttypes.txt),
                    expression(expr),
                  ]),
              rows,
            ),
          ),
          switch (optExpr) {
          | None => Sexp.atom("None")
          | Some(expr) => Sexp.list([Sexp.atom("Some"), expression(expr)])
          },
        ])
      | [@implicit_arity] Pexp_field(expr, longidentLoc) =>
        Sexp.list([
          Sexp.atom("Pexp_field"),
          expression(expr),
          longident(longidentLoc.Asttypes.txt),
        ])
      | [@implicit_arity] Pexp_setfield(expr1, longidentLoc, expr2) =>
        Sexp.list([
          Sexp.atom("Pexp_setfield"),
          expression(expr1),
          longident(longidentLoc.Asttypes.txt),
          expression(expr2),
        ])
      | Pexp_array(exprs) =>
        Sexp.list([
          Sexp.atom("Pexp_array"),
          Sexp.list(mapEmpty(~f=expression, exprs)),
        ])
      | [@implicit_arity] Pexp_ifthenelse(expr1, expr2, optExpr) =>
        Sexp.list([
          Sexp.atom("Pexp_ifthenelse"),
          expression(expr1),
          expression(expr2),
          switch (optExpr) {
          | None => Sexp.atom("None")
          | Some(expr) => Sexp.list([Sexp.atom("Some"), expression(expr)])
          },
        ])
      | [@implicit_arity] Pexp_sequence(expr1, expr2) =>
        Sexp.list([
          Sexp.atom("Pexp_sequence"),
          expression(expr1),
          expression(expr2),
        ])
      | [@implicit_arity] Pexp_while(expr1, expr2) =>
        Sexp.list([
          Sexp.atom("Pexp_while"),
          expression(expr1),
          expression(expr2),
        ])
      | [@implicit_arity] Pexp_for(pat, e1, e2, flag, e3) =>
        Sexp.list([
          Sexp.atom("Pexp_for"),
          pattern(pat),
          expression(e1),
          expression(e2),
          directionFlag(flag),
          expression(e3),
        ])
      | [@implicit_arity] Pexp_constraint(expr, typexpr) =>
        Sexp.list([
          Sexp.atom("Pexp_constraint"),
          expression(expr),
          coreType(typexpr),
        ])
      | [@implicit_arity] Pexp_coerce(expr, optTyp, typexpr) =>
        Sexp.list([
          Sexp.atom("Pexp_coerce"),
          expression(expr),
          switch (optTyp) {
          | None => Sexp.atom("None")
          | Some(typ) => Sexp.list([Sexp.atom("Some"), coreType(typ)])
          },
          coreType(typexpr),
        ])
      | Pexp_send(_) => Sexp.list([Sexp.atom("Pexp_send")])
      | Pexp_new(_) => Sexp.list([Sexp.atom("Pexp_new")])
      | Pexp_setinstvar(_) => Sexp.list([Sexp.atom("Pexp_setinstvar")])
      | Pexp_override(_) => Sexp.list([Sexp.atom("Pexp_override")])
      | [@implicit_arity] Pexp_letmodule(modName, modExpr, expr) =>
        Sexp.list([
          Sexp.atom("Pexp_letmodule"),
          string(modName.Asttypes.txt),
          moduleExpression(modExpr),
          expression(expr),
        ])
      | [@implicit_arity] Pexp_letexception(extConstr, expr) =>
        Sexp.list([
          Sexp.atom("Pexp_letexception"),
          extensionConstructor(extConstr),
          expression(expr),
        ])
      | Pexp_assert(expr) =>
        Sexp.list([Sexp.atom("Pexp_assert"), expression(expr)])
      | Pexp_lazy(expr) =>
        Sexp.list([Sexp.atom("Pexp_lazy"), expression(expr)])
      | Pexp_poly(_) => Sexp.list([Sexp.atom("Pexp_poly")])
      | Pexp_object(_) => Sexp.list([Sexp.atom("Pexp_object")])
      | [@implicit_arity] Pexp_newtype(lbl, expr) =>
        Sexp.list([
          Sexp.atom("Pexp_newtype"),
          string(lbl.Asttypes.txt),
          expression(expr),
        ])
      | Pexp_pack(modExpr) =>
        Sexp.list([Sexp.atom("Pexp_pack"), moduleExpression(modExpr)])
      | [@implicit_arity] Pexp_open(flag, longidentLoc, expr) =>
        Sexp.list([
          Sexp.atom("Pexp_open"),
          overrideFlag(flag),
          longident(longidentLoc.Asttypes.txt),
          expression(expr),
        ])
      | Pexp_extension(ext) =>
        Sexp.list([Sexp.atom("Pexp_extension"), extension(ext)])
      | Pexp_unreachable => Sexp.atom("Pexp_unreachable")
      };

    Sexp.list([Sexp.atom("expression"), desc]);
  }

  and case = c =>
    Sexp.list([
      Sexp.atom("case"),
      Sexp.list([Sexp.atom("pc_lhs"), pattern(c.pc_lhs)]),
      Sexp.list([
        Sexp.atom("pc_guard"),
        switch (c.pc_guard) {
        | None => Sexp.atom("None")
        | Some(expr) => Sexp.list([Sexp.atom("Some"), expression(expr)])
        },
      ]),
      Sexp.list([Sexp.atom("pc_rhs"), expression(c.pc_rhs)]),
    ])

  and pattern = p => {
    let descr =
      switch (p.ppat_desc) {
      | Ppat_any => Sexp.atom("Ppat_any")
      | Ppat_var(var) =>
        Sexp.list([Sexp.atom("Ppat_var"), string(var.Location.txt)])
      | [@implicit_arity] Ppat_alias(p, alias) =>
        Sexp.list([Sexp.atom("Ppat_alias"), pattern(p), string(alias.txt)])
      | Ppat_constant(c) =>
        Sexp.list([Sexp.atom("Ppat_constant"), constant(c)])
      | [@implicit_arity] Ppat_interval(lo, hi) =>
        Sexp.list([Sexp.atom("Ppat_interval"), constant(lo), constant(hi)])
      | Ppat_tuple(patterns) =>
        Sexp.list([
          Sexp.atom("Ppat_tuple"),
          Sexp.list(mapEmpty(~f=pattern, patterns)),
        ])
      | [@implicit_arity] Ppat_construct(longidentLoc, optPattern) =>
        Sexp.list([
          Sexp.atom("Ppat_construct"),
          longident(longidentLoc.Location.txt),
          switch (optPattern) {
          | None => Sexp.atom("None")
          | Some(p) => Sexp.list([Sexp.atom("some"), pattern(p)])
          },
        ])
      | [@implicit_arity] Ppat_variant(lbl, optPattern) =>
        Sexp.list([
          Sexp.atom("Ppat_variant"),
          string(lbl),
          switch (optPattern) {
          | None => Sexp.atom("None")
          | Some(p) => Sexp.list([Sexp.atom("Some"), pattern(p)])
          },
        ])
      | [@implicit_arity] Ppat_record(rows, flag) =>
        Sexp.list([
          Sexp.atom("Ppat_record"),
          closedFlag(flag),
          Sexp.list(
            mapEmpty(
              ~f=
                ((longidentLoc, p)) =>
                  Sexp.list([
                    longident(longidentLoc.Location.txt),
                    pattern(p),
                  ]),
              rows,
            ),
          ),
        ])
      | Ppat_array(patterns) =>
        Sexp.list([
          Sexp.atom("Ppat_array"),
          Sexp.list(mapEmpty(~f=pattern, patterns)),
        ])
      | [@implicit_arity] Ppat_or(p1, p2) =>
        Sexp.list([Sexp.atom("Ppat_or"), pattern(p1), pattern(p2)])
      | [@implicit_arity] Ppat_constraint(p, typexpr) =>
        Sexp.list([
          Sexp.atom("Ppat_constraint"),
          pattern(p),
          coreType(typexpr),
        ])
      | Ppat_type(longidentLoc) =>
        Sexp.list([
          Sexp.atom("Ppat_type"),
          longident(longidentLoc.Location.txt),
        ])
      | Ppat_lazy(p) => Sexp.list([Sexp.atom("Ppat_lazy"), pattern(p)])
      | Ppat_unpack(stringLoc) =>
        Sexp.list([
          Sexp.atom("Ppat_unpack"),
          string(stringLoc.Location.txt),
        ])
      | Ppat_exception(p) =>
        Sexp.list([Sexp.atom("Ppat_exception"), pattern(p)])
      | Ppat_extension(ext) =>
        Sexp.list([Sexp.atom("Ppat_extension"), extension(ext)])
      | [@implicit_arity] Ppat_open(longidentLoc, p) =>
        Sexp.list([
          Sexp.atom("Ppat_open"),
          longident(longidentLoc.Location.txt),
          pattern(p),
        ])
      };

    Sexp.list([Sexp.atom("pattern"), descr]);
  }

  and objectField = field =>
    switch (field) {
    | [@implicit_arity] Otag(lblLoc, attrs, typexpr) =>
      Sexp.list([
        Sexp.atom("Otag"),
        string(lblLoc.txt),
        attributes(attrs),
        coreType(typexpr),
      ])
    | Oinherit(typexpr) =>
      Sexp.list([Sexp.atom("Oinherit"), coreType(typexpr)])
    }

  and rowField = field =>
    switch (field) {
    | [@implicit_arity] Rtag(labelLoc, attrs, truth, types) =>
      Sexp.list([
        Sexp.atom("Rtag"),
        string(labelLoc.txt),
        attributes(attrs),
        Sexp.atom(if (truth) {"true"} else {"false"}),
        Sexp.list(mapEmpty(~f=coreType, types)),
      ])
    | Rinherit(typexpr) =>
      Sexp.list([Sexp.atom("Rinherit"), coreType(typexpr)])
    }

  and packageType = ((modNameLoc, packageConstraints)) =>
    Sexp.list([
      Sexp.atom("package_type"),
      longident(modNameLoc.Asttypes.txt),
      Sexp.list(
        mapEmpty(
          ~f=
            ((modNameLoc, typexpr)) =>
              Sexp.list([
                longident(modNameLoc.Asttypes.txt),
                coreType(typexpr),
              ]),
          packageConstraints,
        ),
      ),
    ])

  and coreType = typexpr => {
    let desc =
      switch (typexpr.ptyp_desc) {
      | Ptyp_any => Sexp.atom("Ptyp_any")
      | Ptyp_var(var) => Sexp.list([Sexp.atom("Ptyp_var"), string(var)])
      | [@implicit_arity] Ptyp_arrow(argLbl, typ1, typ2) =>
        Sexp.list([
          Sexp.atom("Ptyp_arrow"),
          argLabel(argLbl),
          coreType(typ1),
          coreType(typ2),
        ])
      | Ptyp_tuple(types) =>
        Sexp.list([
          Sexp.atom("Ptyp_tuple"),
          Sexp.list(mapEmpty(~f=coreType, types)),
        ])
      | [@implicit_arity] Ptyp_constr(longidentLoc, types) =>
        Sexp.list([
          Sexp.atom("Ptyp_constr"),
          longident(longidentLoc.txt),
          Sexp.list(mapEmpty(~f=coreType, types)),
        ])
      | [@implicit_arity] Ptyp_alias(typexpr, alias) =>
        Sexp.list([
          Sexp.atom("Ptyp_alias"),
          coreType(typexpr),
          string(alias),
        ])
      | [@implicit_arity] Ptyp_object(fields, flag) =>
        Sexp.list([
          Sexp.atom("Ptyp_object"),
          closedFlag(flag),
          Sexp.list(mapEmpty(~f=objectField, fields)),
        ])
      | [@implicit_arity] Ptyp_class(longidentLoc, types) =>
        Sexp.list([
          Sexp.atom("Ptyp_class"),
          longident(longidentLoc.Location.txt),
          Sexp.list(mapEmpty(~f=coreType, types)),
        ])
      | [@implicit_arity] Ptyp_variant(fields, flag, optLabels) =>
        Sexp.list([
          Sexp.atom("Ptyp_variant"),
          Sexp.list(mapEmpty(~f=rowField, fields)),
          closedFlag(flag),
          switch (optLabels) {
          | None => Sexp.atom("None")
          | Some(lbls) => Sexp.list(mapEmpty(~f=string, lbls))
          },
        ])
      | [@implicit_arity] Ptyp_poly(lbls, typexpr) =>
        Sexp.list([
          Sexp.atom("Ptyp_poly"),
          Sexp.list(mapEmpty(~f=lbl => string(lbl.Asttypes.txt), lbls)),
          coreType(typexpr),
        ])
      | Ptyp_package(package) =>
        Sexp.list([Sexp.atom("Ptyp_package"), packageType(package)])
      | Ptyp_extension(ext) =>
        Sexp.list([Sexp.atom("Ptyp_extension"), extension(ext)])
      };

    Sexp.list([Sexp.atom("core_type"), desc]);
  }

  and payload = p =>
    switch (p) {
    | PStr(s) =>
      Sexp.list([Sexp.atom("PStr"), ...mapEmpty(~f=structureItem, s)])
    | PSig(s) => Sexp.list([Sexp.atom("PSig"), signature(s)])
    | PTyp(ct) => Sexp.list([Sexp.atom("PTyp"), coreType(ct)])
    | [@implicit_arity] PPat(pat, optExpr) =>
      Sexp.list([
        Sexp.atom("PPat"),
        pattern(pat),
        switch (optExpr) {
        | Some(expr) => Sexp.list([Sexp.atom("Some"), expression(expr)])
        | None => Sexp.atom("None")
        },
      ])
    }

  and attribute = ((stringLoc, p)) =>
    Sexp.list([
      Sexp.atom("attribute"),
      Sexp.atom(stringLoc.Asttypes.txt),
      payload(p),
    ])

  and extension = ((stringLoc, p)) =>
    Sexp.list([
      Sexp.atom("extension"),
      Sexp.atom(stringLoc.Asttypes.txt),
      payload(p),
    ])

  and attributes = attrs => {
    let sexprs = mapEmpty(~f=attribute, attrs);
    Sexp.list([Sexp.atom("attributes"), ...sexprs]);
  };

  let implementation = structure;
  let interface = signature;
};

module IO: {
  let readFile: string => string;
  let readStdin: unit => string;
} = {
  /* random chunk size: 2^15, TODO: why do we guess randomly? */
  let chunkSize = 32768;

  let readFile = filename => {
    let chan = open_in(filename);
    let buffer = Buffer.create(chunkSize);
    let chunk = ([@doesNotRaise] Bytes.create)(chunkSize);
    let rec loop = () => {
      let len =
        try(input(chan, chunk, 0, chunkSize)) {
        | Invalid_argument(_) => 0
        };
      if (len === 0) {
        close_in_noerr(chan);
        Buffer.contents(buffer);
      } else {
        Buffer.add_subbytes(buffer, chunk, 0, len);
        loop();
      };
    };

    loop();
  };

  let readStdin = () => {
    let buffer = Buffer.create(chunkSize);
    let chunk = ([@doesNotRaise] Bytes.create)(chunkSize);
    let rec loop = () => {
      let len =
        try(input(stdin, chunk, 0, chunkSize)) {
        | Invalid_argument(_) => 0
        };
      if (len === 0) {
        close_in_noerr(stdin);
        Buffer.contents(buffer);
      } else {
        Buffer.add_subbytes(buffer, chunk, 0, len);
        loop();
      };
    };

    loop();
  };
};

module CharacterCodes = {
  let eof = (-1);

  let space = 0x0020;
  [@live]
  let newline = 0x0A /* \n */;
  let lineFeed = 0x0A; /* \n */
  let carriageReturn = 0x0D; /* \r */
  let lineSeparator = 0x2028;
  let paragraphSeparator = 0x2029;

  let tab = 0x09;

  let bang = 0x21;
  let dot = 0x2E;
  let colon = 0x3A;
  let comma = 0x2C;
  let backtick = 0x60;
  /* let question = 0x3F */
  let semicolon = 0x3B;
  let underscore = 0x5F;
  let singleQuote = 0x27;
  let doubleQuote = 0x22;
  let equal = 0x3D;
  let bar = 0x7C;
  let tilde = 0x7E;
  let question = 0x3F;
  let ampersand = 0x26;
  let at = 0x40;
  let dollar = 0x24;
  let percent = 0x25;

  let lparen = 0x28;
  let rparen = 0x29;
  let lbracket = 0x5B;
  let rbracket = 0x5D;
  let lbrace = 0x7B;
  let rbrace = 0x7D;

  let forwardslash = 0x2F; /* / */
  let backslash = 0x5C; /* \ */

  let greaterThan = 0x3E;
  let hash = 0x23;
  let lessThan = 0x3C;

  let minus = 0x2D;
  let plus = 0x2B;
  let asterisk = 0x2A;

  let _0 = 0x30;
  [@live]
  let _1 = 0x31;
  [@live]
  let _2 = 0x32;
  [@live]
  let _3 = 0x33;
  [@live]
  let _4 = 0x34;
  [@live]
  let _5 = 0x35;
  [@live]
  let _6 = 0x36;
  [@live]
  let _7 = 0x37;
  [@live]
  let _8 = 0x38;
  let _9 = 0x39;

  module Lower = {
    let a = 0x61;
    let b = 0x62;
    [@live]
    let c = 0x63;
    [@live]
    let d = 0x64;
    let e = 0x65;
    let f = 0x66;
    let g = 0x67;
    [@live]
    let h = 0x68;
    [@live]
    let i = 0x69;
    [@live]
    let j = 0x6A;
    [@live]
    let k = 0x6B;
    [@live]
    let l = 0x6C;
    [@live]
    let m = 0x6D;
    let n = 0x6E;
    let o = 0x6F;
    let p = 0x70;
    [@live]
    let q = 0x71;
    let r = 0x72;
    [@live]
    let s = 0x73;
    let t = 0x74;
    [@live]
    let u = 0x75;
    [@live]
    let v = 0x76;
    [@live]
    let w = 0x77;
    let x = 0x78;
    [@live]
    let y = 0x79;
    let z = 0x7A;
  };

  module Upper = {
    let a = 0x41;
    /* let b = 0x42 */
    [@live]
    let c = 0x43;
    [@live]
    let d = 0x44;
    [@live]
    let e = 0x45;
    [@live]
    let f = 0x46;
    let g = 0x47;
    [@live]
    let h = 0x48;
    [@live]
    let i = 0x49;
    [@live]
    let j = 0x4A;
    [@live]
    let k = 0x4B;
    [@live]
    let l = 0x4C;
    [@live]
    let m = 0x4D;
    [@live]
    let b = 0x4E;
    [@live]
    let o = 0x4F;
    [@live]
    let p = 0x50;
    [@live]
    let q = 0x51;
    [@live]
    let r = 0x52;
    [@live]
    let s = 0x53;
    [@live]
    let t = 0x54;
    [@live]
    let u = 0x55;
    [@live]
    let v = 0x56;
    [@live]
    let w = 0x57;
    [@live]
    let x = 0x58;
    [@live]
    let y = 0x59;
    let z = 0x5a;
  };

  /* returns lower-case ch, ch should be ascii */
  let lower = ch =>
    /* if ch >= Lower.a && ch <= Lower.z then ch else ch + 32 */
    32 lor ch;

  let isLetter = ch =>
    Lower.a <= ch && ch <= Lower.z || Upper.a <= ch && ch <= Upper.z;

  let isUpperCase = ch => Upper.a <= ch && ch <= Upper.z;

  let isDigit = ch => _0 <= ch && ch <= _9;

  let isHex = ch =>
    _0 <= ch && ch <= _9 || Lower.a <= lower(ch) && lower(ch) <= Lower.f;

  /*
       // ES5 7.3:
       // The ECMAScript line terminator characters are listed in Table 3.
       //     Table 3: Line Terminator Characters
       //     Code Unit Value     Name                    Formal Name
       //     \u000A              Line Feed               <LF>
       //     \u000D              Carriage Return         <CR>
       //     \u2028              Line separator          <LS>
       //     \u2029              Paragraph separator     <PS>
       // Only the characters in Table 3 are treated as line terminators. Other new line or line
       // breaking characters are treated as white space but not as line terminators.
   */
  let isLineBreak = ch =>
    ch === lineFeed
    || ch === carriageReturn
    || ch === lineSeparator
    || ch === paragraphSeparator;

  let digitValue = ch =>
    if (_0 <= ch && ch <= _9) {
      ch - 48;
    } else if (Lower.a <= lower(ch) && lower(ch) <= Lower.f) {
      lower(ch) - Lower.a + 10;
    } else {
      16;
    }; /* larger than any legal value */
};

module Comment: {
  type t;

  let toString: t => string;

  let loc: t => Location.t;
  let txt: t => string;
  let prevTokEndPos: t => Lexing.position;

  let setPrevTokEndPos: (t, Lexing.position) => unit;

  let isSingleLineComment: t => bool;

  let makeSingleLineComment: (~loc: Location.t, string) => t;
  let makeMultiLineComment: (~loc: Location.t, string) => t;
  let fromOcamlComment:
    (~loc: Location.t, ~txt: string, ~prevTokEndPos: Lexing.position) => t;
  let trimSpaces: string => string;
} = {
  type style =
    | SingleLine
    | MultiLine;

  let styleToString = s =>
    switch (s) {
    | SingleLine => "SingleLine"
    | MultiLine => "MultiLine"
    };

  type t = {
    txt: string,
    style,
    loc: Location.t,
    mutable prevTokEndPos: Lexing.position,
  };

  let loc = t => t.loc;
  let txt = t => t.txt;
  let prevTokEndPos = t => t.prevTokEndPos;

  let setPrevTokEndPos = (t, pos) => t.prevTokEndPos = pos;

  let isSingleLineComment = t =>
    switch (t.style) {
    | SingleLine => true
    | MultiLine => false
    };

  let toString = t =>
    Format.sprintf(
      "(txt: %s\nstyle: %s\nlines: %d-%d)",
      t.txt,
      styleToString(t.style),
      t.loc.loc_start.pos_lnum,
      t.loc.loc_end.pos_lnum,
    );

  let makeSingleLineComment = (~loc, txt) => {
    txt,
    loc,
    style: SingleLine,
    prevTokEndPos: Lexing.dummy_pos,
  };

  let makeMultiLineComment = (~loc, txt) => {
    txt,
    loc,
    style: MultiLine,
    prevTokEndPos: Lexing.dummy_pos,
  };

  let fromOcamlComment = (~loc, ~txt, ~prevTokEndPos) => {
    txt,
    loc,
    style: MultiLine,
    prevTokEndPos,
  };

  let trimSpaces = s => {
    let len = String.length(s);
    if (len == 0) {
      s;
    } else if (String.unsafe_get(s, 0) == ' '
               || String.unsafe_get(s, len - 1) == ' ') {
      let b = Bytes.of_string(s);
      let i = ref(0);
      while (i^ < len && Bytes.unsafe_get(b, i^) == ' ') {
        incr(i);
      };
      let j = ref(len - 1);
      while (j^ >= i^ && Bytes.unsafe_get(b, j^) == ' ') {
        decr(j);
      };
      if (j^ >= i^) {
        ([@doesNotRaise] Bytes.sub)(b, i^, j^ - i^ + 1) |> Bytes.to_string;
      } else {
        "";
      };
    } else {
      s;
    };
  };
};

module Token = {
  type t =
    | Open
    | True
    | False
    | Character(char)
    | Int({
        i: string,
        suffix: option(char),
      })
    | Float({
        f: string,
        suffix: option(char),
      })
    | String(string)
    | Lident(string)
    | Uident(string)
    | As
    | Dot
    | DotDot
    | DotDotDot
    | Bang
    | Semicolon
    | Let
    | And
    | Rec
    | Underscore
    | SingleQuote
    | Equal
    | EqualEqual
    | EqualEqualEqual
    | Bar
    | Lparen
    | Rparen
    | Lbracket
    | Rbracket
    | Lbrace
    | Rbrace
    | Colon
    | Comma
    | Eof
    | Exception
    | [@live] Backslash
    | Forwardslash
    | ForwardslashDot
    | Asterisk
    | AsteriskDot
    | Exponentiation
    | Minus
    | MinusDot
    | Plus
    | PlusDot
    | PlusPlus
    | PlusEqual
    | ColonGreaterThan
    | GreaterThan
    | LessThan
    | LessThanSlash
    | Hash
    | HashEqual
    | HashHash
    | Assert
    | Lazy
    | Tilde
    | Question
    | If
    | Else
    | For
    | In
    | To
    | Downto
    | While
    | Switch
    | When
    | EqualGreater
    | MinusGreater
    | External
    | Typ
    | Private
    | Mutable
    | Constraint
    | Include
    | Module
    | Of
    | With
    | Land
    | Lor
    | Band /* Bitwise and: & */
    | BangEqual
    | BangEqualEqual
    | LessEqual
    | GreaterEqual
    | ColonEqual
    | At
    | AtAt
    | Percent
    | PercentPercent
    | Comment(Comment.t)
    | List
    | TemplateTail(string)
    | TemplatePart(string)
    | Backtick
    | BarGreater
    | Try
    | Catch
    | Import
    | Export;

  let precedence =
    fun
    | HashEqual
    | ColonEqual => 1
    | Lor => 2
    | Land => 3
    | Equal
    | EqualEqual
    | EqualEqualEqual
    | LessThan
    | GreaterThan
    | BangEqual
    | BangEqualEqual
    | LessEqual
    | GreaterEqual
    | BarGreater => 4
    | Plus
    | PlusDot
    | Minus
    | MinusDot
    | PlusPlus => 5
    | Asterisk
    | AsteriskDot
    | Forwardslash
    | ForwardslashDot => 6
    | Exponentiation => 7
    | MinusGreater => 8
    | Dot => 9
    | _ => 0;

  let toString =
    fun
    | Open => "open"
    | True => "true"
    | False => "false"
    | Character(c) => "'" ++ Char.escaped(c) ++ "'"
    | String(s) => s
    | Lident(str) => str
    | Uident(str) => str
    | Dot => "."
    | DotDot => ".."
    | DotDotDot => "..."
    | Int({i}) => "int " ++ i
    | Float({f}) => "Float: " ++ f
    | Bang => "!"
    | Semicolon => ";"
    | Let => "let"
    | And => "and"
    | Rec => "rec"
    | Underscore => "_"
    | SingleQuote => "'"
    | Equal => "="
    | EqualEqual => "=="
    | EqualEqualEqual => "==="
    | Eof => "eof"
    | Bar => "|"
    | As => "as"
    | Lparen => "("
    | Rparen => ")"
    | Lbracket => "["
    | Rbracket => "]"
    | Lbrace => "{"
    | Rbrace => "}"
    | ColonGreaterThan => ":>"
    | Colon => ":"
    | Comma => ","
    | Minus => "-"
    | MinusDot => "-."
    | Plus => "+"
    | PlusDot => "+."
    | PlusPlus => "++"
    | PlusEqual => "+="
    | Backslash => "\\"
    | Forwardslash => "/"
    | ForwardslashDot => "/."
    | Exception => "exception"
    | Hash => "#"
    | HashHash => "##"
    | HashEqual => "#="
    | GreaterThan => ">"
    | LessThan => "<"
    | LessThanSlash => "</"
    | Asterisk => "*"
    | AsteriskDot => "*."
    | Exponentiation => "**"
    | Assert => "assert"
    | Lazy => "lazy"
    | Tilde => "tilde"
    | Question => "?"
    | If => "if"
    | Else => "else"
    | For => "for"
    | In => "in"
    | To => "to"
    | Downto => "downto"
    | While => "while"
    | Switch => "switch"
    | When => "when"
    | EqualGreater => "=>"
    | MinusGreater => "->"
    | External => "external"
    | Typ => "type"
    | Private => "private"
    | Constraint => "constraint"
    | Mutable => "mutable"
    | Include => "include"
    | Module => "module"
    | Of => "of"
    | With => "with"
    | Lor => "||"
    | Band => "&"
    | Land => "&&"
    | BangEqual => "!="
    | BangEqualEqual => "!=="
    | GreaterEqual => ">="
    | LessEqual => "<="
    | ColonEqual => ":="
    | At => "@"
    | AtAt => "@@"
    | Percent => "%"
    | PercentPercent => "%%"
    | Comment(c) => "Comment(" ++ Comment.toString(c) ++ ")"
    | List => "list"
    | TemplatePart(text) => text ++ "${"
    | TemplateTail(text) => "TemplateTail(" ++ text ++ ")"
    | Backtick => "`"
    | BarGreater => "|>"
    | Try => "try"
    | Catch => "catch"
    | Import => "import"
    | Export => "export";

  [@raises Not_found]
  let keywordTable =
    fun
    | "true" => True
    | "false" => False
    | "open" => Open
    | "let" => Let
    | "rec" => Rec
    | "and" => And
    | "as" => As
    | "exception" => Exception
    | "assert" => Assert
    | "lazy" => Lazy
    | "if" => If
    | "else" => Else
    | "for" => For
    | "in" => In
    | "to" => To
    | "downto" => Downto
    | "while" => While
    | "switch" => Switch
    | "when" => When
    | "external" => External
    | "type" => Typ
    | "private" => Private
    | "mutable" => Mutable
    | "constraint" => Constraint
    | "include" => Include
    | "module" => Module
    | "of" => Of
    | "list" => List
    | "with" => With
    | "try" => Try
    | "catch" => Catch
    | "import" => Import
    | "export" => Export
    | _ => raise(Not_found);

  let isKeyword =
    fun
    | True
    | False
    | Open
    | Let
    | Rec
    | And
    | As
    | Exception
    | Assert
    | Lazy
    | If
    | Else
    | For
    | In
    | To
    | Downto
    | While
    | Switch
    | When
    | External
    | Typ
    | Private
    | Mutable
    | Constraint
    | Include
    | Module
    | Of
    | Land
    | Lor
    | List
    | With
    | Try
    | Catch
    | Import
    | Export => true
    | _ => false;

  let lookupKeyword = str =>
    try(keywordTable(str)) {
    | Not_found =>
      if (CharacterCodes.isUpperCase(int_of_char([@doesNotRaise] str.[0]))) {
        Uident(str);
      } else {
        Lident(str);
      }
    };

  let isKeywordTxt = str =>
    try({
      let _ = keywordTable(str);
      true;
    }) {
    | Not_found => false
    };
};

module Grammar = {
  type t =
    | OpenDescription /* open Belt */
    | [@live] ModuleLongIdent /* Foo or Foo.Bar */
    | Ternary /* condExpr ? trueExpr : falseExpr */
    | Es6ArrowExpr
    | Jsx
    | JsxAttribute
    | [@live] JsxChild
    | ExprOperand
    | ExprUnary
    | ExprSetField
    | ExprBinaryAfterOp(Token.t)
    | ExprBlock
    | ExprCall
    | ExprList
    | ExprArrayAccess
    | ExprArrayMutation
    | ExprIf
    | IfCondition
    | IfBranch
    | ElseBranch
    | TypeExpression
    | External
    | PatternMatching
    | PatternMatchCase
    | LetBinding
    | PatternList
    | PatternOcamlList
    | PatternRecord
    | TypeDef
    | TypeConstrName
    | TypeParams
    | [@live] TypeParam
    | PackageConstraint
    | TypeRepresentation
    | RecordDecl
    | ConstructorDeclaration
    | ParameterList
    | StringFieldDeclarations
    | FieldDeclarations
    | TypExprList
    | FunctorArgs
    | ModExprList
    | TypeParameters
    | RecordRows
    | RecordRowsStringKey
    | ArgumentList
    | Signature
    | Specification
    | Structure
    | Implementation
    | Attribute
    | TypeConstraint
    | Primitive
    | AtomicTypExpr
    | ListExpr
    | JsFfiImport;

  let toString =
    fun
    | OpenDescription => "an open description"
    | ModuleLongIdent => "a module identifier"
    | Ternary => "a ternary expression"
    | Es6ArrowExpr => "an es6 arrow function"
    | Jsx => "a jsx expression"
    | JsxAttribute => "a jsx attribute"
    | ExprOperand => "a basic expression"
    | ExprUnary => "a unary expression"
    | ExprBinaryAfterOp(op) =>
      "an expression after the operator \"" ++ Token.toString(op) ++ "\""
    | ExprIf => "an if expression"
    | IfCondition => "the condition of an if expression"
    | IfBranch => "the true-branch of an if expression"
    | ElseBranch => "the else-branch of an if expression"
    | TypeExpression => "a type"
    | External => "an external"
    | PatternMatching => "the cases of a pattern match"
    | ExprBlock => "a block with expressions"
    | ExprSetField => "a record field mutation"
    | ExprCall => "a function application"
    | ExprArrayAccess => "an array access expression"
    | ExprArrayMutation => "an array mutation"
    | LetBinding => "a let binding"
    | TypeDef => "a type definition"
    | TypeParams => "type parameters"
    | TypeParam => "a type parameter"
    | TypeConstrName => "a type-constructor name"
    | TypeRepresentation => "a type representation"
    | RecordDecl => "a record declaration"
    | PatternMatchCase => "a pattern match case"
    | ConstructorDeclaration => "a constructor declaration"
    | ExprList => "multiple expressions"
    | PatternList => "multiple patterns"
    | PatternOcamlList => "a list pattern"
    | PatternRecord => "a record pattern"
    | ParameterList => "parameters"
    | StringFieldDeclarations => "string field declarations"
    | FieldDeclarations => "field declarations"
    | TypExprList => "list of types"
    | FunctorArgs => "functor arguments"
    | ModExprList => "list of module expressions"
    | TypeParameters => "list of type parameters"
    | RecordRows => "rows of a record"
    | RecordRowsStringKey => "rows of a record with string keys"
    | ArgumentList => "arguments"
    | Signature => "signature"
    | Specification => "specification"
    | Structure => "structure"
    | Implementation => "implementation"
    | Attribute => "an attribute"
    | TypeConstraint => "constraints on a type"
    | Primitive => "an external primitive"
    | AtomicTypExpr => "a type"
    | ListExpr => "an ocaml list expr"
    | PackageConstraint => "a package constraint"
    | JsFfiImport => "js ffi import"
    | JsxChild => "jsx child";

  let isSignatureItemStart =
    fun
    | Token.At
    | Let
    | Typ
    | External
    | Exception
    | Open
    | Include
    | Module
    | AtAt
    | PercentPercent => true
    | _ => false;

  let isAtomicPatternStart =
    fun
    | Token.Int(_)
    | String(_)
    | Character(_)
    | Lparen
    | Lbracket
    | Lbrace
    | Underscore
    | Lident(_)
    | Uident(_)
    | List
    | Exception
    | Lazy
    | Percent => true
    | _ => false;

  let isAtomicExprStart =
    fun
    | Token.True
    | False
    | Int(_)
    | String(_)
    | Float(_)
    | Character(_)
    | Backtick
    | Uident(_)
    | Lident(_)
    | Hash
    | Lparen
    | List
    | Lbracket
    | Lbrace
    | LessThan
    | Module
    | Percent => true
    | _ => false;

  let isAtomicTypExprStart =
    fun
    | Token.SingleQuote
    | Underscore
    | Lparen
    | Lbrace
    | Uident(_)
    | Lident(_)
    | List
    | Percent => true
    | _ => false;

  let isExprStart =
    fun
    | Token.True
    | False
    | Int(_)
    | String(_)
    | Float(_)
    | Character(_)
    | Backtick
    | Underscore /* _ => doThings() */
    | Uident(_)
    | Lident(_)
    | Hash
    | Lparen
    | List
    | Module
    | Lbracket
    | Lbrace
    | LessThan
    | Minus
    | MinusDot
    | Plus
    | PlusDot
    | Bang
    | Percent
    | At
    | If
    | Switch
    | While
    | For
    | Assert
    | Lazy
    | Try => true
    | _ => false;

  let isJsxAttributeStart =
    fun
    | Token.Lident(_)
    | Question => true
    | _ => false;

  let isStructureItemStart =
    fun
    | Token.Open
    | Let
    | Typ
    | External
    | Import
    | Export
    | Exception
    | Include
    | Module
    | AtAt
    | PercentPercent
    | At => true
    | t when isExprStart(t) => true
    | _ => false;

  let isPatternStart =
    fun
    | Token.Int(_)
    | Float(_)
    | String(_)
    | Character(_)
    | True
    | False
    | Minus
    | Plus
    | Lparen
    | Lbracket
    | Lbrace
    | List
    | Underscore
    | Lident(_)
    | Uident(_)
    | Hash
    | HashHash
    | Exception
    | Lazy
    | Percent
    | Module
    | At => true
    | _ => false;

  let isParameterStart =
    fun
    | Token.Typ
    | Tilde
    | Dot => true
    | token when isPatternStart(token) => true
    | _ => false;

  /* TODO: overparse Uident ? */
  let isStringFieldDeclStart =
    fun
    | Token.String(_)
    | At => true
    | _ => false;

  /* TODO: overparse Uident ? */
  let isFieldDeclStart =
    fun
    | Token.At
    | Mutable
    | Lident(_)
    | List => true
    /* recovery, TODO: this is not ideal… */
    | Uident(_) => true
    | t when Token.isKeyword(t) => true
    | _ => false;

  let isRecordDeclStart =
    fun
    | Token.At
    | Mutable
    | Lident(_)
    | List => true
    | _ => false;

  let isTypExprStart =
    fun
    | Token.At
    | SingleQuote
    | Underscore
    | Lparen
    | Lbracket
    | Uident(_)
    | Lident(_)
    | List
    | Module
    | Percent
    | Lbrace => true
    | _ => false;

  let isTypeParameterStart =
    fun
    | Token.Tilde
    | Dot => true
    | token when isTypExprStart(token) => true
    | _ => false;

  let isTypeParamStart =
    fun
    | Token.Plus
    | Minus
    | SingleQuote
    | Underscore => true
    | _ => false;

  let isFunctorArgStart =
    fun
    | Token.At
    | Uident(_)
    | Underscore
    | Percent
    | Lbrace
    | Lparen => true
    | _ => false;

  let isModExprStart =
    fun
    | Token.At
    | Percent
    | Uident(_)
    | Lbrace
    | Lparen => true
    | _ => false;

  let isRecordRowStart =
    fun
    | Token.DotDotDot => true
    | Token.Uident(_)
    | Lident(_)
    | List => true
    /* TODO */
    | t when Token.isKeyword(t) => true
    | _ => false;

  let isRecordRowStringKeyStart =
    fun
    | Token.String(_) => true
    | _ => false;

  let isArgumentStart =
    fun
    | Token.Tilde
    | Dot
    | Underscore => true
    | t when isExprStart(t) => true
    | _ => false;

  let isPatternMatchStart =
    fun
    | Token.Bar => true
    | t when isPatternStart(t) => true
    | _ => false;

  let isPatternOcamlListStart =
    fun
    | Token.DotDotDot => true
    | t when isPatternStart(t) => true
    | _ => false;

  let isPatternRecordItemStart =
    fun
    | Token.DotDotDot
    | Uident(_)
    | Lident(_)
    | List
    | Underscore => true
    | _ => false;

  let isAttributeStart =
    fun
    | Token.At => true
    | _ => false;

  let isJsFfiImportStart =
    fun
    | Token.Lident(_)
    | At => true
    | _ => false;

  let isJsxChildStart = isAtomicExprStart;

  let isBlockExprStart =
    fun
    | Token.At
    | Hash
    | Percent
    | Minus
    | MinusDot
    | Plus
    | PlusDot
    | Bang
    | True
    | False
    | Int(_)
    | String(_)
    | Character(_)
    | Lident(_)
    | Uident(_)
    | Lparen
    | List
    | Lbracket
    | Lbrace
    | Forwardslash
    | Assert
    | Lazy
    | If
    | For
    | While
    | Switch
    | Open
    | Module
    | Exception
    | Let
    | LessThan
    | Backtick
    | Try
    | Underscore => true
    | _ => false;

  let isListElement = (grammar, token) =>
    switch (grammar) {
    | ExprList => token == Token.DotDotDot || isExprStart(token)
    | ListExpr => token == DotDotDot || isExprStart(token)
    | PatternList => token == DotDotDot || isPatternStart(token)
    | ParameterList => isParameterStart(token)
    | StringFieldDeclarations => isStringFieldDeclStart(token)
    | FieldDeclarations => isFieldDeclStart(token)
    | RecordDecl => isRecordDeclStart(token)
    | TypExprList => isTypExprStart(token) || token == Token.LessThan
    | TypeParams => isTypeParamStart(token)
    | FunctorArgs => isFunctorArgStart(token)
    | ModExprList => isModExprStart(token)
    | TypeParameters => isTypeParameterStart(token)
    | RecordRows => isRecordRowStart(token)
    | RecordRowsStringKey => isRecordRowStringKeyStart(token)
    | ArgumentList => isArgumentStart(token)
    | Signature
    | Specification => isSignatureItemStart(token)
    | Structure
    | Implementation => isStructureItemStart(token)
    | PatternMatching => isPatternMatchStart(token)
    | PatternOcamlList => isPatternOcamlListStart(token)
    | PatternRecord => isPatternRecordItemStart(token)
    | Attribute => isAttributeStart(token)
    | TypeConstraint => token == Constraint
    | PackageConstraint => token == And
    | ConstructorDeclaration => token == Bar
    | Primitive =>
      switch (token) {
      | Token.String(_) => true
      | _ => false
      }
    | JsxAttribute => isJsxAttributeStart(token)
    | JsFfiImport => isJsFfiImportStart(token)
    | _ => false
    };

  let isListTerminator = (grammar, token) =>
    switch (grammar, token) {
    | (_, Token.Eof)
    | (ExprList, Rparen | Forwardslash | Rbracket)
    | (ListExpr, Rparen)
    | (ArgumentList, Rparen)
    | (TypExprList, Rparen | Forwardslash | GreaterThan | Equal)
    | (ModExprList, Rparen)
    | (
        PatternList | PatternOcamlList | PatternRecord,
        Forwardslash | Rbracket | Rparen |
        EqualGreater /* pattern matching => */ |
        In /* for expressions */ |
        Equal /* let {x} = foo */,
      )
    | (ExprBlock, Rbrace)
    | (Structure | Signature, Rbrace)
    | (TypeParams, Rparen)
    | (ParameterList, EqualGreater | Lbrace)
    | (JsxAttribute, Forwardslash | GreaterThan)
    | (JsFfiImport, Rbrace)
    | (StringFieldDeclarations, Rbrace) => true

    | (Attribute, token) when token != At => true
    | (TypeConstraint, token) when token != Constraint => true
    | (PackageConstraint, token) when token != And => true
    | (ConstructorDeclaration, token) when token != Bar => true
    | (Primitive, Semicolon) => true
    | (Primitive, token) when isStructureItemStart(token) => true

    | _ => false
    };

  let isPartOfList = (grammar, token) =>
    isListElement(grammar, token) || isListTerminator(grammar, token);
};

module Reporting = {
  module TerminalDoc = {
    type break =
      | Never
      | Always;

    type document =
      | Nil
      | Group({
          break,
          doc: document,
        })
      | Text(string)
      | Indent({
          amount: int,
          doc: document,
        })
      | Append({
          doc1: document,
          doc2: document,
        });

    let group = (~break, doc) => Group({break, doc});
    let text = txt => Text(txt);
    let indent = (i, d) => Indent({amount: i, doc: d});
    let append = (d1, d2) => Append({doc1: d1, doc2: d2});
    let nil = Nil;

    type stack =
      | Empty
      | Cons({
          doc: document,
          stack,
        });

    let push = (stack, doc) => Cons({doc, stack});

    type mode =
      | Flat
      | Break;

    let toString = (/* ~width */ doc: document) => {
      let buffer = Buffer.create(100);
      let rec loop = (stack, mode, offset) =>
        switch (stack) {
        | Empty => ()
        | Cons({doc, stack: rest}) =>
          switch (doc) {
          | Nil => loop(rest, mode, offset)
          | Text(txt) =>
            Buffer.add_string(buffer, txt);
            loop(rest, mode, offset + String.length(txt));
          | Indent({amount: i, doc}) =>
            let indentation = ([@doesNotRaise] String.make)(i, ' ');
            Buffer.add_string(buffer, indentation);
            loop(push(rest, doc), mode, offset + i);
          | Append({doc1, doc2}) =>
            let rest = push(rest, doc2);
            let rest = push(rest, mode == Flat ? Nil : text("\n"));

            let rest = push(rest, doc1);
            loop(rest, mode, offset);
          | Group({break, doc}) =>
            let rest = push(rest, doc);
            switch (break) {
            | Always => loop(rest, Break, offset)
            | Never => loop(rest, Flat, offset)
            };
          }
        };

      loop(push(Empty, doc), Flat, 0);
      Buffer.contents(buffer);
    };
  };

  type color =
    | [@live] NoColor
    | [@live] Red;

  type style = {
    [@live]
    underline: bool,
    [@live]
    color,
  };

  let highlight = (~from, ~len, txt) =>
    if (from < 0 || String.length(txt) === 0 || from >= String.length(txt)) {
      txt;
    } else {
      let before =
        try(String.sub(txt, 0, from)) {
        | Invalid_argument(_) => ""
        };
      let content =
        "\027[31m"
        ++ (
          try(String.sub(txt, from, len)) {
          | Invalid_argument(_) => ""
          }
        )
        ++ "\027[0m";

      let after =
        try(String.sub(txt, from + len, String.length(txt) - (from + len))) {
        | Invalid_argument(_) => ""
        };
      before ++ content ++ after;
    };

  let underline = (~from, ~len, txt) => {
    open TerminalDoc;
    let indent = ([@doesNotRaise] String.make)(from, ' ');
    let underline = ([@doesNotRaise] String.make)(len, '^');
    let line = highlight(~from=0, ~len, underline);
    group(~break=Always, append(text(txt), text(indent ++ line)));
  };

  let rec drop = (n, l) =>
    if (n === 1) {
      l;
    } else {
      drop(
        n - 1,
        switch (l) {
        | [_x, ...xs] => xs
        | _ => l
        },
      );
    };

  let rec take = (n, l) =>
    switch (l) {
    | _ when n === 0 => []
    | [] => []
    | [x, ...xs] => [x, ...take(n - 1, xs)]
    };

  /* TODO: cleanup */
  let renderCodeContext = (~missing, src: string, startPos, endPos) => {
    open Lexing;
    let startCol = startPos.pos_cnum - startPos.pos_bol;
    let endCol = endPos.pos_cnum - startPos.pos_cnum + startCol;
    let startLine = max(1, startPos.pos_lnum - 2); /* 2 lines before */
    let lines = String.split_on_char('\n', src);
    let endLine = {
      let len = List.length(lines);
      min(len, startPos.pos_lnum + 3);
    }; /* 2 lines after */

    let lines =
      lines |> drop(startLine) |> take(endLine - startLine) |> Array.of_list;

    let renderLine = (x, ix) => {
      let x =
        if (ix == startPos.pos_lnum) {
          switch (missing) {
          | Some(_len) => x ++ [@doesNotRaise] String.make(10, ' ')
          | None => x
          };
        } else {
          x;
        };

      open TerminalDoc;
      let rowNr = {
        let txt = string_of_int(ix);
        let len = String.length(txt);
        if (ix == startPos.pos_lnum) {
          highlight(~from=0, ~len, txt);
        } else {
          txt;
        };
      };

      let len = {
        let len =
          if (endCol >= 0) {
            endCol - startCol;
          } else {
            1;
          };

        if (startCol + len > String.length(x)) {
          String.length(x) - startCol - 1;
        } else {
          len;
        };
      };

      let line =
        if (ix == startPos.pos_lnum) {
          switch (missing) {
          | Some(len) =>
            underline(
              ~from=
                startCol
                + String.length(
                    String.length(string_of_int(ix)) |> string_of_int,
                  )
                + 5,
              ~len,
              x,
            )
          | None =>
            let len =
              if (startCol + len > String.length(x)) {
                String.length(x) - startCol;
              } else {
                len;
              };

            text(highlight(~from=startCol, ~len, x));
          };
        } else {
          text(x);
        };

      group(
        ~break=Never,
        append(append(text(rowNr), text(" │")), indent(2, line)),
      );
    };

    let reportDoc = ref(TerminalDoc.nil);

    let linesLen = Array.length(lines);
    for (i in 0 to linesLen - 1) {
      let line =
        try(lines[i]) {
        | Invalid_argument(_) => ""
        };
      reportDoc :=
        {
          open TerminalDoc;
          let ix = startLine + i;
          group(~break=Always, append(reportDoc^, renderLine(line, ix)));
        };
    };

    TerminalDoc.toString(reportDoc^);
  };

  type problem =
    | [@live] Unexpected(Token.t)
    | [@live] Expected({
        token: Token.t,
        pos: Lexing.position,
        context: option(Grammar.t),
      })
    | [@live] Message(string)
    | [@live] Uident
    | [@live] Lident
    | [@live] Unbalanced(Token.t);

  type parseError = (Lexing.position, problem);
};

module Diagnostics: {
  type t;
  type category;
  type report;

  type reportStyle;
  let parseReportStyle: string => reportStyle;

  let unexpected: (Token.t, list((Grammar.t, Lexing.position))) => category;
  let expected: (~grammar: Grammar.t=?, Lexing.position, Token.t) => category;
  let uident: Token.t => category;
  let lident: Token.t => category;
  let unclosedString: category;
  let unclosedTemplate: category;
  let unclosedComment: category;
  let unknownUchar: int => category;
  let message: string => category;

  let make:
    (
      ~filename: string,
      ~startPos: Lexing.position,
      ~endPos: Lexing.position,
      category
    ) =>
    t;

  let stringOfReport: (~style: reportStyle, list(t), string) => string;
} = {
  type category =
    | Unexpected({
        token: Token.t,
        context: list((Grammar.t, Lexing.position)),
      })
    | Expected({
        context: option(Grammar.t),
        pos: Lexing.position /* prev token end*/,
        token: Token.t,
      })
    | Message(string)
    | Uident(Token.t)
    | Lident(Token.t)
    | UnclosedString
    | UnclosedTemplate
    | UnclosedComment
    | UnknownUchar(int);

  type t = {
    filename: string,
    startPos: Lexing.position,
    endPos: Lexing.position,
    category,
  };

  type report = list(t);

  /* TODO: add json here */
  type reportStyle =
    | Pretty
    | Plain;

  let parseReportStyle = txt =>
    switch (String.lowercase_ascii(txt)) {
    | "plain" => Plain
    | _ => Pretty
    };

  let defaultUnexpected = token =>
    "I'm not sure what to parse here when looking at \""
    ++ Token.toString(token)
    ++ "\".";

  let explain = t =>
    switch (t.category) {
    | Uident(currentToken) =>
      switch (currentToken) {
      | Lident(lident) =>
        let guess = String.capitalize_ascii(lident);
        "Did you mean `" ++ guess ++ "` instead of `" ++ lident ++ "`?";
      | t when Token.isKeyword(t) =>
        let token = Token.toString(t);
        "`" ++ token ++ "` is a reserved keyword.";
      | _ => "At this point, I'm looking for an uppercased identifier like `Belt` or `Array`"
      }
    | Lident(currentToken) =>
      switch (currentToken) {
      | Uident(uident) =>
        let guess = String.uncapitalize_ascii(uident);
        "Did you mean `" ++ guess ++ "` instead of `" ++ uident ++ "`?";
      | t when Token.isKeyword(t) =>
        let token = Token.toString(t);
        "`"
        ++ token
        ++ "` is a reserved keyword. Keywords need to be escaped: \\\""
        ++ token
        ++ "\"";
      | Underscore => "`_` isn't a valid name."
      | _ => "I'm expecting an lowercased identifier like `name` or `age`"
      }
    | Message(txt) => txt
    | UnclosedString => "This string is missing a double quote at the end"
    | UnclosedTemplate => "Did you forget to close this template expression with a backtick?"
    | UnclosedComment => "This comment seems to be missing a closing `*/`"
    | UnknownUchar(uchar) =>
      switch (uchar) {
      | 94 /* ^ */ => "Hmm, not sure what I should do here with this character.\nIf you're trying to deref an expression, use `foo.contents` instead."
      | _ => "Hmm, I have no idea what this character means…"
      }
    | Expected({context, token: t}) =>
      let hint =
        switch (context) {
        | Some(grammar) =>
          "It signals the start of " ++ Grammar.toString(grammar)
        | None => ""
        };

      "Did you forget a `" ++ Token.toString(t) ++ "` here? " ++ hint;
    | Unexpected({token: t, context: breadcrumbs}) =>
      let name = Token.toString(t);
      switch (breadcrumbs) {
      | [(AtomicTypExpr, _), ...breadcrumbs] =>
        switch (breadcrumbs, t) {
        | (
            [(StringFieldDeclarations | FieldDeclarations, _), ..._],
            String(_) | At | Rbrace | Comma | Eof,
          ) => "I'm missing a type here"
        | (_, t) when Grammar.isStructureItemStart(t) || t == Eof => "Missing a type here"
        | _ => defaultUnexpected(t)
        }
      | [(ExprOperand, _), ...breadcrumbs] =>
        switch (breadcrumbs, t) {
        | ([(ExprBlock, _), ..._], Rbrace) => "It seems that this expression block is empty"
        | ([(ExprBlock, _), ..._], Bar) =>
          /* Pattern matching */
          "Looks like there might be an expression missing here"
        | ([(ExprSetField, _), ..._], _) => "It seems that this record field mutation misses an expression"
        | ([(ExprArrayMutation, _), ..._], _) => "Seems that an expression is missing, with what do I mutate the array?"
        | ([(ExprBinaryAfterOp(_) | ExprUnary, _), ..._], _) => "Did you forget to write an expression here?"
        | ([(Grammar.LetBinding, _), ..._], _) => "This let-binding misses an expression"
        | ([_, ..._], Rbracket | Rbrace) => "Missing expression"
        | _ =>
          "I'm not sure what to parse here when looking at \"" ++ name ++ "\"."
        }
      | [(TypeParam, _), ..._] =>
        switch (t) {
        | Lident(ident) =>
          "Did you mean '"
          ++ ident
          ++ "? A Type parameter starts with a quote."
        | _ =>
          "I'm not sure what to parse here when looking at \"" ++ name ++ "\"."
        }
      | _ =>
        /* TODO: match on circumstance to verify Lident needed ? */
        if (Token.isKeyword(t)) {
          "`"
          ++ name
          ++ "` is a reserved keyword. Keywords need to be escaped: \\\""
          ++ Token.toString(t)
          ++ "\"";
        } else {
          "I'm not sure what to parse here when looking at \"" ++ name ++ "\".";
        }
      };
    };

  let toPlainString = (t, buffer) => {
    Buffer.add_string(buffer, t.filename);
    Buffer.add_char(buffer, '(');
    Buffer.add_string(buffer, string_of_int(t.startPos.pos_cnum));
    Buffer.add_char(buffer, ',');
    Buffer.add_string(buffer, string_of_int(t.endPos.pos_cnum));
    Buffer.add_char(buffer, ')');
    Buffer.add_char(buffer, ':');
    Buffer.add_string(buffer, explain(t));
  };

  let toString = (t, src) => {
    open Lexing;
    let startchar = t.startPos.pos_cnum - t.startPos.pos_bol;
    let endchar = t.endPos.pos_cnum - t.startPos.pos_cnum + startchar;
    let locationInfo =
      Printf.sprintf(
        /* ReasonLanguageServer requires the following format */
        "File \"%s\", line %d, characters %d-%d:",
        t.filename,
        t.startPos.pos_lnum,
        startchar,
        endchar,
      );

    let code = {
      let missing =
        switch (t.category) {
        | Expected({token: t}) => Some(String.length(Token.toString(t)))
        | _ => None
        };

      Reporting.renderCodeContext(~missing, src, t.startPos, t.endPos);
    };

    let explanation = explain(t);
    Printf.sprintf("%s\n\n%s\n\n%s\n\n", locationInfo, code, explanation);
  };

  let make = (~filename, ~startPos, ~endPos, category) => {
    filename,
    startPos,
    endPos,
    category,
  };

  let stringOfReport = (~style, diagnostics, src) =>
    switch (style) {
    | Pretty =>
      List.fold_left(
        (report, diagnostic) => report ++ toString(diagnostic, src) ++ "\n",
        "\n",
        List.rev(diagnostics),
      )
    | Plain =>
      let buffer = Buffer.create(100);
      List.iter(
        diagnostic => {
          toPlainString(diagnostic, buffer);
          Buffer.add_char(buffer, '\n');
        },
        diagnostics,
      );
      Buffer.contents(buffer);
    };

  let unexpected = (token, context) => Unexpected({token, context});

  let expected = (~grammar=?, pos, token) =>
    Expected({context: grammar, pos, token});

  let uident = currentToken => Uident(currentToken);
  let lident = currentToken => Lident(currentToken);
  let unclosedString = UnclosedString;
  let unclosedComment = UnclosedComment;
  let unclosedTemplate = UnclosedTemplate;
  let unknownUchar = code => UnknownUchar(code);
  let message = txt => Message(txt);
};

/* Collection of utilities to view the ast in a more a convenient form,
 * allowing for easier processing.
 * Example: given a ptyp_arrow type, what are its arguments and what is the
 * returnType? */
module ParsetreeViewer: {
  /* Restructures a nested tree of arrow types into its args & returnType
   * The parsetree contains: a => b => c => d, for printing purposes
   * we restructure the tree into (a, b, c) and its returnType d */
  let arrowType:
    Parsetree.core_type =>
    (
      Parsetree.attributes,
      list((Parsetree.attributes, Asttypes.arg_label, Parsetree.core_type)),
      Parsetree.core_type,
    );

  let functorType:
    Parsetree.module_type =>
    (
      list(
        (
          Parsetree.attributes,
          Asttypes.loc(string),
          option(Parsetree.module_type),
        ),
      ),
      Parsetree.module_type,
    );

  /* filters @bs out of the provided attributes */
  let processUncurriedAttribute:
    Parsetree.attributes => (bool, Parsetree.attributes);

  /* if ... else if ... else ... is represented as nested expressions: if ... else { if ... }
   * The purpose of this function is to flatten nested ifs into one sequence.
   * Basically compute: ([if, else if, else if, else if], else) */
  let collectIfExpressions:
    Parsetree.expression =>
    (
      list((Parsetree.expression, Parsetree.expression)),
      option(Parsetree.expression),
    );

  let collectListExpressions:
    Parsetree.expression =>
    (list(Parsetree.expression), option(Parsetree.expression));

  type funParamKind =
    | Parameter({
        attrs: Parsetree.attributes,
        lbl: Asttypes.arg_label,
        defaultExpr: option(Parsetree.expression),
        pat: Parsetree.pattern,
      })
    | NewTypes({
        attrs: Parsetree.attributes,
        locs: list(Asttypes.loc(string)),
      });

  let funExpr:
    Parsetree.expression =>
    (Parsetree.attributes, list(funParamKind), Parsetree.expression);

  /* example:
   *  `makeCoordinate({
   *    x: 1,
   *    y: 2,
   *  })`
   *  Notice howe `({` and `})` "hug" or stick to each other */
  let isHuggableExpression: Parsetree.expression => bool;

  let isHuggablePattern: Parsetree.pattern => bool;

  let isHuggableRhs: Parsetree.expression => bool;

  let operatorPrecedence: string => int;

  let isUnaryExpression: Parsetree.expression => bool;
  let isBinaryOperator: string => bool;
  let isBinaryExpression: Parsetree.expression => bool;

  let flattenableOperators: (string, string) => bool;

  let hasAttributes: Parsetree.attributes => bool;

  let isArrayAccess: Parsetree.expression => bool;
  let isTernaryExpr: Parsetree.expression => bool;

  let collectTernaryParts:
    Parsetree.expression =>
    (
      list((Parsetree.expression, Parsetree.expression)),
      Parsetree.expression,
    );

  let parametersShouldHug: list(funParamKind) => bool;

  let filterTernaryAttributes: Parsetree.attributes => Parsetree.attributes;

  let isJsxExpression: Parsetree.expression => bool;
  let hasJsxAttribute: Parsetree.attributes => bool;

  let shouldIndentBinaryExpr: Parsetree.expression => bool;
  let shouldInlineRhsBinaryExpr: Parsetree.expression => bool;
  let filterPrinteableAttributes: Parsetree.attributes => Parsetree.attributes;
  let partitionPrinteableAttributes:
    Parsetree.attributes => (Parsetree.attributes, Parsetree.attributes);

  let requiresSpecialCallbackPrintingLastArg:
    list((Asttypes.arg_label, Parsetree.expression)) => bool;
  let requiresSpecialCallbackPrintingFirstArg:
    list((Asttypes.arg_label, Parsetree.expression)) => bool;

  let modExprApply:
    Parsetree.module_expr =>
    (list(Parsetree.module_expr), Parsetree.module_expr);

  let modExprFunctor:
    Parsetree.module_expr =>
    (
      list(
        (
          Parsetree.attributes,
          Asttypes.loc(string),
          option(Parsetree.module_type),
        ),
      ),
      Parsetree.module_expr,
    );

  let splitGenTypeAttr: Parsetree.attributes => (bool, Parsetree.attributes);

  let collectPatternsFromListConstruct:
    (list(Parsetree.pattern), Parsetree.pattern) =>
    (list(Parsetree.pattern), Parsetree.pattern);

  let isBlockExpr: Parsetree.expression => bool;

  let isTemplateLiteral: Parsetree.expression => bool;

  let collectOrPatternChain: Parsetree.pattern => list(Parsetree.pattern);

  let processBracesAttr:
    Parsetree.expression =>
    (option(Parsetree.attribute), Parsetree.expression);

  let filterParsingAttrs: Parsetree.attributes => Parsetree.attributes;

  let isBracedExpr: Parsetree.expression => bool;

  let isPipeExpr: Parsetree.expression => bool;

  let extractValueDescriptionFromModExpr:
    Parsetree.module_expr => list(Parsetree.value_description);

  type jsImportScope =
    | JsGlobalImport /* nothing */
    | JsModuleImport(string) /* from "path" */
    | JsScopedImport(list(string)); /* window.location */

  let classifyJsImport: Parsetree.value_description => jsImportScope;

  /* (__x) => f(a, __x, c) -----> f(a, _, c)  */
  let rewriteUnderscoreApply: Parsetree.expression => Parsetree.expression;

  /* (__x) => f(a, __x, c) -----> f(a, _, c)  */
  let isUnderscoreApplySugar: Parsetree.expression => bool;
} = {
  open Parsetree;

  let arrowType = ct => {
    let rec process = (attrsBefore, acc, typ) =>
      switch (typ) {
      | {
          ptyp_desc: [@implicit_arity] Ptyp_arrow(Nolabel as lbl, typ1, typ2),
          ptyp_attributes: [],
        } =>
        let arg = ([], lbl, typ1);
        process(attrsBefore, [arg, ...acc], typ2);
      | {
          ptyp_desc: [@implicit_arity] Ptyp_arrow(Nolabel as lbl, typ1, typ2),
          ptyp_attributes: [({txt: "bs"}, _)] as attrs,
        } =>
        let arg = (attrs, lbl, typ1);
        process(attrsBefore, [arg, ...acc], typ2);
      | {
          ptyp_desc: [@implicit_arity] Ptyp_arrow(Nolabel, _typ1, _typ2),
          ptyp_attributes: _attrs,
        } as returnType =>
        let args = List.rev(acc);
        (attrsBefore, args, returnType);
      | {
          ptyp_desc:
            [@implicit_arity]
            Ptyp_arrow((Labelled(_) | Optional(_)) as lbl, typ1, typ2),
          ptyp_attributes: attrs,
        } =>
        let arg = (attrs, lbl, typ1);
        process(attrsBefore, [arg, ...acc], typ2);
      | typ => (attrsBefore, List.rev(acc), typ)
      };

    switch (ct) {
    | {
        ptyp_desc: [@implicit_arity] Ptyp_arrow(Nolabel, _typ1, _typ2),
        ptyp_attributes: attrs,
      } as typ =>
      process(attrs, [], {...typ, ptyp_attributes: []})
    | typ => process([], [], typ)
    };
  };

  let functorType = modtype => {
    let rec process = (acc, modtype) =>
      switch (modtype) {
      | {
          pmty_desc: [@implicit_arity] Pmty_functor(lbl, argType, returnType),
          pmty_attributes: attrs,
        } =>
        let arg = (attrs, lbl, argType);
        process([arg, ...acc], returnType);
      | modType => (List.rev(acc), modType)
      };

    process([], modtype);
  };

  let processUncurriedAttribute = attrs => {
    let rec process = (uncurriedSpotted, acc, attrs) =>
      switch (attrs) {
      | [] => (uncurriedSpotted, List.rev(acc))
      | [({Location.txt: "bs"}, _), ...rest] => process(true, acc, rest)
      | [attr, ...rest] => process(uncurriedSpotted, [attr, ...acc], rest)
      };

    process(false, [], attrs);
  };

  let collectIfExpressions = expr => {
    let rec collect = (acc, expr) =>
      switch (expr.pexp_desc) {
      | [@implicit_arity] Pexp_ifthenelse(ifExpr, thenExpr, Some(elseExpr)) =>
        collect([(ifExpr, thenExpr), ...acc], elseExpr)
      | [@implicit_arity] Pexp_ifthenelse(ifExpr, thenExpr, None as elseExpr) =>
        let ifs = List.rev([(ifExpr, thenExpr), ...acc]);
        (ifs, elseExpr);
      | _ => (List.rev(acc), Some(expr))
      };

    collect([], expr);
  };

  let collectListExpressions = expr => {
    let rec collect = (acc, expr) =>
      switch (expr.pexp_desc) {
      | [@implicit_arity] Pexp_construct({txt: Longident.Lident("[]")}, _) => (
          List.rev(acc),
          None,
        )
      | [@implicit_arity]
        Pexp_construct(
          {txt: Longident.Lident("::")},
          Some({pexp_desc: Pexp_tuple([hd, tail])}),
        ) =>
        collect([hd, ...acc], tail)
      | _ => (List.rev(acc), Some(expr))
      };

    collect([], expr);
  };

  /* (__x) => f(a, __x, c) -----> f(a, _, c)  */
  let rewriteUnderscoreApply = expr =>
    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_fun(
        Nolabel,
        None,
        {ppat_desc: Ppat_var({txt: "__x"})},
        {pexp_desc: [@implicit_arity] Pexp_apply(callExpr, args)} as e,
      ) =>
      let newArgs =
        List.map(
          arg =>
            switch (arg) {
            | (
                lbl,
                {
                  pexp_desc:
                    Pexp_ident({txt: Longident.Lident("__x")} as lid),
                } as argExpr,
              ) => (
                lbl,
                {
                  ...argExpr,
                  pexp_desc:
                    Pexp_ident({...lid, txt: Longident.Lident("_")}),
                },
              )
            | arg => arg
            },
          args,
        );
      {...e, pexp_desc: [@implicit_arity] Pexp_apply(callExpr, newArgs)};
    | _ => expr
    };

  type funParamKind =
    | Parameter({
        attrs: Parsetree.attributes,
        lbl: Asttypes.arg_label,
        defaultExpr: option(Parsetree.expression),
        pat: Parsetree.pattern,
      })
    | NewTypes({
        attrs: Parsetree.attributes,
        locs: list(Asttypes.loc(string)),
      });

  let funExpr = expr => {
    /* Turns (type t, type u, type z) into "type t u z" */
    let rec collectNewTypes = (acc, returnExpr) =>
      switch (returnExpr) {
      | {
          pexp_desc: [@implicit_arity] Pexp_newtype(stringLoc, returnExpr),
          pexp_attributes: [],
        } =>
        collectNewTypes([stringLoc, ...acc], returnExpr)
      | returnExpr => (List.rev(acc), returnExpr)
      };

    let rec collect = (attrsBefore, acc, expr) =>
      switch (expr) {
      | {
          pexp_desc:
            [@implicit_arity]
            Pexp_fun(
              Nolabel,
              None,
              {ppat_desc: Ppat_var({txt: "__x"})},
              {pexp_desc: Pexp_apply(_)},
            ),
        } => (
          attrsBefore,
          List.rev(acc),
          rewriteUnderscoreApply(expr),
        )
      | {
          pexp_desc:
            [@implicit_arity] Pexp_fun(lbl, defaultExpr, pattern, returnExpr),
          pexp_attributes: [],
        } =>
        let parameter =
          Parameter({attrs: [], lbl, defaultExpr, pat: pattern});
        collect(attrsBefore, [parameter, ...acc], returnExpr);
      | {
          pexp_desc: [@implicit_arity] Pexp_newtype(stringLoc, rest),
          pexp_attributes: attrs,
        } =>
        let (stringLocs, returnExpr) = collectNewTypes([stringLoc], rest);
        let param = NewTypes({attrs, locs: stringLocs});
        collect(attrsBefore, [param, ...acc], returnExpr);
      | {
          pexp_desc:
            [@implicit_arity] Pexp_fun(lbl, defaultExpr, pattern, returnExpr),
          pexp_attributes: [({txt: "bs"}, _)] as attrs,
        } =>
        let parameter = Parameter({attrs, lbl, defaultExpr, pat: pattern});
        collect(attrsBefore, [parameter, ...acc], returnExpr);
      | {
          pexp_desc:
            [@implicit_arity]
            Pexp_fun(
              (Labelled(_) | Optional(_)) as lbl,
              defaultExpr,
              pattern,
              returnExpr,
            ),
          pexp_attributes: attrs,
        } =>
        let parameter = Parameter({attrs, lbl, defaultExpr, pat: pattern});
        collect(attrsBefore, [parameter, ...acc], returnExpr);
      | expr => (attrsBefore, List.rev(acc), expr)
      };

    switch (expr) {
    | {
        pexp_desc:
          [@implicit_arity]
          Pexp_fun(Nolabel, _defaultExpr, _pattern, _returnExpr),
        pexp_attributes: attrs,
      } as expr =>
      collect(attrs, [], {...expr, pexp_attributes: []})
    | expr => collect([], [], expr)
    };
  };

  let processBracesAttr = expr =>
    switch (expr.pexp_attributes) {
    | [({txt: "ns.braces"}, _) as attr, ...attrs] => (
        Some(attr),
        {...expr, pexp_attributes: attrs},
      )
    | _ => (None, expr)
    };

  let filterParsingAttrs = attrs =>
    List.filter(
      attr =>
        switch (attr) {
        | (
            {
              Location.txt:
                "ns.ternary" | "ns.braces" | "bs" | "ns.namedArgLoc",
            },
            _,
          ) =>
          false
        | _ => true
        },
      attrs,
    );

  let isBlockExpr = expr =>
    switch (expr.pexp_desc) {
    | Pexp_letmodule(_)
    | Pexp_letexception(_)
    | Pexp_let(_)
    | Pexp_open(_)
    | Pexp_sequence(_) => true
    | _ => false
    };

  let isBracedExpr = expr =>
    switch (processBracesAttr(expr)) {
    | (Some(_), _) => true
    | _ => false
    };

  let isHuggableExpression = expr =>
    switch (expr.pexp_desc) {
    | Pexp_array(_)
    | Pexp_tuple(_)
    | [@implicit_arity]
      Pexp_construct({txt: Longident.Lident("::" | "[]")}, _)
    | [@implicit_arity] Pexp_extension({txt: "bs.obj"}, _)
    | Pexp_record(_) => true
    | _ when isBlockExpr(expr) => true
    | _ when isBracedExpr(expr) => true
    | _ => false
    };

  let isHuggableRhs = expr =>
    switch (expr.pexp_desc) {
    | Pexp_array(_)
    | Pexp_tuple(_)
    | [@implicit_arity]
      Pexp_construct({txt: Longident.Lident("::" | "[]")}, _)
    | [@implicit_arity] Pexp_extension({txt: "bs.obj"}, _)
    | Pexp_record(_) => true
    | _ when isBracedExpr(expr) => true
    | _ => false
    };

  let isHuggablePattern = pattern =>
    switch (pattern.ppat_desc) {
    | Ppat_array(_)
    | Ppat_tuple(_)
    | Ppat_record(_)
    | Ppat_construct(_) => true
    | _ => false
    };

  let operatorPrecedence = operator =>
    switch (operator) {
    | ":=" => 1
    | "||" => 2
    | "&&" => 3
    | "="
    | "=="
    | "<"
    | ">"
    | "!="
    | "<>"
    | "!=="
    | "<="
    | ">="
    | "|>" => 4
    | "+"
    | "+."
    | "-"
    | "-."
    | "^" => 5
    | "*"
    | "*."
    | "/"
    | "/." => 6
    | "**" => 7
    | "#"
    | "##"
    | "|." => 8
    | _ => 0
    };

  let isUnaryOperator = operator =>
    switch (operator) {
    | "~+"
    | "~+."
    | "~-"
    | "~-."
    | "not" => true
    | _ => false
    };

  let isUnaryExpression = expr =>
    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_apply(
        {pexp_desc: Pexp_ident({txt: Longident.Lident(operator)})},
        [(Nolabel, _arg)],
      )
        when isUnaryOperator(operator) =>
      true
    | _ => false
    };

  let isBinaryOperator = operator =>
    switch (operator) {
    | ":="
    | "||"
    | "&&"
    | "="
    | "=="
    | "<"
    | ">"
    | "!="
    | "!=="
    | "<="
    | ">="
    | "|>"
    | "+"
    | "+."
    | "-"
    | "-."
    | "^"
    | "*"
    | "*."
    | "/"
    | "/."
    | "**"
    | "|."
    | "<>" => true
    | _ => false
    };

  let isBinaryExpression = expr =>
    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_apply(
        {pexp_desc: Pexp_ident({txt: Longident.Lident(operator)})},
        [(Nolabel, _operand1), (Nolabel, _operand2)],
      )
        when isBinaryOperator(operator) =>
      true
    | _ => false
    };

  let isEqualityOperator = operator =>
    switch (operator) {
    | "="
    | "=="
    | "<>"
    | "!=" => true
    | _ => false
    };

  let flattenableOperators = (parentOperator, childOperator) => {
    let precParent = operatorPrecedence(parentOperator);
    let precChild = operatorPrecedence(childOperator);
    if (precParent === precChild) {
      !(
        isEqualityOperator(parentOperator)
        && isEqualityOperator(childOperator)
      );
    } else {
      false;
    };
  };

  let hasAttributes = attrs =>
    List.exists(
      attr =>
        switch (attr) {
        | ({Location.txt: "bs" | "ns.ternary" | "ns.braces"}, _) => false
        | _ => true
        },
      attrs,
    );

  let isArrayAccess = expr =>
    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_apply(
        {
          pexp_desc:
            Pexp_ident({
              txt: [@implicit_arity] Longident.Ldot(Lident("Array"), "get"),
            }),
        },
        [(Nolabel, _parentExpr), (Nolabel, _memberExpr)],
      ) =>
      true
    | _ => false
    };

  let rec hasTernaryAttribute = attrs =>
    switch (attrs) {
    | [] => false
    | [({Location.txt: "ns.ternary"}, _), ..._] => true
    | [_, ...attrs] => hasTernaryAttribute(attrs)
    };

  let isTernaryExpr = expr =>
    switch (expr) {
    | {pexp_attributes: attrs, pexp_desc: Pexp_ifthenelse(_)}
        when hasTernaryAttribute(attrs) =>
      true
    | _ => false
    };

  let collectTernaryParts = expr => {
    let rec collect = (acc, expr) =>
      switch (expr) {
      | {
          pexp_attributes: attrs,
          pexp_desc:
            [@implicit_arity]
            Pexp_ifthenelse(condition, consequent, Some(alternate)),
        }
          when hasTernaryAttribute(attrs) =>
        collect([(condition, consequent), ...acc], alternate)
      | alternate => (List.rev(acc), alternate)
      };

    collect([], expr);
  };

  let parametersShouldHug = parameters =>
    switch (parameters) {
    | [Parameter({attrs: [], lbl: Asttypes.Nolabel, defaultExpr: None, pat})]
        when isHuggablePattern(pat) =>
      true
    | _ => false
    };

  let filterTernaryAttributes = attrs =>
    List.filter(
      attr =>
        switch (attr) {
        | ({Location.txt: "ns.ternary"}, _) => false
        | _ => true
        },
      attrs,
    );

  let isJsxExpression = expr => {
    let rec loop = attrs =>
      switch (attrs) {
      | [] => false
      | [({Location.txt: "JSX"}, _), ..._] => true
      | [_, ...attrs] => loop(attrs)
      };

    switch (expr.pexp_desc) {
    | Pexp_apply(_) => loop(expr.Parsetree.pexp_attributes)
    | _ => false
    };
  };

  let hasJsxAttribute = attributes =>
    switch (attributes) {
    | [({Location.txt: "JSX"}, _), ..._] => true
    | _ => false
    };

  let shouldIndentBinaryExpr = expr => {
    let samePrecedenceSubExpression = (operator, subExpression) =>
      switch (subExpression) {
      | {
          pexp_desc:
            [@implicit_arity]
            Pexp_apply(
              {pexp_desc: Pexp_ident({txt: Longident.Lident(subOperator)})},
              [(Nolabel, _lhs), (Nolabel, _rhs)],
            ),
        }
          when isBinaryOperator(subOperator) =>
        flattenableOperators(operator, subOperator)
      | _ => true
      };

    switch (expr) {
    | {
        pexp_desc:
          [@implicit_arity]
          Pexp_apply(
            {pexp_desc: Pexp_ident({txt: Longident.Lident(operator)})},
            [(Nolabel, lhs), (Nolabel, _rhs)],
          ),
      }
        when isBinaryOperator(operator) =>
      isEqualityOperator(operator)
      || !samePrecedenceSubExpression(operator, lhs)
      || operator == ":="
    | _ => false
    };
  };

  let shouldInlineRhsBinaryExpr = rhs =>
    switch (rhs.pexp_desc) {
    | Parsetree.Pexp_constant(_)
    | Pexp_let(_)
    | Pexp_letmodule(_)
    | Pexp_letexception(_)
    | Pexp_sequence(_)
    | Pexp_open(_)
    | Pexp_ifthenelse(_)
    | Pexp_for(_)
    | Pexp_while(_)
    | Pexp_try(_)
    | Pexp_array(_)
    | Pexp_record(_) => true
    | _ => false
    };

  let filterPrinteableAttributes = attrs =>
    List.filter(
      attr =>
        switch (attr) {
        | ({Location.txt: "bs" | "ns.ternary"}, _) => false
        | _ => true
        },
      attrs,
    );

  let partitionPrinteableAttributes = attrs =>
    List.partition(
      attr =>
        switch (attr) {
        | ({Location.txt: "bs" | "ns.ternary"}, _) => false
        | _ => true
        },
      attrs,
    );

  let requiresSpecialCallbackPrintingLastArg = args => {
    let rec loop = args =>
      switch (args) {
      | [] => false
      | [(_, {pexp_desc: Pexp_fun(_) | Pexp_newtype(_)})] => true
      | [(_, {pexp_desc: Pexp_fun(_) | Pexp_newtype(_)}), ..._] => false
      | [_, ...rest] => loop(rest)
      };

    loop(args);
  };

  let requiresSpecialCallbackPrintingFirstArg = args => {
    let rec loop = args =>
      switch (args) {
      | [] => true
      | [(_, {pexp_desc: Pexp_fun(_) | Pexp_newtype(_)}), ..._] => false
      | [_, ...rest] => loop(rest)
      };

    switch (args) {
    | [(_, {pexp_desc: Pexp_fun(_) | Pexp_newtype(_)})] => false
    | [(_, {pexp_desc: Pexp_fun(_) | Pexp_newtype(_)}), ...rest] =>
      loop(rest)
    | _ => false
    };
  };

  let modExprApply = modExpr => {
    let rec loop = (acc, modExpr) =>
      switch (modExpr) {
      | {pmod_desc: [@implicit_arity] Pmod_apply(next, arg)} =>
        loop([arg, ...acc], next)
      | _ => (acc, modExpr)
      };

    loop([], modExpr);
  };

  let modExprFunctor = modExpr => {
    let rec loop = (acc, modExpr) =>
      switch (modExpr) {
      | {
          pmod_desc:
            [@implicit_arity] Pmod_functor(lbl, modType, returnModExpr),
          pmod_attributes: attrs,
        } =>
        let param = (attrs, lbl, modType);
        loop([param, ...acc], returnModExpr);
      | returnModExpr => (List.rev(acc), returnModExpr)
      };

    loop([], modExpr);
  };

  let splitGenTypeAttr = attrs =>
    switch (attrs) {
    | [({Location.txt: "genType"}, _), ...attrs] => (true, attrs)
    | attrs => (false, attrs)
    };

  let rec collectPatternsFromListConstruct = (acc, pattern) =>
    Parsetree.(
      switch (pattern.ppat_desc) {
      | [@implicit_arity]
        Ppat_construct(
          {txt: Longident.Lident("::")},
          Some({ppat_desc: Ppat_tuple([pat, rest])}),
        ) =>
        collectPatternsFromListConstruct([pat, ...acc], rest)
      | _ => (List.rev(acc), pattern)
      }
    );

  let rec isTemplateLiteral = expr => {
    let isPexpConstantString = expr =>
      switch (expr.pexp_desc) {
      | Pexp_constant([@implicit_arity] Pconst_string(_, Some(_))) => true
      | _ => false
      };

    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_apply(
        {pexp_desc: Pexp_ident({txt: Longident.Lident("^")})},
        [(Nolabel, arg1), (Nolabel, arg2)],
      )
        when !(isPexpConstantString(arg1) && isPexpConstantString(arg2)) =>
      isTemplateLiteral(arg1) || isTemplateLiteral(arg2)
    | Pexp_constant([@implicit_arity] Pconst_string(_, Some(_))) => true
    | _ => false
    };
  };

  /* Blue | Red | Green -> [Blue; Red; Green] */
  let collectOrPatternChain = pat => {
    let rec loop = (pattern, chain) =>
      switch (pattern.ppat_desc) {
      | [@implicit_arity] Ppat_or(left, right) =>
        loop(left, [right, ...chain])
      | _ => [pattern, ...chain]
      };

    loop(pat, []);
  };

  let isPipeExpr = expr =>
    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_apply(
        {pexp_desc: Pexp_ident({txt: Longident.Lident("|." | "|>")})},
        [(Nolabel, _operand1), (Nolabel, _operand2)],
      ) =>
      true
    | _ => false
    };

  let extractValueDescriptionFromModExpr = modExpr => {
    let rec loop = (structure, acc) =>
      switch (structure) {
      | [] => List.rev(acc)
      | [structureItem, ...structure] =>
        switch (structureItem.Parsetree.pstr_desc) {
        | Pstr_primitive(vd) => loop(structure, [vd, ...acc])
        | _ => loop(structure, acc)
        }
      };

    switch (modExpr.pmod_desc) {
    | Pmod_structure(structure) => loop(structure, [])
    | _ => []
    };
  };

  type jsImportScope =
    | JsGlobalImport /* nothing */
    | JsModuleImport(string) /* from "path" */
    | JsScopedImport(list(string)); /* window.location */

  let classifyJsImport = valueDescription => {
    let rec loop = attrs =>
      Parsetree.(
        switch (attrs) {
        | [] => JsGlobalImport
        | [
            (
              {Location.txt: "bs.scope"},
              PStr([
                {
                  pstr_desc:
                    [@implicit_arity]
                    Pstr_eval(
                      {
                        pexp_desc:
                          Pexp_constant(
                            [@implicit_arity] Pconst_string(s, _),
                          ),
                      },
                      _,
                    ),
                },
              ]),
            ),
            ..._,
          ] =>
          JsScopedImport([s])
        | [
            (
              {Location.txt: "genType.import"},
              PStr([
                {
                  pstr_desc:
                    [@implicit_arity]
                    Pstr_eval(
                      {
                        pexp_desc:
                          Pexp_constant(
                            [@implicit_arity] Pconst_string(s, _),
                          ),
                      },
                      _,
                    ),
                },
              ]),
            ),
            ..._,
          ] =>
          JsModuleImport(s)
        | [
            (
              {Location.txt: "bs.scope"},
              PStr([
                {
                  pstr_desc:
                    [@implicit_arity]
                    Pstr_eval({pexp_desc: Pexp_tuple(exprs)}, _),
                },
              ]),
            ),
            ..._,
          ] =>
          let scopes =
            List.fold_left(
              (acc, curr) =>
                switch (curr.Parsetree.pexp_desc) {
                | Pexp_constant([@implicit_arity] Pconst_string(s, _)) => [
                    s,
                    ...acc,
                  ]
                | _ => acc
                },
              [],
              exprs,
            );

          JsScopedImport(List.rev(scopes));
        | [_, ...attrs] => loop(attrs)
        }
      );

    loop(valueDescription.pval_attributes);
  };

  let isUnderscoreApplySugar = expr =>
    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_fun(
        Nolabel,
        None,
        {ppat_desc: Ppat_var({txt: "__x"})},
        {pexp_desc: Pexp_apply(_)},
      ) =>
      true
    | _ => false
    };
};

module Parens: {
  type kind =
    | Parenthesized
    | Braced(Location.t)
    | Nothing;

  let expr: Parsetree.expression => kind;
  let structureExpr: Parsetree.expression => kind;

  let unaryExprOperand: Parsetree.expression => kind;

  let binaryExprOperand: (~isLhs: bool, Parsetree.expression) => kind;
  let subBinaryExprOperand: (string, string) => bool;
  let rhsBinaryExprOperand: (string, Parsetree.expression) => bool;
  let flattenOperandRhs: (string, Parsetree.expression) => bool;

  let lazyOrAssertExprRhs: Parsetree.expression => kind;

  let fieldExpr: Parsetree.expression => kind;

  let setFieldExprRhs: Parsetree.expression => kind;

  let ternaryOperand: Parsetree.expression => kind;

  let jsxPropExpr: Parsetree.expression => kind;
  let jsxChildExpr: Parsetree.expression => kind;

  let binaryExpr: Parsetree.expression => kind;
  let modTypeFunctorReturn: Parsetree.module_type => bool;
  let modTypeWithOperand: Parsetree.module_type => bool;
  let modExprFunctorConstraint: Parsetree.module_type => bool;

  let bracedExpr: Parsetree.expression => bool;
  let callExpr: Parsetree.expression => kind;

  let includeModExpr: Parsetree.module_expr => bool;
} = {
  type kind =
    | Parenthesized
    | Braced(Location.t)
    | Nothing;

  let expr = expr => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | _ =>
      switch (expr) {
      | {
          Parsetree.pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_pack(_)},
              {ptyp_desc: Ptyp_package(_)},
            ),
        } =>
        Nothing
      | {pexp_desc: Pexp_constraint(_)} => Parenthesized
      | _ => Nothing
      }
    };
  };

  let callExpr = expr => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | _ =>
      switch (expr) {
      | {Parsetree.pexp_attributes: attrs}
          when
            switch (ParsetreeViewer.filterParsingAttrs(attrs)) {
            | [_, ..._] => true
            | [] => false
            } =>
        Parenthesized
      | _
          when
            ParsetreeViewer.isUnaryExpression(expr)
            || ParsetreeViewer.isBinaryExpression(expr) =>
        Parenthesized
      | {
          Parsetree.pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_pack(_)},
              {ptyp_desc: Ptyp_package(_)},
            ),
        } =>
        Nothing
      | {pexp_desc: Pexp_fun(_)}
          when ParsetreeViewer.isUnderscoreApplySugar(expr) =>
        Nothing
      | {
          pexp_desc:
            Pexp_lazy(_) | Pexp_assert(_) | Pexp_fun(_) | Pexp_newtype(_) |
            Pexp_function(_) |
            Pexp_constraint(_) |
            Pexp_setfield(_) |
            Pexp_match(_) |
            Pexp_try(_) |
            Pexp_while(_) |
            Pexp_for(_) |
            Pexp_ifthenelse(_),
        } =>
        Parenthesized
      | _ => Nothing
      }
    };
  };

  let structureExpr = expr => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | None =>
      switch (expr) {
      | _
          when
            ParsetreeViewer.hasAttributes(expr.pexp_attributes)
            && !ParsetreeViewer.isJsxExpression(expr) =>
        Parenthesized
      | {
          Parsetree.pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_pack(_)},
              {ptyp_desc: Ptyp_package(_)},
            ),
        } =>
        Nothing
      | {pexp_desc: Pexp_constraint(_)} => Parenthesized
      | _ => Nothing
      }
    };
  };

  let unaryExprOperand = expr => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | None =>
      switch (expr) {
      | {Parsetree.pexp_attributes: attrs}
          when
            switch (ParsetreeViewer.filterParsingAttrs(attrs)) {
            | [_, ..._] => true
            | [] => false
            } =>
        Parenthesized
      | expr
          when
            ParsetreeViewer.isUnaryExpression(expr)
            || ParsetreeViewer.isBinaryExpression(expr) =>
        Parenthesized
      | {
          pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_pack(_)},
              {ptyp_desc: Ptyp_package(_)},
            ),
        } =>
        Nothing
      | {pexp_desc: Pexp_fun(_)}
          when ParsetreeViewer.isUnderscoreApplySugar(expr) =>
        Nothing
      | {
          pexp_desc:
            Pexp_lazy(_) | Pexp_assert(_) | Pexp_fun(_) | Pexp_newtype(_) |
            Pexp_function(_) |
            Pexp_constraint(_) |
            Pexp_setfield(_) |
            Pexp_extension(_) | /* readability? maybe remove */
            Pexp_match(_) |
            Pexp_try(_) |
            Pexp_while(_) |
            Pexp_for(_) |
            Pexp_ifthenelse(_),
        } =>
        Parenthesized
      | _ => Nothing
      }
    };
  };

  let binaryExprOperand = (~isLhs, expr) => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | None =>
      switch (expr) {
      | {
          Parsetree.pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_pack(_)},
              {ptyp_desc: Ptyp_package(_)},
            ),
        } =>
        Nothing
      | {pexp_desc: Pexp_fun(_)}
          when ParsetreeViewer.isUnderscoreApplySugar(expr) =>
        Nothing
      | {
          pexp_desc:
            Pexp_constraint(_) | Pexp_fun(_) | Pexp_function(_) |
            Pexp_newtype(_),
        } =>
        Parenthesized
      | expr when ParsetreeViewer.isBinaryExpression(expr) => Parenthesized
      | expr when ParsetreeViewer.isTernaryExpr(expr) => Parenthesized
      | {pexp_desc: Pexp_lazy(_) | Pexp_assert(_)} when isLhs => Parenthesized
      | _ => Nothing
      }
    };
  };

  let subBinaryExprOperand = (parentOperator, childOperator) => {
    let precParent = ParsetreeViewer.operatorPrecedence(parentOperator);
    let precChild = ParsetreeViewer.operatorPrecedence(childOperator);
    precParent > precChild
    || precParent === precChild
    && !ParsetreeViewer.flattenableOperators(parentOperator, childOperator)
    /* a && b || c, add parens to (a && b) for readability, who knows the difference by heart… */
    || parentOperator == "||"
    && childOperator == "&&";
  };

  let rhsBinaryExprOperand = (parentOperator, rhs) =>
    switch (rhs.Parsetree.pexp_desc) {
    | [@implicit_arity]
      Parsetree.Pexp_apply(
        {
          pexp_attributes: [],
          pexp_desc: Pexp_ident({txt: Longident.Lident(operator)}),
        },
        [(_, _left), (_, _right)],
      )
        when ParsetreeViewer.isBinaryOperator(operator) =>
      let precParent = ParsetreeViewer.operatorPrecedence(parentOperator);
      let precChild = ParsetreeViewer.operatorPrecedence(operator);
      precParent === precChild;
    | _ => false
    };

  let flattenOperandRhs = (parentOperator, rhs) =>
    switch (rhs.Parsetree.pexp_desc) {
    | [@implicit_arity]
      Parsetree.Pexp_apply(
        {pexp_desc: Pexp_ident({txt: Longident.Lident(operator)})},
        [(_, _left), (_, _right)],
      )
        when ParsetreeViewer.isBinaryOperator(operator) =>
      let precParent = ParsetreeViewer.operatorPrecedence(parentOperator);
      let precChild = ParsetreeViewer.operatorPrecedence(operator);
      precParent >= precChild || rhs.pexp_attributes != [];
    | [@implicit_arity]
      Pexp_constraint(
        {pexp_desc: Pexp_pack(_)},
        {ptyp_desc: Ptyp_package(_)},
      ) =>
      false
    | Pexp_fun(_) when ParsetreeViewer.isUnderscoreApplySugar(rhs) => false
    | Pexp_fun(_)
    | Pexp_newtype(_)
    | Pexp_setfield(_)
    | Pexp_constraint(_) => true
    | _ when ParsetreeViewer.isTernaryExpr(rhs) => true
    | _ => false
    };

  let lazyOrAssertExprRhs = expr => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | None =>
      switch (expr) {
      | {Parsetree.pexp_attributes: attrs}
          when
            switch (ParsetreeViewer.filterParsingAttrs(attrs)) {
            | [_, ..._] => true
            | [] => false
            } =>
        Parenthesized
      | expr when ParsetreeViewer.isBinaryExpression(expr) => Parenthesized
      | {
          pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_pack(_)},
              {ptyp_desc: Ptyp_package(_)},
            ),
        } =>
        Nothing
      | {pexp_desc: Pexp_fun(_)}
          when ParsetreeViewer.isUnderscoreApplySugar(expr) =>
        Nothing
      | {
          pexp_desc:
            Pexp_lazy(_) | Pexp_assert(_) | Pexp_fun(_) | Pexp_newtype(_) |
            Pexp_function(_) |
            Pexp_constraint(_) |
            Pexp_setfield(_) |
            Pexp_match(_) |
            Pexp_try(_) |
            Pexp_while(_) |
            Pexp_for(_) |
            Pexp_ifthenelse(_),
        } =>
        Parenthesized
      | _ => Nothing
      }
    };
  };

  let isNegativeConstant = constant => {
    let isNeg = txt => {
      let len = String.length(txt);
      len > 0 && txt.[0] == '-';
    };

    switch (constant) {
    | [@implicit_arity] Parsetree.Pconst_integer(i, _)
    | [@implicit_arity] Pconst_float(i, _) when isNeg(i) => true
    | _ => false
    };
  };

  let fieldExpr = expr => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | None =>
      switch (expr) {
      | {Parsetree.pexp_attributes: attrs}
          when
            switch (ParsetreeViewer.filterParsingAttrs(attrs)) {
            | [_, ..._] => true
            | [] => false
            } =>
        Parenthesized
      | expr
          when
            ParsetreeViewer.isBinaryExpression(expr)
            || ParsetreeViewer.isUnaryExpression(expr) =>
        Parenthesized
      | {
          pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_pack(_)},
              {ptyp_desc: Ptyp_package(_)},
            ),
        } =>
        Nothing
      | {pexp_desc: Pexp_constant(c)} when isNegativeConstant(c) =>
        Parenthesized
      | {pexp_desc: Pexp_fun(_)}
          when ParsetreeViewer.isUnderscoreApplySugar(expr) =>
        Nothing
      | {
          pexp_desc:
            Pexp_lazy(_) | Pexp_assert(_) | Pexp_extension(_) | /* %extension.x vs (%extension).x */
            Pexp_fun(_) |
            Pexp_newtype(_) |
            Pexp_function(_) |
            Pexp_constraint(_) |
            Pexp_setfield(_) |
            Pexp_match(_) |
            Pexp_try(_) |
            Pexp_while(_) |
            Pexp_for(_) |
            Pexp_ifthenelse(_),
        } =>
        Parenthesized
      | _ => Nothing
      }
    };
  };

  let setFieldExprRhs = expr => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | None =>
      switch (expr) {
      | {
          Parsetree.pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_pack(_)},
              {ptyp_desc: Ptyp_package(_)},
            ),
        } =>
        Nothing
      | {pexp_desc: Pexp_constraint(_)} => Parenthesized
      | _ => Nothing
      }
    };
  };

  let ternaryOperand = expr => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | None =>
      switch (expr) {
      | {
          Parsetree.pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_pack(_)},
              {ptyp_desc: Ptyp_package(_)},
            ),
        } =>
        Nothing
      | {pexp_desc: Pexp_constraint(_)} => Parenthesized
      | {pexp_desc: Pexp_fun(_) | Pexp_newtype(_)} =>
        let (_attrsOnArrow, _parameters, returnExpr) =
          ParsetreeViewer.funExpr(expr);
        switch (returnExpr.pexp_desc) {
        | Pexp_constraint(_) => Parenthesized
        | _ => Nothing
        };
      | _ => Nothing
      }
    };
  };

  let startsWithMinus = txt => {
    let len = String.length(txt);
    if (len === 0) {
      false;
    } else {
      let s = txt.[0];
      s == '-';
    };
  };

  let jsxPropExpr = expr =>
    switch (expr.Parsetree.pexp_desc) {
    | Parsetree.Pexp_let(_)
    | Pexp_sequence(_)
    | Pexp_letexception(_)
    | Pexp_letmodule(_)
    | Pexp_open(_) => Nothing
    | _ =>
      let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
      switch (optBraces) {
      | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
      | None =>
        switch (expr) {
        | {
            Parsetree.pexp_desc:
              Pexp_constant(
                [@implicit_arity] Pconst_integer(x, _) |
                [@implicit_arity] Pconst_float(x, _),
              ),
            pexp_attributes: [],
          }
            when startsWithMinus(x) =>
          Parenthesized
        | {
            Parsetree.pexp_desc:
              Pexp_ident(_) | Pexp_constant(_) | Pexp_field(_) |
              Pexp_construct(_) |
              Pexp_variant(_) |
              Pexp_array(_) |
              Pexp_pack(_) |
              Pexp_record(_) |
              Pexp_extension(_) |
              Pexp_letmodule(_) |
              Pexp_letexception(_) |
              Pexp_open(_) |
              Pexp_sequence(_) |
              Pexp_let(_) |
              Pexp_tuple(_),
            pexp_attributes: [],
          } =>
          Nothing
        | {
            Parsetree.pexp_desc:
              [@implicit_arity]
              Pexp_constraint(
                {pexp_desc: Pexp_pack(_)},
                {ptyp_desc: Ptyp_package(_)},
              ),
            pexp_attributes: [],
          } =>
          Nothing
        | _ => Parenthesized
        }
      };
    };

  let jsxChildExpr = expr =>
    switch (expr.Parsetree.pexp_desc) {
    | Parsetree.Pexp_let(_)
    | Pexp_sequence(_)
    | Pexp_letexception(_)
    | Pexp_letmodule(_)
    | Pexp_open(_) => Nothing
    | _ =>
      let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
      switch (optBraces) {
      | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
      | _ =>
        switch (expr) {
        | {
            Parsetree.pexp_desc:
              Pexp_constant(
                [@implicit_arity] Pconst_integer(x, _) |
                [@implicit_arity] Pconst_float(x, _),
              ),
            pexp_attributes: [],
          }
            when startsWithMinus(x) =>
          Parenthesized
        | {
            Parsetree.pexp_desc:
              Pexp_ident(_) | Pexp_constant(_) | Pexp_field(_) |
              Pexp_construct(_) |
              Pexp_variant(_) |
              Pexp_array(_) |
              Pexp_pack(_) |
              Pexp_record(_) |
              Pexp_extension(_) |
              Pexp_letmodule(_) |
              Pexp_letexception(_) |
              Pexp_open(_) |
              Pexp_sequence(_) |
              Pexp_let(_),
            pexp_attributes: [],
          } =>
          Nothing
        | {
            Parsetree.pexp_desc:
              [@implicit_arity]
              Pexp_constraint(
                {pexp_desc: Pexp_pack(_)},
                {ptyp_desc: Ptyp_package(_)},
              ),
            pexp_attributes: [],
          } =>
          Nothing
        | expr when ParsetreeViewer.isJsxExpression(expr) => Nothing
        | _ => Parenthesized
        }
      };
    };

  let binaryExpr = expr => {
    let (optBraces, _) = ParsetreeViewer.processBracesAttr(expr);
    switch (optBraces) {
    | Some(({Location.loc: bracesLoc}, _)) => Braced(bracesLoc)
    | None =>
      switch (expr) {
      | {Parsetree.pexp_attributes: [_, ..._]} as expr
          when ParsetreeViewer.isBinaryExpression(expr) =>
        Parenthesized
      | _ => Nothing
      }
    };
  };

  let modTypeFunctorReturn = modType =>
    switch (modType) {
    | {Parsetree.pmty_desc: Pmty_with(_)} => true
    | _ => false
    };

  /* Add parens for readability:
          module type Functor = SetLike => Set with type t = A.t
        This is actually:
          module type Functor = (SetLike => Set) with type t = A.t
     */
  let modTypeWithOperand = modType =>
    switch (modType) {
    | {Parsetree.pmty_desc: Pmty_functor(_)} => true
    | _ => false
    };

  let modExprFunctorConstraint = modType =>
    switch (modType) {
    | {Parsetree.pmty_desc: Pmty_functor(_) | Pmty_with(_)} => true
    | _ => false
    };

  let bracedExpr = expr =>
    switch (expr.Parsetree.pexp_desc) {
    | [@implicit_arity]
      Pexp_constraint(
        {pexp_desc: Pexp_pack(_)},
        {ptyp_desc: Ptyp_package(_)},
      ) =>
      false
    | Pexp_constraint(_) => true
    | _ => false
    };

  let includeModExpr = modExpr =>
    switch (modExpr.Parsetree.pmod_desc) {
    | Parsetree.Pmod_constraint(_) => true
    | _ => false
    };
};

module CommentTable = {
  type t = {
    leading: Hashtbl.t(Location.t, list(Comment.t)),
    inside: Hashtbl.t(Location.t, list(Comment.t)),
    trailing: Hashtbl.t(Location.t, list(Comment.t)),
  };

  let make = () => {
    leading: Hashtbl.create(100),
    inside: Hashtbl.create(100),
    trailing: Hashtbl.create(100),
  };

  let empty = make();

  [@live]
  let log = t => {
    open Location;
    let leadingStuff =
      Hashtbl.fold(
        (k: Location.t, v: list(Comment.t), acc) => {
          let loc =
            Doc.concat([
              Doc.lbracket,
              Doc.text(string_of_int(k.loc_start.pos_lnum)),
              Doc.text(":"),
              Doc.text(
                string_of_int(k.loc_start.pos_cnum - k.loc_start.pos_bol),
              ),
              Doc.text("-"),
              Doc.text(string_of_int(k.loc_end.pos_lnum)),
              Doc.text(":"),
              Doc.text(
                string_of_int(k.loc_end.pos_cnum - k.loc_end.pos_bol),
              ),
              Doc.rbracket,
            ]);
          let doc =
            Doc.breakableGroup(
              ~forceBreak=true,
              Doc.concat([
                loc,
                Doc.indent(
                  Doc.concat([
                    Doc.line,
                    Doc.join(
                      ~sep=Doc.comma,
                      List.map(c => Doc.text(Comment.txt(c)), v),
                    ),
                  ]),
                ),
                Doc.line,
              ]),
            );
          [doc, ...acc];
        },
        t.leading,
        [],
      );

    let trailingStuff =
      Hashtbl.fold(
        (k: Location.t, v: list(Comment.t), acc) => {
          let loc =
            Doc.concat([
              Doc.lbracket,
              Doc.text(string_of_int(k.loc_start.pos_lnum)),
              Doc.text(":"),
              Doc.text(
                string_of_int(k.loc_start.pos_cnum - k.loc_start.pos_bol),
              ),
              Doc.text("-"),
              Doc.text(string_of_int(k.loc_end.pos_lnum)),
              Doc.text(":"),
              Doc.text(
                string_of_int(k.loc_end.pos_cnum - k.loc_end.pos_bol),
              ),
              Doc.rbracket,
            ]);
          let doc =
            Doc.breakableGroup(
              ~forceBreak=true,
              Doc.concat([
                loc,
                Doc.indent(
                  Doc.concat([
                    Doc.line,
                    Doc.join(
                      ~sep=Doc.concat([Doc.comma, Doc.line]),
                      List.map(c => Doc.text(Comment.txt(c)), v),
                    ),
                  ]),
                ),
                Doc.line,
              ]),
            );
          [doc, ...acc];
        },
        t.trailing,
        [],
      );

    Doc.breakableGroup(
      ~forceBreak=true,
      Doc.concat([
        Doc.text("leading comments:"),
        Doc.line,
        Doc.indent(Doc.concat(leadingStuff)),
        Doc.line,
        Doc.line,
        Doc.text("trailing comments:"),
        Doc.indent(Doc.concat(trailingStuff)),
        Doc.line,
        Doc.line,
      ]),
    )
    |> Doc.toString(~width=80)
    |> print_endline;
  };
  let attach = (tbl, loc, comments) =>
    switch (comments) {
    | [] => ()
    | comments => Hashtbl.replace(tbl, loc, comments)
    };

  let partitionByLoc = (comments, loc) => {
    let rec loop = ((leading, inside, trailing), comments) =>
      Location.(
        switch (comments) {
        | [comment, ...rest] =>
          let cmtLoc = Comment.loc(comment);
          if (cmtLoc.loc_end.pos_cnum <= loc.loc_start.pos_cnum) {
            loop(([comment, ...leading], inside, trailing), rest);
          } else if (cmtLoc.loc_start.pos_cnum >= loc.loc_end.pos_cnum) {
            loop((leading, inside, [comment, ...trailing]), rest);
          } else {
            loop((leading, [comment, ...inside], trailing), rest);
          };
        | [] => (List.rev(leading), List.rev(inside), List.rev(trailing))
        }
      );

    loop(([], [], []), comments);
  };

  let partitionLeadingTrailing = (comments, loc) => {
    let rec loop = ((leading, trailing), comments) =>
      Location.(
        switch (comments) {
        | [comment, ...rest] =>
          let cmtLoc = Comment.loc(comment);
          if (cmtLoc.loc_end.pos_cnum <= loc.loc_start.pos_cnum) {
            loop(([comment, ...leading], trailing), rest);
          } else {
            loop((leading, [comment, ...trailing]), rest);
          };
        | [] => (List.rev(leading), List.rev(trailing))
        }
      );

    loop(([], []), comments);
  };

  let partitionByOnSameLine = (loc, comments) => {
    let rec loop = ((onSameLine, onOtherLine), comments) =>
      Location.(
        switch (comments) {
        | [] => (List.rev(onSameLine), List.rev(onOtherLine))
        | [comment, ...rest] =>
          let cmtLoc = Comment.loc(comment);
          if (cmtLoc.loc_start.pos_lnum === loc.loc_end.pos_lnum) {
            loop(([comment, ...onSameLine], onOtherLine), rest);
          } else {
            loop((onSameLine, [comment, ...onOtherLine]), rest);
          };
        }
      );

    loop(([], []), comments);
  };

  let partitionAdjacentTrailing = (loc1, comments) => {
    open Location;
    open Lexing;
    let rec loop = (~prevEndPos, afterLoc1, comments) =>
      switch (comments) {
      | [] => (List.rev(afterLoc1), [])
      | [comment, ...rest] as comments =>
        let cmtPrevEndPos = Comment.prevTokEndPos(comment);
        if (prevEndPos.Lexing.pos_cnum === cmtPrevEndPos.pos_cnum) {
          let commentEnd = Comment.loc(comment).loc_end;
          loop(~prevEndPos=commentEnd, [comment, ...afterLoc1], rest);
        } else {
          (List.rev(afterLoc1), comments);
        };
      };

    loop(~prevEndPos=loc1.loc_end, [], comments);
  };

  let rec collectListPatterns = (acc, pattern) =>
    Parsetree.(
      switch (pattern.ppat_desc) {
      | [@implicit_arity]
        Ppat_construct(
          {txt: Longident.Lident("::")},
          Some({ppat_desc: Ppat_tuple([pat, rest])}),
        ) =>
        collectListPatterns([pat, ...acc], rest)
      | [@implicit_arity] Ppat_construct({txt: Longident.Lident("[]")}, None) =>
        List.rev(acc)
      | _ => List.rev([pattern, ...acc])
      }
    );

  let rec collectListExprs = (acc, expr) =>
    Parsetree.(
      switch (expr.pexp_desc) {
      | [@implicit_arity]
        Pexp_construct(
          {txt: Longident.Lident("::")},
          Some({pexp_desc: Pexp_tuple([expr, rest])}),
        ) =>
        collectListExprs([expr, ...acc], rest)
      | [@implicit_arity] Pexp_construct({txt: Longident.Lident("[]")}, _) =>
        List.rev(acc)
      | _ => List.rev([expr, ...acc])
      }
    );

  /* TODO: use ParsetreeViewer */
  let arrowType = ct => {
    open Parsetree;
    let rec process = (attrsBefore, acc, typ) =>
      switch (typ) {
      | {
          ptyp_desc: [@implicit_arity] Ptyp_arrow(Nolabel as lbl, typ1, typ2),
          ptyp_attributes: [],
        } =>
        let arg = ([], lbl, typ1);
        process(attrsBefore, [arg, ...acc], typ2);
      | {
          ptyp_desc: [@implicit_arity] Ptyp_arrow(Nolabel as lbl, typ1, typ2),
          ptyp_attributes: [({txt: "bs"}, _)] as attrs,
        } =>
        let arg = (attrs, lbl, typ1);
        process(attrsBefore, [arg, ...acc], typ2);
      | {
          ptyp_desc: [@implicit_arity] Ptyp_arrow(Nolabel, _typ1, _typ2),
          ptyp_attributes: _attrs,
        } as returnType =>
        let args = List.rev(acc);
        (attrsBefore, args, returnType);
      | {
          ptyp_desc:
            [@implicit_arity]
            Ptyp_arrow((Labelled(_) | Optional(_)) as lbl, typ1, typ2),
          ptyp_attributes: attrs,
        } =>
        let arg = (attrs, lbl, typ1);
        process(attrsBefore, [arg, ...acc], typ2);
      | typ => (attrsBefore, List.rev(acc), typ)
      };

    switch (ct) {
    | {
        ptyp_desc: [@implicit_arity] Ptyp_arrow(Nolabel, _typ1, _typ2),
        ptyp_attributes: attrs,
      } as typ =>
      process(attrs, [], {...typ, ptyp_attributes: []})
    | typ => process([], [], typ)
    };
  };

  /* TODO: avoiding the dependency on ParsetreeViewer here, is this a good idea? */
  let modExprApply = modExpr => {
    let rec loop = (acc, modExpr) =>
      switch (modExpr) {
      | {Parsetree.pmod_desc: [@implicit_arity] Pmod_apply(next, arg)} =>
        loop([arg, ...acc], next)
      | _ => [modExpr, ...acc]
      };

    loop([], modExpr);
  };

  /* TODO: avoiding the dependency on ParsetreeViewer here, is this a good idea? */
  let modExprFunctor = modExpr => {
    let rec loop = (acc, modExpr) =>
      switch (modExpr) {
      | {
          Parsetree.pmod_desc:
            [@implicit_arity] Pmod_functor(lbl, modType, returnModExpr),
          pmod_attributes: attrs,
        } =>
        let param = (attrs, lbl, modType);
        loop([param, ...acc], returnModExpr);
      | returnModExpr => (List.rev(acc), returnModExpr)
      };

    loop([], modExpr);
  };

  let functorType = modtype => {
    let rec process = (acc, modtype) =>
      switch (modtype) {
      | {
          Parsetree.pmty_desc:
            [@implicit_arity] Pmty_functor(lbl, argType, returnType),
          pmty_attributes: attrs,
        } =>
        let arg = (attrs, lbl, argType);
        process([arg, ...acc], returnType);
      | modType => (List.rev(acc), modType)
      };

    process([], modtype);
  };

  let funExpr = expr => {
    open Parsetree;
    /* Turns (type t, type u, type z) into "type t u z" */
    let rec collectNewTypes = (acc, returnExpr) =>
      switch (returnExpr) {
      | {
          pexp_desc: [@implicit_arity] Pexp_newtype(stringLoc, returnExpr),
          pexp_attributes: [],
        } =>
        collectNewTypes([stringLoc, ...acc], returnExpr)
      | returnExpr =>
        let loc =
          switch (acc, List.rev(acc)) {
          | ([_startLoc, ..._], [endLoc, ..._]) => {
              ...endLoc.loc,
              loc_end: endLoc.loc.loc_end,
            }
          | _ => Location.none
          };

        let txt =
          List.fold_right(
            (curr, acc) => acc ++ " " ++ curr.Location.txt,
            acc,
            "type",
          );
        (Location.mkloc(txt, loc), returnExpr);
      };

    /* For simplicity reason Pexp_newtype gets converted to a Nolabel parameter,
     * otherwise this function would need to return a variant:
     * | NormalParamater(...)
     * | NewType(...)
     * This complicates printing with an extra variant/boxing/allocation for a code-path
     * that is not often used. Lets just keep it simple for now */
    let rec collect = (attrsBefore, acc, expr) =>
      switch (expr) {
      | {
          pexp_desc:
            [@implicit_arity] Pexp_fun(lbl, defaultExpr, pattern, returnExpr),
          pexp_attributes: [],
        } =>
        let parameter = ([], lbl, defaultExpr, pattern);
        collect(attrsBefore, [parameter, ...acc], returnExpr);
      | {
          pexp_desc: [@implicit_arity] Pexp_newtype(stringLoc, rest),
          pexp_attributes: attrs,
        } =>
        let (var, returnExpr) = collectNewTypes([stringLoc], rest);
        let parameter = (
          attrs,
          Asttypes.Nolabel,
          None,
          Ast_helper.Pat.var(~loc=stringLoc.loc, var),
        );
        collect(attrsBefore, [parameter, ...acc], returnExpr);
      | {
          pexp_desc:
            [@implicit_arity] Pexp_fun(lbl, defaultExpr, pattern, returnExpr),
          pexp_attributes: [({txt: "bs"}, _)] as attrs,
        } =>
        let parameter = (attrs, lbl, defaultExpr, pattern);
        collect(attrsBefore, [parameter, ...acc], returnExpr);
      | {
          pexp_desc:
            [@implicit_arity]
            Pexp_fun(
              (Labelled(_) | Optional(_)) as lbl,
              defaultExpr,
              pattern,
              returnExpr,
            ),
          pexp_attributes: attrs,
        } =>
        let parameter = (attrs, lbl, defaultExpr, pattern);
        collect(attrsBefore, [parameter, ...acc], returnExpr);
      | expr => (attrsBefore, List.rev(acc), expr)
      };

    switch (expr) {
    | {
        pexp_desc:
          [@implicit_arity]
          Pexp_fun(Nolabel, _defaultExpr, _pattern, _returnExpr),
        pexp_attributes: attrs,
      } as expr =>
      collect(attrs, [], {...expr, pexp_attributes: []})
    | expr => collect([], [], expr)
    };
  };

  let rec isBlockExpr = expr =>
    Parsetree.(
      switch (expr.pexp_desc) {
      | Pexp_letmodule(_)
      | Pexp_letexception(_)
      | Pexp_let(_)
      | Pexp_open(_)
      | Pexp_sequence(_) => true
      | [@implicit_arity] Pexp_apply(callExpr, _) when isBlockExpr(callExpr) =>
        true
      | [@implicit_arity] Pexp_constraint(expr, _) when isBlockExpr(expr) =>
        true
      | [@implicit_arity] Pexp_field(expr, _) when isBlockExpr(expr) => true
      | [@implicit_arity] Pexp_setfield(expr, _, _) when isBlockExpr(expr) =>
        true
      | _ => false
      }
    );

  let rec walkStructure = (s, t, comments) =>
    switch (s) {
    | _ when comments == [] => ()
    | [] => attach(t.inside, Location.none, comments)
    | s =>
      walkList(
        ~getLoc=n => n.Parsetree.pstr_loc,
        ~walkNode=walkStructureItem,
        s,
        t,
        comments,
      )
    }

  and walkStructureItem = (si, t, comments) =>
    switch (si.Parsetree.pstr_desc) {
    | _ when comments == [] => ()
    | Pstr_primitive(valueDescription) =>
      walkValueDescription(valueDescription, t, comments)
    | Pstr_open(openDescription) =>
      walkOpenDescription(openDescription, t, comments)
    | [@implicit_arity] Pstr_value(_, valueBindings) =>
      walkValueBindings(valueBindings, t, comments)
    | [@implicit_arity] Pstr_type(_, typeDeclarations) =>
      walkTypeDeclarations(typeDeclarations, t, comments)
    | [@implicit_arity] Pstr_eval(expr, _) => walkExpr(expr, t, comments)
    | Pstr_module(moduleBinding) =>
      walkModuleBinding(moduleBinding, t, comments)
    | Pstr_recmodule(moduleBindings) =>
      walkList(
        ~getLoc=mb => mb.Parsetree.pmb_loc,
        ~walkNode=walkModuleBinding,
        moduleBindings,
        t,
        comments,
      )
    | Pstr_modtype(modTypDecl) =>
      walkModuleTypeDeclaration(modTypDecl, t, comments)
    | Pstr_attribute(attribute) => walkAttribute(attribute, t, comments)
    | [@implicit_arity] Pstr_extension(extension, _) =>
      walkExtension(extension, t, comments)
    | Pstr_include(includeDeclaration) =>
      walkIncludeDeclaration(includeDeclaration, t, comments)
    | Pstr_exception(extensionConstructor) =>
      walkExtConstr(extensionConstructor, t, comments)
    | Pstr_typext(typeExtension) =>
      walkTypeExtension(typeExtension, t, comments)
    | Pstr_class_type(_)
    | Pstr_class(_) => ()
    }

  and walkValueDescription = (vd, t, comments) => {
    let (leading, trailing) =
      partitionLeadingTrailing(comments, vd.pval_name.loc);
    attach(t.leading, vd.pval_name.loc, leading);
    let (afterName, rest) =
      partitionAdjacentTrailing(vd.pval_name.loc, trailing);
    attach(t.trailing, vd.pval_name.loc, afterName);
    let (before, inside, after) =
      partitionByLoc(rest, vd.pval_type.ptyp_loc);

    attach(t.leading, vd.pval_type.ptyp_loc, before);
    walkTypExpr(vd.pval_type, t, inside);
    attach(t.trailing, vd.pval_type.ptyp_loc, after);
  }

  and walkTypeExtension = (te, t, comments) => {
    let (leading, trailing) =
      partitionLeadingTrailing(comments, te.ptyext_path.loc);
    attach(t.leading, te.ptyext_path.loc, leading);
    let (afterPath, rest) =
      partitionAdjacentTrailing(te.ptyext_path.loc, trailing);
    attach(t.trailing, te.ptyext_path.loc, afterPath);

    /* type params */
    let rest =
      switch (te.ptyext_params) {
      | [] => rest
      | typeParams =>
        visitListButContinueWithRemainingComments(
          ~getLoc=((typexpr, _variance)) => typexpr.Parsetree.ptyp_loc,
          ~walkNode=walkTypeParam,
          ~newlineDelimited=false,
          typeParams,
          t,
          rest,
        )
      };

    walkList(
      ~getLoc=n => n.Parsetree.pext_loc,
      ~walkNode=walkExtConstr,
      te.ptyext_constructors,
      t,
      rest,
    );
  }

  and walkIncludeDeclaration = (inclDecl, t, comments) => {
    let (before, inside, after) =
      partitionByLoc(comments, inclDecl.pincl_mod.pmod_loc);
    attach(t.leading, inclDecl.pincl_mod.pmod_loc, before);
    walkModExpr(inclDecl.pincl_mod, t, inside);
    attach(t.trailing, inclDecl.pincl_mod.pmod_loc, after);
  }

  and walkModuleTypeDeclaration = (mtd, t, comments) => {
    let (leading, trailing) =
      partitionLeadingTrailing(comments, mtd.pmtd_name.loc);
    attach(t.leading, mtd.pmtd_name.loc, leading);
    switch (mtd.pmtd_type) {
    | None => attach(t.trailing, mtd.pmtd_name.loc, trailing)
    | Some(modType) =>
      let (afterName, rest) =
        partitionAdjacentTrailing(mtd.pmtd_name.loc, trailing);
      attach(t.trailing, mtd.pmtd_name.loc, afterName);
      let (before, inside, after) = partitionByLoc(rest, modType.pmty_loc);
      attach(t.leading, modType.pmty_loc, before);
      walkModType(modType, t, inside);
      attach(t.trailing, modType.pmty_loc, after);
    };
  }

  and walkModuleBinding = (mb, t, comments) => {
    let (leading, trailing) =
      partitionLeadingTrailing(comments, mb.pmb_name.loc);
    attach(t.leading, mb.pmb_name.loc, leading);
    let (afterName, rest) =
      partitionAdjacentTrailing(mb.pmb_name.loc, trailing);
    attach(t.trailing, mb.pmb_name.loc, afterName);
    let (leading, inside, trailing) =
      partitionByLoc(rest, mb.pmb_expr.pmod_loc);
    switch (mb.pmb_expr.pmod_desc) {
    | Pmod_constraint(_) =>
      walkModExpr(mb.pmb_expr, t, List.concat([leading, inside]))
    | _ =>
      attach(t.leading, mb.pmb_expr.pmod_loc, leading);
      walkModExpr(mb.pmb_expr, t, inside);
    };
    attach(t.trailing, mb.pmb_expr.pmod_loc, trailing);
  }

  and walkSignature = (signature, t, comments) =>
    switch (signature) {
    | _ when comments == [] => ()
    | [] => attach(t.inside, Location.none, comments)
    | _s =>
      walkList(
        ~getLoc=n => n.Parsetree.psig_loc,
        ~walkNode=walkSignatureItem,
        signature,
        t,
        comments,
      )
    }

  and walkSignatureItem = (si, t, comments) =>
    switch (si.psig_desc) {
    | _ when comments == [] => ()
    | Psig_value(valueDescription) =>
      walkValueDescription(valueDescription, t, comments)
    | [@implicit_arity] Psig_type(_, typeDeclarations) =>
      walkTypeDeclarations(typeDeclarations, t, comments)
    | Psig_typext(typeExtension) =>
      walkTypeExtension(typeExtension, t, comments)
    | Psig_exception(extensionConstructor) =>
      walkExtConstr(extensionConstructor, t, comments)
    | Psig_module(moduleDeclaration) =>
      walkModuleDeclaration(moduleDeclaration, t, comments)
    | Psig_recmodule(moduleDeclarations) =>
      walkList(
        ~getLoc=n => n.Parsetree.pmd_loc,
        ~walkNode=walkModuleDeclaration,
        moduleDeclarations,
        t,
        comments,
      )
    | Psig_modtype(moduleTypeDeclaration) =>
      walkModuleTypeDeclaration(moduleTypeDeclaration, t, comments)
    | Psig_open(openDescription) =>
      walkOpenDescription(openDescription, t, comments)
    | Psig_include(includeDescription) =>
      walkIncludeDescription(includeDescription, t, comments)
    | Psig_attribute(attribute) => walkAttribute(attribute, t, comments)
    | [@implicit_arity] Psig_extension(extension, _) =>
      walkExtension(extension, t, comments)
    | Psig_class(_)
    | Psig_class_type(_) => ()
    }

  and walkIncludeDescription = (id, t, comments) => {
    let (before, inside, after) =
      partitionByLoc(comments, id.pincl_mod.pmty_loc);
    attach(t.leading, id.pincl_mod.pmty_loc, before);
    walkModType(id.pincl_mod, t, inside);
    attach(t.trailing, id.pincl_mod.pmty_loc, after);
  }

  and walkModuleDeclaration = (md, t, comments) => {
    let (leading, trailing) =
      partitionLeadingTrailing(comments, md.pmd_name.loc);
    attach(t.leading, md.pmd_name.loc, leading);
    let (afterName, rest) =
      partitionAdjacentTrailing(md.pmd_name.loc, trailing);
    attach(t.trailing, md.pmd_name.loc, afterName);
    let (leading, inside, trailing) =
      partitionByLoc(rest, md.pmd_type.pmty_loc);
    attach(t.leading, md.pmd_type.pmty_loc, leading);
    walkModType(md.pmd_type, t, inside);
    attach(t.trailing, md.pmd_type.pmty_loc, trailing);
  }

  and walkList:
    'node.
    (
      ~prevLoc: Location.t=?,
      ~getLoc: 'node => Location.t,
      ~walkNode: ('node, t, list(Comment.t)) => unit,
      list('node),
      t,
      list(Comment.t)
    ) =>
    unit
   =
    (~prevLoc=?, ~getLoc, ~walkNode, l, t, comments) =>
      Location.(
        switch (l) {
        | _ when comments == [] => ()
        | [] =>
          switch (prevLoc) {
          | Some(loc) => attach(t.trailing, loc, comments)
          | None => ()
          }
        | [node, ...rest] =>
          let currLoc = getLoc(node);
          let (leading, inside, trailing) =
            partitionByLoc(comments, currLoc);
          switch (prevLoc) {
          | None =>
            /* first node, all leading comments attach here */
            attach(t.leading, currLoc, leading)
          | Some(prevLoc) =>
            /* Same line */
            if (prevLoc.loc_end.pos_lnum === currLoc.loc_start.pos_lnum) {
              let (afterPrev, beforeCurr) =
                partitionAdjacentTrailing(prevLoc, leading);
              let () = attach(t.trailing, prevLoc, afterPrev);
              attach(t.leading, currLoc, beforeCurr);
            } else {
              let (onSameLineAsPrev, afterPrev) =
                partitionByOnSameLine(prevLoc, leading);
              let () = attach(t.trailing, prevLoc, onSameLineAsPrev);
              let (leading, _inside, _trailing) =
                partitionByLoc(afterPrev, currLoc);
              attach(t.leading, currLoc, leading);
            }
          };
          walkNode(node, t, inside);
          walkList(~prevLoc=currLoc, ~getLoc, ~walkNode, rest, t, trailing);
        }
      )

  /* The parsetree doesn't always contain location info about the opening or
   * closing token of a "list-of-things". This routine visits the whole list,
   * but returns any remaining comments that likely fall after the whole list. */
  and visitListButContinueWithRemainingComments:
    'node.
    (
      ~prevLoc: Location.t=?,
      ~newlineDelimited: bool,
      ~getLoc: 'node => Location.t,
      ~walkNode: ('node, t, list(Comment.t)) => unit,
      list('node),
      t,
      list(Comment.t)
    ) =>
    list(Comment.t)
   =
    (~prevLoc=?, ~newlineDelimited, ~getLoc, ~walkNode, l, t, comments) =>
      Location.(
        switch (l) {
        | _ when comments == [] => []
        | [] =>
          switch (prevLoc) {
          | Some(loc) =>
            let (afterPrev, rest) =
              if (newlineDelimited) {
                partitionByOnSameLine(loc, comments);
              } else {
                partitionAdjacentTrailing(loc, comments);
              };

            attach(t.trailing, loc, afterPrev);
            rest;
          | None => comments
          }
        | [node, ...rest] =>
          let currLoc = getLoc(node);
          let (leading, inside, trailing) =
            partitionByLoc(comments, currLoc);
          let () =
            switch (prevLoc) {
            | None =>
              /* first node, all leading comments attach here */
              attach(t.leading, currLoc, leading);
              ();
            | Some(prevLoc) =>
              /* Same line */
              if (prevLoc.loc_end.pos_lnum === currLoc.loc_start.pos_lnum) {
                let (afterPrev, beforeCurr) =
                  partitionAdjacentTrailing(prevLoc, leading);
                let () = attach(t.trailing, prevLoc, afterPrev);
                let () = attach(t.leading, currLoc, beforeCurr);
                ();
              } else {
                let (onSameLineAsPrev, afterPrev) =
                  partitionByOnSameLine(prevLoc, leading);
                let () = attach(t.trailing, prevLoc, onSameLineAsPrev);
                let (leading, _inside, _trailing) =
                  partitionByLoc(afterPrev, currLoc);
                let () = attach(t.leading, currLoc, leading);
                ();
              }
            };

          walkNode(node, t, inside);
          visitListButContinueWithRemainingComments(
            ~prevLoc=currLoc,
            ~getLoc,
            ~walkNode,
            ~newlineDelimited,
            rest,
            t,
            trailing,
          );
        }
      )

  and walkValueBindings = (vbs, t, comments) =>
    walkList(
      ~getLoc=n => n.Parsetree.pvb_loc,
      ~walkNode=walkValueBinding,
      vbs,
      t,
      comments,
    )

  and walkOpenDescription = (openDescription, t, comments) => {
    let loc = openDescription.popen_lid.loc;
    let (leading, trailing) = partitionLeadingTrailing(comments, loc);
    attach(t.leading, loc, leading);
    attach(t.trailing, loc, trailing);
  }

  and walkTypeDeclarations = (typeDeclarations, t, comments) =>
    walkList(
      ~getLoc=n => n.Parsetree.ptype_loc,
      ~walkNode=walkTypeDeclaration,
      typeDeclarations,
      t,
      comments,
    )

  and walkTypeParam = ((typexpr, _variance), t, comments) =>
    walkTypExpr(typexpr, t, comments)

  and walkTypeDeclaration = (td, t, comments) => {
    let (beforeName, rest) =
      partitionLeadingTrailing(comments, td.ptype_name.loc);
    attach(t.leading, td.ptype_name.loc, beforeName);

    let (afterName, rest) =
      partitionAdjacentTrailing(td.ptype_name.loc, rest);
    attach(t.trailing, td.ptype_name.loc, afterName);

    /* type params */
    let rest =
      switch (td.ptype_params) {
      | [] => rest
      | typeParams =>
        visitListButContinueWithRemainingComments(
          ~getLoc=((typexpr, _variance)) => typexpr.Parsetree.ptyp_loc,
          ~walkNode=walkTypeParam,
          ~newlineDelimited=false,
          typeParams,
          t,
          rest,
        )
      };

    /* manifest:  = typexpr */
    let rest =
      switch (td.ptype_manifest) {
      | Some(typexpr) =>
        let (beforeTyp, insideTyp, afterTyp) =
          partitionByLoc(rest, typexpr.ptyp_loc);
        attach(t.leading, typexpr.ptyp_loc, beforeTyp);
        walkTypExpr(typexpr, t, insideTyp);
        let (afterTyp, rest) =
          partitionAdjacentTrailing(typexpr.Parsetree.ptyp_loc, afterTyp);
        attach(t.trailing, typexpr.ptyp_loc, afterTyp);
        rest;
      | None => rest
      };

    let rest =
      switch (td.ptype_kind) {
      | Ptype_abstract
      | Ptype_open => rest
      | Ptype_record(labelDeclarations) =>
        let () =
          walkList(
            ~getLoc=ld => ld.Parsetree.pld_loc,
            ~walkNode=walkLabelDeclaration,
            labelDeclarations,
            t,
            rest,
          );

        [];
      | Ptype_variant(constructorDeclarations) =>
        walkConstructorDeclarations(constructorDeclarations, t, rest)
      };

    attach(t.trailing, td.ptype_loc, rest);
  }

  and walkLabelDeclarations = (lds, t, comments) =>
    visitListButContinueWithRemainingComments(
      ~getLoc=ld => ld.Parsetree.pld_loc,
      ~walkNode=walkLabelDeclaration,
      ~newlineDelimited=false,
      lds,
      t,
      comments,
    )

  and walkLabelDeclaration = (ld, t, comments) => {
    let (beforeName, rest) =
      partitionLeadingTrailing(comments, ld.pld_name.loc);
    attach(t.leading, ld.pld_name.loc, beforeName);
    let (afterName, rest) = partitionAdjacentTrailing(ld.pld_name.loc, rest);
    attach(t.trailing, ld.pld_name.loc, afterName);
    let (beforeTyp, insideTyp, afterTyp) =
      partitionByLoc(rest, ld.pld_type.ptyp_loc);
    attach(t.leading, ld.pld_type.ptyp_loc, beforeTyp);
    walkTypExpr(ld.pld_type, t, insideTyp);
    attach(t.trailing, ld.pld_type.ptyp_loc, afterTyp);
  }

  and walkConstructorDeclarations = (cds, t, comments) =>
    visitListButContinueWithRemainingComments(
      ~getLoc=cd => cd.Parsetree.pcd_loc,
      ~walkNode=walkConstructorDeclaration,
      ~newlineDelimited=false,
      cds,
      t,
      comments,
    )

  and walkConstructorDeclaration = (cd, t, comments) => {
    let (beforeName, rest) =
      partitionLeadingTrailing(comments, cd.pcd_name.loc);
    attach(t.leading, cd.pcd_name.loc, beforeName);
    let (afterName, rest) = partitionAdjacentTrailing(cd.pcd_name.loc, rest);
    attach(t.trailing, cd.pcd_name.loc, afterName);
    let rest = walkConstructorArguments(cd.pcd_args, t, rest);

    let rest =
      switch (cd.pcd_res) {
      | Some(typexpr) =>
        let (beforeTyp, insideTyp, afterTyp) =
          partitionByLoc(rest, typexpr.ptyp_loc);
        attach(t.leading, typexpr.ptyp_loc, beforeTyp);
        walkTypExpr(typexpr, t, insideTyp);
        let (afterTyp, rest) =
          partitionAdjacentTrailing(typexpr.Parsetree.ptyp_loc, afterTyp);
        attach(t.trailing, typexpr.ptyp_loc, afterTyp);
        rest;
      | None => rest
      };

    attach(t.trailing, cd.pcd_loc, rest);
  }

  and walkConstructorArguments = (args, t, comments) =>
    switch (args) {
    | Pcstr_tuple(typexprs) =>
      visitListButContinueWithRemainingComments(
        ~getLoc=n => n.Parsetree.ptyp_loc,
        ~walkNode=walkTypExpr,
        ~newlineDelimited=false,
        typexprs,
        t,
        comments,
      )
    | Pcstr_record(labelDeclarations) =>
      walkLabelDeclarations(labelDeclarations, t, comments)
    }

  and walkValueBinding = (vb, t, comments) => {
    open Location;

    let vb =
      Parsetree.(
        switch (vb.pvb_pat, vb.pvb_expr) {
        | (
            {
              ppat_desc:
                [@implicit_arity]
                Ppat_constraint(
                  pat,
                  {ptyp_desc: [@implicit_arity] Ptyp_poly([], t)},
                ),
            },
            {pexp_desc: [@implicit_arity] Pexp_constraint(expr, _typ)},
          ) => {
            ...vb,
            pvb_pat:
              Ast_helper.Pat.constraint_(
                ~loc={...pat.ppat_loc, loc_end: t.Parsetree.ptyp_loc.loc_end},
                pat,
                t,
              ),
            pvb_expr: expr,
          }
        | (
            {
              ppat_desc:
                [@implicit_arity]
                Ppat_constraint(
                  pat,
                  {ptyp_desc: [@implicit_arity] Ptyp_poly([_, ..._], t)},
                ),
            },
            {pexp_desc: Pexp_fun(_)},
          ) => {
            ...vb,
            pvb_pat: {
              ...vb.pvb_pat,
              ppat_loc: {
                ...pat.ppat_loc,
                loc_end: t.ptyp_loc.loc_end,
              },
            },
          }
        | _ => vb
        }
      );

    let patternLoc = vb.Parsetree.pvb_pat.ppat_loc;
    let exprLoc = vb.Parsetree.pvb_expr.pexp_loc;

    let (leading, inside, trailing) = partitionByLoc(comments, patternLoc);

    /* everything before start of pattern can only be leading on the pattern:
     *   let |* before *| a = 1 */
    attach(t.leading, patternLoc, leading);
    walkPattern(vb.Parsetree.pvb_pat, t, inside);
    /* let pattern = expr     -> pattern and expr on the same line */
    /* if patternLoc.loc_end.pos_lnum == exprLoc.loc_start.pos_lnum then ( */
    let (afterPat, surroundingExpr) =
      partitionAdjacentTrailing(patternLoc, trailing);

    attach(t.trailing, patternLoc, afterPat);
    let (beforeExpr, insideExpr, afterExpr) =
      partitionByLoc(surroundingExpr, exprLoc);
    if (isBlockExpr(vb.pvb_expr)) {
      walkExpr(
        vb.pvb_expr,
        t,
        List.concat([beforeExpr, insideExpr, afterExpr]),
      );
    } else {
      attach(t.leading, exprLoc, beforeExpr);
      walkExpr(vb.Parsetree.pvb_expr, t, insideExpr);
      attach(t.trailing, exprLoc, afterExpr);
    };
  }

  and walkExpr = (expr, t, comments) =>
    Location.(
      switch (expr.Parsetree.pexp_desc) {
      | _ when comments == [] => ()
      | Pexp_constant(_) =>
        let (leading, trailing) =
          partitionLeadingTrailing(comments, expr.pexp_loc);
        attach(t.leading, expr.pexp_loc, leading);
        attach(t.trailing, expr.pexp_loc, trailing);
      | Pexp_ident(longident) =>
        let (leading, trailing) =
          partitionLeadingTrailing(comments, longident.loc);
        attach(t.leading, longident.loc, leading);
        attach(t.trailing, longident.loc, trailing);
      | [@implicit_arity] Pexp_let(_recFlag, valueBindings, expr2) =>
        let comments =
          visitListButContinueWithRemainingComments(
            ~getLoc=
              n =>
                if (n.Parsetree.pvb_pat.ppat_loc.loc_ghost) {
                  n.pvb_expr.pexp_loc;
                } else {
                  n.Parsetree.pvb_loc;
                },
            ~walkNode=walkValueBinding,
            ~newlineDelimited=true,
            valueBindings,
            t,
            comments,
          );

        if (isBlockExpr(expr2)) {
          walkExpr(expr2, t, comments);
        } else {
          let (leading, inside, trailing) =
            partitionByLoc(comments, expr2.pexp_loc);
          attach(t.leading, expr2.pexp_loc, leading);
          walkExpr(expr2, t, inside);
          attach(t.trailing, expr2.pexp_loc, trailing);
        };
      | [@implicit_arity] Pexp_sequence(expr1, expr2) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, expr1.pexp_loc);
        let comments =
          if (isBlockExpr(expr1)) {
            let (afterExpr, comments) =
              partitionByOnSameLine(expr1.pexp_loc, trailing);
            walkExpr(expr1, t, List.concat([leading, inside, afterExpr]));
            comments;
          } else {
            attach(t.leading, expr1.pexp_loc, leading);
            walkExpr(expr1, t, inside);
            let (afterExpr, comments) =
              partitionByOnSameLine(expr1.pexp_loc, trailing);
            attach(t.trailing, expr1.pexp_loc, afterExpr);
            comments;
          };
        if (isBlockExpr(expr2)) {
          walkExpr(expr2, t, comments);
        } else {
          let (leading, inside, trailing) =
            partitionByLoc(comments, expr2.pexp_loc);
          attach(t.leading, expr2.pexp_loc, leading);
          walkExpr(expr2, t, inside);
          attach(t.trailing, expr2.pexp_loc, trailing);
        };
      | [@implicit_arity] Pexp_open(_override, longident, expr2) =>
        let (leading, comments) =
          partitionLeadingTrailing(comments, expr.pexp_loc);
        attach(
          t.leading,
          {...expr.pexp_loc, loc_end: longident.loc.loc_end},
          leading,
        );
        let (leading, trailing) =
          partitionLeadingTrailing(comments, longident.loc);
        attach(t.leading, longident.loc, leading);
        let (afterLongident, rest) =
          partitionByOnSameLine(longident.loc, trailing);
        attach(t.trailing, longident.loc, afterLongident);
        if (isBlockExpr(expr2)) {
          walkExpr(expr2, t, rest);
        } else {
          let (leading, inside, trailing) =
            partitionByLoc(rest, expr2.pexp_loc);
          attach(t.leading, expr2.pexp_loc, leading);
          walkExpr(expr2, t, inside);
          attach(t.trailing, expr2.pexp_loc, trailing);
        };
      | [@implicit_arity]
        Pexp_extension(
          {txt: "bs.obj"},
          PStr([
            {
              pstr_desc:
                [@implicit_arity]
                Pstr_eval(
                  {pexp_desc: [@implicit_arity] Pexp_record(rows, _)},
                  [],
                ),
            },
          ]),
        ) =>
        walkList(
          ~getLoc=
            (
              (longident, expr): (
                Asttypes.loc(Longident.t),
                Parsetree.expression,
              ),
            ) =>
              {...longident.loc, loc_end: expr.pexp_loc.loc_end},
          ~walkNode=walkExprRecordRow,
          rows,
          t,
          comments,
        )
      | Pexp_extension(extension) => walkExtension(extension, t, comments)
      | [@implicit_arity] Pexp_letexception(extensionConstructor, expr2) =>
        let (leading, comments) =
          partitionLeadingTrailing(comments, expr.pexp_loc);
        attach(
          t.leading,
          {...expr.pexp_loc, loc_end: extensionConstructor.pext_loc.loc_end},
          leading,
        );
        let (leading, inside, trailing) =
          partitionByLoc(comments, extensionConstructor.pext_loc);
        attach(t.leading, extensionConstructor.pext_loc, leading);
        walkExtConstr(extensionConstructor, t, inside);
        let (afterExtConstr, rest) =
          partitionByOnSameLine(extensionConstructor.pext_loc, trailing);
        attach(t.trailing, extensionConstructor.pext_loc, afterExtConstr);
        if (isBlockExpr(expr2)) {
          walkExpr(expr2, t, rest);
        } else {
          let (leading, inside, trailing) =
            partitionByLoc(rest, expr2.pexp_loc);
          attach(t.leading, expr2.pexp_loc, leading);
          walkExpr(expr2, t, inside);
          attach(t.trailing, expr2.pexp_loc, trailing);
        };
      | [@implicit_arity] Pexp_letmodule(stringLoc, modExpr, expr2) =>
        let (leading, comments) =
          partitionLeadingTrailing(comments, expr.pexp_loc);
        attach(
          t.leading,
          {...expr.pexp_loc, loc_end: modExpr.pmod_loc.loc_end},
          leading,
        );
        let (leading, trailing) =
          partitionLeadingTrailing(comments, stringLoc.loc);
        attach(t.leading, stringLoc.loc, leading);
        let (afterString, rest) =
          partitionAdjacentTrailing(stringLoc.loc, trailing);
        attach(t.trailing, stringLoc.loc, afterString);
        let (beforeModExpr, insideModExpr, afterModExpr) =
          partitionByLoc(rest, modExpr.pmod_loc);
        attach(t.leading, modExpr.pmod_loc, beforeModExpr);
        walkModExpr(modExpr, t, insideModExpr);
        let (afterModExpr, rest) =
          partitionByOnSameLine(modExpr.pmod_loc, afterModExpr);
        attach(t.trailing, modExpr.pmod_loc, afterModExpr);
        if (isBlockExpr(expr2)) {
          walkExpr(expr2, t, rest);
        } else {
          let (leading, inside, trailing) =
            partitionByLoc(rest, expr2.pexp_loc);
          attach(t.leading, expr2.pexp_loc, leading);
          walkExpr(expr2, t, inside);
          attach(t.trailing, expr2.pexp_loc, trailing);
        };
      | Pexp_assert(expr)
      | Pexp_lazy(expr) =>
        if (isBlockExpr(expr)) {
          walkExpr(expr, t, comments);
        } else {
          let (leading, inside, trailing) =
            partitionByLoc(comments, expr.pexp_loc);
          attach(t.leading, expr.pexp_loc, leading);
          walkExpr(expr, t, inside);
          attach(t.trailing, expr.pexp_loc, trailing);
        }
      | [@implicit_arity] Pexp_coerce(expr, optTypexpr, typexpr) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, expr.pexp_loc);
        attach(t.leading, expr.pexp_loc, leading);
        walkExpr(expr, t, inside);
        let (afterExpr, rest) =
          partitionAdjacentTrailing(expr.pexp_loc, trailing);
        attach(t.trailing, expr.pexp_loc, afterExpr);
        let rest =
          switch (optTypexpr) {
          | Some(typexpr) =>
            let (leading, inside, trailing) =
              partitionByLoc(comments, typexpr.ptyp_loc);
            attach(t.leading, typexpr.ptyp_loc, leading);
            walkTypExpr(typexpr, t, inside);
            let (afterTyp, rest) =
              partitionAdjacentTrailing(typexpr.ptyp_loc, trailing);
            attach(t.trailing, typexpr.ptyp_loc, afterTyp);
            rest;
          | None => rest
          };

        let (leading, inside, trailing) =
          partitionByLoc(rest, typexpr.ptyp_loc);
        attach(t.leading, typexpr.ptyp_loc, leading);
        walkTypExpr(typexpr, t, inside);
        attach(t.trailing, typexpr.ptyp_loc, trailing);
      | [@implicit_arity] Pexp_constraint(expr, typexpr) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, expr.pexp_loc);
        attach(t.leading, expr.pexp_loc, leading);
        walkExpr(expr, t, inside);
        let (afterExpr, rest) =
          partitionAdjacentTrailing(expr.pexp_loc, trailing);
        attach(t.trailing, expr.pexp_loc, afterExpr);
        let (leading, inside, trailing) =
          partitionByLoc(rest, typexpr.ptyp_loc);
        attach(t.leading, typexpr.ptyp_loc, leading);
        walkTypExpr(typexpr, t, inside);
        attach(t.trailing, typexpr.ptyp_loc, trailing);
      | Pexp_tuple([])
      | Pexp_array([])
      | [@implicit_arity] Pexp_construct({txt: Longident.Lident("[]")}, _) =>
        attach(t.inside, expr.pexp_loc, comments)
      | [@implicit_arity] Pexp_construct({txt: Longident.Lident("::")}, _) =>
        walkList(
          ~getLoc=n => n.Parsetree.pexp_loc,
          ~walkNode=walkExpr,
          collectListExprs([], expr),
          t,
          comments,
        )
      | [@implicit_arity] Pexp_construct(longident, args) =>
        let (leading, trailing) =
          partitionLeadingTrailing(comments, longident.loc);
        attach(t.leading, longident.loc, leading);
        switch (args) {
        | Some(expr) =>
          let (afterLongident, rest) =
            partitionAdjacentTrailing(longident.loc, trailing);
          attach(t.trailing, longident.loc, afterLongident);
          walkExpr(expr, t, rest);
        | None => attach(t.trailing, longident.loc, trailing)
        };
      | [@implicit_arity] Pexp_variant(_label, None) => ()
      | [@implicit_arity] Pexp_variant(_label, Some(expr)) =>
        walkExpr(expr, t, comments)
      | Pexp_array(exprs)
      | Pexp_tuple(exprs) =>
        walkList(
          ~getLoc=n => n.Parsetree.pexp_loc,
          ~walkNode=walkExpr,
          exprs,
          t,
          comments,
        )
      | [@implicit_arity] Pexp_record(rows, spreadExpr) =>
        let comments =
          switch (spreadExpr) {
          | None => comments
          | Some(expr) =>
            let (leading, inside, trailing) =
              partitionByLoc(comments, expr.pexp_loc);
            attach(t.leading, expr.pexp_loc, leading);
            walkExpr(expr, t, inside);
            let (afterExpr, rest) =
              partitionAdjacentTrailing(expr.pexp_loc, trailing);
            attach(t.trailing, expr.pexp_loc, afterExpr);
            rest;
          };

        walkList(
          ~getLoc=
            (
              (longident, expr): (
                Asttypes.loc(Longident.t),
                Parsetree.expression,
              ),
            ) =>
              {...longident.loc, loc_end: expr.pexp_loc.loc_end},
          ~walkNode=walkExprRecordRow,
          rows,
          t,
          comments,
        );
      | [@implicit_arity] Pexp_field(expr, longident) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, expr.pexp_loc);
        let trailing =
          if (isBlockExpr(expr)) {
            let (afterExpr, rest) =
              partitionAdjacentTrailing(expr.pexp_loc, trailing);
            walkExpr(expr, t, List.concat([leading, inside, afterExpr]));
            rest;
          } else {
            attach(t.leading, expr.pexp_loc, leading);
            walkExpr(expr, t, inside);
            trailing;
          };
        let (afterExpr, rest) =
          partitionAdjacentTrailing(expr.pexp_loc, trailing);
        attach(t.trailing, expr.pexp_loc, afterExpr);
        let (leading, trailing) =
          partitionLeadingTrailing(rest, longident.loc);
        attach(t.leading, longident.loc, leading);
        attach(t.trailing, longident.loc, trailing);
      | [@implicit_arity] Pexp_setfield(expr1, longident, expr2) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, expr1.pexp_loc);
        let rest =
          if (isBlockExpr(expr1)) {
            let (afterExpr, rest) =
              partitionAdjacentTrailing(expr1.pexp_loc, trailing);
            walkExpr(expr1, t, List.concat([leading, inside, afterExpr]));
            rest;
          } else {
            let (afterExpr, rest) =
              partitionAdjacentTrailing(expr1.pexp_loc, trailing);
            attach(t.leading, expr1.pexp_loc, leading);
            walkExpr(expr1, t, inside);
            attach(t.trailing, expr1.pexp_loc, afterExpr);
            rest;
          };
        let (beforeLongident, afterLongident) =
          partitionLeadingTrailing(rest, longident.loc);
        attach(t.leading, longident.loc, beforeLongident);
        let (afterLongident, rest) =
          partitionAdjacentTrailing(longident.loc, afterLongident);
        attach(t.trailing, longident.loc, afterLongident);
        if (isBlockExpr(expr2)) {
          walkExpr(expr2, t, rest);
        } else {
          let (leading, inside, trailing) =
            partitionByLoc(rest, expr2.pexp_loc);
          attach(t.leading, expr2.pexp_loc, leading);
          walkExpr(expr2, t, inside);
          attach(t.trailing, expr2.pexp_loc, trailing);
        };
      | [@implicit_arity] Pexp_ifthenelse(ifExpr, thenExpr, elseExpr) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, ifExpr.pexp_loc);
        let comments =
          if (isBlockExpr(ifExpr)) {
            let (afterExpr, comments) =
              partitionAdjacentTrailing(ifExpr.pexp_loc, trailing);
            walkExpr(ifExpr, t, List.concat([leading, inside, afterExpr]));
            comments;
          } else {
            attach(t.leading, ifExpr.pexp_loc, leading);
            walkExpr(ifExpr, t, inside);
            let (afterExpr, comments) =
              partitionAdjacentTrailing(ifExpr.pexp_loc, trailing);
            attach(t.trailing, ifExpr.pexp_loc, afterExpr);
            comments;
          };
        let (leading, inside, trailing) =
          partitionByLoc(comments, thenExpr.pexp_loc);
        let comments =
          if (isBlockExpr(thenExpr)) {
            let (afterExpr, trailing) =
              partitionAdjacentTrailing(thenExpr.pexp_loc, trailing);
            walkExpr(thenExpr, t, List.concat([leading, inside, afterExpr]));
            trailing;
          } else {
            attach(t.leading, thenExpr.pexp_loc, leading);
            walkExpr(thenExpr, t, inside);
            let (afterExpr, comments) =
              partitionAdjacentTrailing(thenExpr.pexp_loc, trailing);
            attach(t.trailing, thenExpr.pexp_loc, afterExpr);
            comments;
          };
        switch (elseExpr) {
        | None => ()
        | Some(expr) =>
          if (isBlockExpr(expr)) {
            walkExpr(expr, t, comments);
          } else {
            let (leading, inside, trailing) =
              partitionByLoc(comments, expr.pexp_loc);
            attach(t.leading, expr.pexp_loc, leading);
            walkExpr(expr, t, inside);
            attach(t.trailing, expr.pexp_loc, trailing);
          }
        };
      | [@implicit_arity] Pexp_while(expr1, expr2) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, expr1.pexp_loc);
        let rest =
          if (isBlockExpr(expr1)) {
            let (afterExpr, rest) =
              partitionAdjacentTrailing(expr1.pexp_loc, trailing);
            walkExpr(expr1, t, List.concat([leading, inside, afterExpr]));
            rest;
          } else {
            attach(t.leading, expr1.pexp_loc, leading);
            walkExpr(expr1, t, inside);
            let (afterExpr, rest) =
              partitionAdjacentTrailing(expr1.pexp_loc, trailing);
            attach(t.trailing, expr1.pexp_loc, afterExpr);
            rest;
          };
        if (isBlockExpr(expr2)) {
          walkExpr(expr2, t, rest);
        } else {
          let (leading, inside, trailing) =
            partitionByLoc(rest, expr2.pexp_loc);
          attach(t.leading, expr2.pexp_loc, leading);
          walkExpr(expr2, t, inside);
          attach(t.trailing, expr2.pexp_loc, trailing);
        };
      | [@implicit_arity] Pexp_for(pat, expr1, expr2, _, expr3) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, pat.ppat_loc);
        attach(t.leading, pat.ppat_loc, leading);
        walkPattern(pat, t, inside);
        let (afterPat, rest) =
          partitionAdjacentTrailing(pat.ppat_loc, trailing);
        attach(t.trailing, pat.ppat_loc, afterPat);
        let (leading, inside, trailing) =
          partitionByLoc(rest, expr1.pexp_loc);
        attach(t.leading, expr1.pexp_loc, leading);
        walkExpr(expr1, t, inside);
        let (afterExpr, rest) =
          partitionAdjacentTrailing(expr1.pexp_loc, trailing);
        attach(t.trailing, expr1.pexp_loc, afterExpr);
        let (leading, inside, trailing) =
          partitionByLoc(rest, expr2.pexp_loc);
        attach(t.leading, expr2.pexp_loc, leading);
        walkExpr(expr2, t, inside);
        let (afterExpr, rest) =
          partitionAdjacentTrailing(expr2.pexp_loc, trailing);
        attach(t.trailing, expr2.pexp_loc, afterExpr);
        if (isBlockExpr(expr3)) {
          walkExpr(expr3, t, rest);
        } else {
          let (leading, inside, trailing) =
            partitionByLoc(rest, expr3.pexp_loc);
          attach(t.leading, expr3.pexp_loc, leading);
          walkExpr(expr3, t, inside);
          attach(t.trailing, expr3.pexp_loc, trailing);
        };
      | Pexp_pack(modExpr) =>
        let (before, inside, after) =
          partitionByLoc(comments, modExpr.pmod_loc);
        attach(t.leading, modExpr.pmod_loc, before);
        walkModExpr(modExpr, t, inside);
        attach(t.trailing, modExpr.pmod_loc, after);
      | [@implicit_arity] Pexp_match(expr, cases)
      | [@implicit_arity] Pexp_try(expr, cases) =>
        let (before, inside, after) =
          partitionByLoc(comments, expr.pexp_loc);
        let after =
          if (isBlockExpr(expr)) {
            let (afterExpr, rest) =
              partitionAdjacentTrailing(expr.pexp_loc, after);
            walkExpr(expr, t, List.concat([before, inside, afterExpr]));
            rest;
          } else {
            attach(t.leading, expr.pexp_loc, before);
            walkExpr(expr, t, inside);
            after;
          };
        let (afterExpr, rest) =
          partitionAdjacentTrailing(expr.pexp_loc, after);
        attach(t.trailing, expr.pexp_loc, afterExpr);
        walkList(
          ~getLoc=
            n =>
              {
                ...n.Parsetree.pc_lhs.ppat_loc,
                loc_end: n.pc_rhs.pexp_loc.loc_end,
              },
          ~walkNode=walkCase,
          cases,
          t,
          rest,
        );
      /* unary expression: todo use parsetreeviewer */
      | [@implicit_arity]
        Pexp_apply(
          {
            pexp_desc:
              Pexp_ident({
                txt:
                  Longident.Lident("~+" | "~+." | "~-" | "~-." | "not" | "!"),
              }),
          },
          [(Nolabel, argExpr)],
        ) =>
        let (before, inside, after) =
          partitionByLoc(comments, argExpr.pexp_loc);
        attach(t.leading, argExpr.pexp_loc, before);
        walkExpr(argExpr, t, inside);
        attach(t.trailing, argExpr.pexp_loc, after);
      /* binary expression */
      | [@implicit_arity]
        Pexp_apply(
          {
            pexp_desc:
              Pexp_ident({
                txt:
                  Longident.Lident(
                    ":=" | "||" | "&&" | "=" | "==" | "<" | ">" | "!=" | "!==" |
                    "<=" |
                    ">=" |
                    "|>" |
                    "+" |
                    "+." |
                    "-" |
                    "-." |
                    "++" |
                    "^" |
                    "*" |
                    "*." |
                    "/" |
                    "/." |
                    "**" |
                    "|." |
                    "<>",
                  ),
              }),
          },
          [(Nolabel, operand1), (Nolabel, operand2)],
        ) =>
        let (before, inside, after) =
          partitionByLoc(comments, operand1.pexp_loc);
        attach(t.leading, operand1.pexp_loc, before);
        walkExpr(operand1, t, inside);
        let (afterOperand1, rest) =
          partitionAdjacentTrailing(operand1.pexp_loc, after);
        attach(t.trailing, operand1.pexp_loc, afterOperand1);
        let (before, inside, after) =
          partitionByLoc(rest, operand2.pexp_loc);
        attach(t.leading, operand2.pexp_loc, before);
        walkExpr(operand2, t, inside); /* (List.concat [inside; after]); */
        attach(t.trailing, operand2.pexp_loc, after);
      | [@implicit_arity] Pexp_apply(callExpr, arguments) =>
        let (before, inside, after) =
          partitionByLoc(comments, callExpr.pexp_loc);
        let after =
          if (isBlockExpr(callExpr)) {
            let (afterExpr, rest) =
              partitionAdjacentTrailing(callExpr.pexp_loc, after);
            walkExpr(callExpr, t, List.concat([before, inside, afterExpr]));
            rest;
          } else {
            attach(t.leading, callExpr.pexp_loc, before);
            walkExpr(callExpr, t, inside);
            after;
          };
        let (afterExpr, rest) =
          partitionAdjacentTrailing(callExpr.pexp_loc, after);
        attach(t.trailing, callExpr.pexp_loc, afterExpr);
        walkList(
          ~getLoc=
            ((_argLabel, expr)) => {
              let loc =
                switch (expr.Parsetree.pexp_attributes) {
                | [({Location.txt: "ns.namedArgLoc", loc}, _), ..._attrs] => {
                    ...loc,
                    loc_end: expr.pexp_loc.loc_end,
                  }
                | _ => expr.pexp_loc
                };

              loc;
            },
          ~walkNode=walkExprArgument,
          arguments,
          t,
          rest,
        );
      | [@implicit_arity] Pexp_fun(_, _, _, _)
      | Pexp_newtype(_) =>
        let (_, parameters, returnExpr) = funExpr(expr);
        let comments =
          visitListButContinueWithRemainingComments(
            ~newlineDelimited=false,
            ~walkNode=walkExprPararameter,
            ~getLoc=
              ((_attrs, _argLbl, exprOpt, pattern)) => {
                open Parsetree;
                let startPos =
                  switch (pattern.ppat_attributes) {
                  | [({Location.txt: "ns.namedArgLoc", loc}, _), ..._attrs] =>
                    loc.loc_start
                  | _ => pattern.ppat_loc.loc_start
                  };

                switch (exprOpt) {
                | None => {...pattern.ppat_loc, loc_start: startPos}
                | Some(expr) => {
                    ...pattern.ppat_loc,
                    loc_start: startPos,
                    loc_end: expr.pexp_loc.loc_end,
                  }
                };
              },
            parameters,
            t,
            comments,
          );

        switch (returnExpr.pexp_desc) {
        | [@implicit_arity] Pexp_constraint(expr, typ)
            when
              expr.pexp_loc.loc_start.pos_cnum >= typ.ptyp_loc.loc_end.pos_cnum =>
          let (leading, inside, trailing) =
            partitionByLoc(comments, typ.ptyp_loc);
          attach(t.leading, typ.ptyp_loc, leading);
          walkTypExpr(typ, t, inside);
          let (afterTyp, comments) =
            partitionAdjacentTrailing(typ.ptyp_loc, trailing);
          attach(t.trailing, typ.ptyp_loc, afterTyp);
          if (isBlockExpr(expr)) {
            walkExpr(expr, t, comments);
          } else {
            let (leading, inside, trailing) =
              partitionByLoc(comments, expr.pexp_loc);
            attach(t.leading, expr.pexp_loc, leading);
            walkExpr(expr, t, inside);
            attach(t.trailing, expr.pexp_loc, trailing);
          };
        | _ =>
          if (isBlockExpr(returnExpr)) {
            walkExpr(returnExpr, t, comments);
          } else {
            let (leading, inside, trailing) =
              partitionByLoc(comments, returnExpr.pexp_loc);
            attach(t.leading, returnExpr.pexp_loc, leading);
            walkExpr(returnExpr, t, inside);
            attach(t.trailing, returnExpr.pexp_loc, trailing);
          }
        };
      | _ => ()
      }
    )

  and walkExprPararameter =
      ((_attrs, _argLbl, exprOpt, pattern), t, comments) => {
    let (leading, inside, trailing) =
      partitionByLoc(comments, pattern.ppat_loc);
    attach(t.leading, pattern.ppat_loc, leading);
    walkPattern(pattern, t, inside);
    switch (exprOpt) {
    | Some(expr) =>
      let (_afterPat, rest) =
        partitionAdjacentTrailing(pattern.ppat_loc, trailing);
      attach(t.trailing, pattern.ppat_loc, trailing);
      if (isBlockExpr(expr)) {
        walkExpr(expr, t, rest);
      } else {
        let (leading, inside, trailing) =
          partitionByLoc(rest, expr.pexp_loc);
        attach(t.leading, expr.pexp_loc, leading);
        walkExpr(expr, t, inside);
        attach(t.trailing, expr.pexp_loc, trailing);
      };
    | None => attach(t.trailing, pattern.ppat_loc, trailing)
    };
  }

  and walkExprArgument = ((_argLabel, expr), t, comments) =>
    switch (expr.Parsetree.pexp_attributes) {
    | [({Location.txt: "ns.namedArgLoc", loc}, _), ..._attrs] =>
      let (leading, trailing) = partitionLeadingTrailing(comments, loc);
      attach(t.leading, loc, leading);
      let (afterLabel, rest) = partitionAdjacentTrailing(loc, trailing);
      attach(t.trailing, loc, afterLabel);
      let (before, inside, after) = partitionByLoc(rest, expr.pexp_loc);
      attach(t.leading, expr.pexp_loc, before);
      walkExpr(expr, t, inside);
      attach(t.trailing, expr.pexp_loc, after);
    | _ =>
      let (before, inside, after) = partitionByLoc(comments, expr.pexp_loc);
      attach(t.leading, expr.pexp_loc, before);
      walkExpr(expr, t, inside);
      attach(t.trailing, expr.pexp_loc, after);
    }

  and walkCase = (case, t, comments) => {
    let (before, inside, after) =
      partitionByLoc(comments, case.pc_lhs.ppat_loc);
    /* cases don't have a location on their own, leading comments should go
     * after the bar on the pattern */
    walkPattern(case.pc_lhs, t, List.concat([before, inside]));
    let (afterPat, rest) =
      partitionAdjacentTrailing(case.pc_lhs.ppat_loc, after);
    attach(t.trailing, case.pc_lhs.ppat_loc, afterPat);
    let comments =
      switch (case.pc_guard) {
      | Some(expr) =>
        let (before, inside, after) = partitionByLoc(rest, expr.pexp_loc);
        let (afterExpr, rest) =
          partitionAdjacentTrailing(expr.pexp_loc, after);
        if (isBlockExpr(expr)) {
          walkExpr(expr, t, List.concat([before, inside, afterExpr]));
        } else {
          attach(t.leading, expr.pexp_loc, before);
          walkExpr(expr, t, inside);
          attach(t.trailing, expr.pexp_loc, afterExpr);
        };
        rest;
      | None => rest
      };

    if (isBlockExpr(case.pc_rhs)) {
      walkExpr(case.pc_rhs, t, comments);
    } else {
      let (before, inside, after) =
        partitionByLoc(comments, case.pc_rhs.pexp_loc);
      attach(t.leading, case.pc_rhs.pexp_loc, before);
      walkExpr(case.pc_rhs, t, inside);
      attach(t.trailing, case.pc_rhs.pexp_loc, after);
    };
  }

  and walkExprRecordRow = ((longident, expr), t, comments) => {
    let (beforeLongident, afterLongident) =
      partitionLeadingTrailing(comments, longident.loc);

    attach(t.leading, longident.loc, beforeLongident);
    let (afterLongident, rest) =
      partitionAdjacentTrailing(longident.loc, afterLongident);
    attach(t.trailing, longident.loc, afterLongident);
    let (leading, inside, trailing) = partitionByLoc(rest, expr.pexp_loc);
    attach(t.leading, expr.pexp_loc, leading);
    walkExpr(expr, t, inside);
    attach(t.trailing, expr.pexp_loc, trailing);
  }

  and walkExtConstr = (extConstr, t, comments) => {
    let (leading, trailing) =
      partitionLeadingTrailing(comments, extConstr.pext_name.loc);
    attach(t.leading, extConstr.pext_name.loc, leading);
    let (afterName, rest) =
      partitionAdjacentTrailing(extConstr.pext_name.loc, trailing);
    attach(t.trailing, extConstr.pext_name.loc, afterName);
    walkExtensionConstructorKind(extConstr.pext_kind, t, rest);
  }

  and walkExtensionConstructorKind = (kind, t, comments) =>
    switch (kind) {
    | Pext_rebind(longident) =>
      let (leading, trailing) =
        partitionLeadingTrailing(comments, longident.loc);
      attach(t.leading, longident.loc, leading);
      attach(t.trailing, longident.loc, trailing);
    | [@implicit_arity] Pext_decl(constructorArguments, maybeTypExpr) =>
      let rest = walkConstructorArguments(constructorArguments, t, comments);
      switch (maybeTypExpr) {
      | None => ()
      | Some(typexpr) =>
        let (before, inside, after) = partitionByLoc(rest, typexpr.ptyp_loc);
        attach(t.leading, typexpr.ptyp_loc, before);
        walkTypExpr(typexpr, t, inside);
        attach(t.trailing, typexpr.ptyp_loc, after);
      };
    }

  and walkModExpr = (modExpr, t, comments) =>
    switch (modExpr.pmod_desc) {
    | Pmod_ident(longident) =>
      let (before, after) =
        partitionLeadingTrailing(comments, longident.loc);
      attach(t.leading, longident.loc, before);
      attach(t.trailing, longident.loc, after);
    | Pmod_structure(structure) => walkStructure(structure, t, comments)
    | Pmod_extension(extension) => walkExtension(extension, t, comments)
    | Pmod_unpack(expr) =>
      let (before, inside, after) = partitionByLoc(comments, expr.pexp_loc);
      attach(t.leading, expr.pexp_loc, before);
      walkExpr(expr, t, inside);
      attach(t.trailing, expr.pexp_loc, after);
    | [@implicit_arity] Pmod_constraint(modexpr, modtype) =>
      if (modtype.pmty_loc.loc_start >= modexpr.pmod_loc.loc_end) {
        let (before, inside, after) =
          partitionByLoc(comments, modexpr.pmod_loc);
        attach(t.leading, modexpr.pmod_loc, before);
        walkModExpr(modexpr, t, inside);
        let (after, rest) =
          partitionAdjacentTrailing(modexpr.pmod_loc, after);
        attach(t.trailing, modexpr.pmod_loc, after);
        let (before, inside, after) = partitionByLoc(rest, modtype.pmty_loc);
        attach(t.leading, modtype.pmty_loc, before);
        walkModType(modtype, t, inside);
        attach(t.trailing, modtype.pmty_loc, after);
      } else {
        let (before, inside, after) =
          partitionByLoc(comments, modtype.pmty_loc);
        attach(t.leading, modtype.pmty_loc, before);
        walkModType(modtype, t, inside);
        let (after, rest) =
          partitionAdjacentTrailing(modtype.pmty_loc, after);
        attach(t.trailing, modtype.pmty_loc, after);
        let (before, inside, after) = partitionByLoc(rest, modexpr.pmod_loc);
        attach(t.leading, modexpr.pmod_loc, before);
        walkModExpr(modexpr, t, inside);
        attach(t.trailing, modexpr.pmod_loc, after);
      }
    | [@implicit_arity] Pmod_apply(_callModExpr, _argModExpr) =>
      let modExprs = modExprApply(modExpr);
      walkList(
        ~getLoc=n => n.Parsetree.pmod_loc,
        ~walkNode=walkModExpr,
        modExprs,
        t,
        comments,
      );
    | Pmod_functor(_) =>
      let (parameters, returnModExpr) = modExprFunctor(modExpr);
      let comments =
        visitListButContinueWithRemainingComments(
          ~getLoc=
            ((_, lbl, modTypeOption)) =>
              switch (modTypeOption) {
              | None => lbl.Asttypes.loc
              | Some(modType) => {
                  ...lbl.loc,
                  loc_end: modType.Parsetree.pmty_loc.loc_end,
                }
              },
          ~walkNode=walkModExprParameter,
          ~newlineDelimited=false,
          parameters,
          t,
          comments,
        );

      switch (returnModExpr.pmod_desc) {
      | [@implicit_arity] Pmod_constraint(modExpr, modType)
          when
            modType.pmty_loc.loc_end.pos_cnum
            <= modExpr.pmod_loc.loc_start.pos_cnum =>
        let (before, inside, after) =
          partitionByLoc(comments, modType.pmty_loc);
        attach(t.leading, modType.pmty_loc, before);
        walkModType(modType, t, inside);
        let (after, rest) =
          partitionAdjacentTrailing(modType.pmty_loc, after);
        attach(t.trailing, modType.pmty_loc, after);
        let (before, inside, after) = partitionByLoc(rest, modExpr.pmod_loc);
        attach(t.leading, modExpr.pmod_loc, before);
        walkModExpr(modExpr, t, inside);
        attach(t.trailing, modExpr.pmod_loc, after);
      | _ =>
        let (before, inside, after) =
          partitionByLoc(comments, returnModExpr.pmod_loc);
        attach(t.leading, returnModExpr.pmod_loc, before);
        walkModExpr(returnModExpr, t, inside);
        attach(t.trailing, returnModExpr.pmod_loc, after);
      };
    }

  and walkModExprParameter = (parameter, t, comments) => {
    let (_attrs, lbl, modTypeOption) = parameter;
    let (leading, trailing) = partitionLeadingTrailing(comments, lbl.loc);
    attach(t.leading, lbl.loc, leading);
    switch (modTypeOption) {
    | None => attach(t.trailing, lbl.loc, trailing)
    | Some(modType) =>
      let (afterLbl, rest) = partitionAdjacentTrailing(lbl.loc, trailing);
      attach(t.trailing, lbl.loc, afterLbl);
      let (before, inside, after) = partitionByLoc(rest, modType.pmty_loc);
      attach(t.leading, modType.pmty_loc, before);
      walkModType(modType, t, inside);
      attach(t.trailing, modType.pmty_loc, after);
    };
  }

  and walkModType = (modType, t, comments) =>
    switch (modType.pmty_desc) {
    | Pmty_ident(longident)
    | Pmty_alias(longident) =>
      let (leading, trailing) =
        partitionLeadingTrailing(comments, longident.loc);
      attach(t.leading, longident.loc, leading);
      attach(t.trailing, longident.loc, trailing);
    | Pmty_signature(signature) => walkSignature(signature, t, comments)
    | Pmty_extension(extension) => walkExtension(extension, t, comments)
    | Pmty_typeof(modExpr) =>
      let (before, inside, after) =
        partitionByLoc(comments, modExpr.pmod_loc);
      attach(t.leading, modExpr.pmod_loc, before);
      walkModExpr(modExpr, t, inside);
      attach(t.trailing, modExpr.pmod_loc, after);
    | [@implicit_arity] Pmty_with(modType, _withConstraints) =>
      let (before, inside, after) =
        partitionByLoc(comments, modType.pmty_loc);
      attach(t.leading, modType.pmty_loc, before);
      walkModType(modType, t, inside);
      attach(t.trailing, modType.pmty_loc, after);
    /* TODO: withConstraints*/
    | Pmty_functor(_) =>
      let (parameters, returnModType) = functorType(modType);
      let comments =
        visitListButContinueWithRemainingComments(
          ~getLoc=
            ((_, lbl, modTypeOption)) =>
              switch (modTypeOption) {
              | None => lbl.Asttypes.loc
              | Some(modType) =>
                if (lbl.txt == "_") {
                  modType.Parsetree.pmty_loc;
                } else {
                  {...lbl.loc, loc_end: modType.Parsetree.pmty_loc.loc_end};
                }
              },
          ~walkNode=walkModTypeParameter,
          ~newlineDelimited=false,
          parameters,
          t,
          comments,
        );

      let (before, inside, after) =
        partitionByLoc(comments, returnModType.pmty_loc);
      attach(t.leading, returnModType.pmty_loc, before);
      walkModType(returnModType, t, inside);
      attach(t.trailing, returnModType.pmty_loc, after);
    }

  and walkModTypeParameter = ((_, lbl, modTypeOption), t, comments) => {
    let (leading, trailing) = partitionLeadingTrailing(comments, lbl.loc);
    attach(t.leading, lbl.loc, leading);
    switch (modTypeOption) {
    | None => attach(t.trailing, lbl.loc, trailing)
    | Some(modType) =>
      let (afterLbl, rest) = partitionAdjacentTrailing(lbl.loc, trailing);
      attach(t.trailing, lbl.loc, afterLbl);
      let (before, inside, after) = partitionByLoc(rest, modType.pmty_loc);
      attach(t.leading, modType.pmty_loc, before);
      walkModType(modType, t, inside);
      attach(t.trailing, modType.pmty_loc, after);
    };
  }

  and walkPattern = (pat, t, comments) =>
    Location.(
      switch (pat.Parsetree.ppat_desc) {
      | _ when comments == [] => ()
      | [@implicit_arity] Ppat_alias(pat, alias) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, pat.ppat_loc);
        attach(t.leading, pat.ppat_loc, leading);
        walkPattern(pat, t, inside);
        let (afterPat, rest) =
          partitionAdjacentTrailing(pat.ppat_loc, trailing);
        attach(t.leading, pat.ppat_loc, leading);
        attach(t.trailing, pat.ppat_loc, afterPat);
        let (beforeAlias, afterAlias) =
          partitionLeadingTrailing(rest, alias.loc);
        attach(t.leading, alias.loc, beforeAlias);
        attach(t.trailing, alias.loc, afterAlias);
      | Ppat_tuple([])
      | Ppat_array([])
      | [@implicit_arity] Ppat_construct({txt: Longident.Lident("()")}, _)
      | [@implicit_arity] Ppat_construct({txt: Longident.Lident("[]")}, _) =>
        attach(t.inside, pat.ppat_loc, comments)
      | Ppat_array(patterns) =>
        walkList(
          ~getLoc=n => n.Parsetree.ppat_loc,
          ~walkNode=walkPattern,
          patterns,
          t,
          comments,
        )
      | Ppat_tuple(patterns) =>
        walkList(
          ~getLoc=n => n.Parsetree.ppat_loc,
          ~walkNode=walkPattern,
          patterns,
          t,
          comments,
        )
      | [@implicit_arity] Ppat_construct({txt: Longident.Lident("::")}, _) =>
        walkList(
          ~getLoc=n => n.Parsetree.ppat_loc,
          ~walkNode=walkPattern,
          collectListPatterns([], pat),
          t,
          comments,
        )
      | [@implicit_arity] Ppat_construct(constr, None) =>
        let (beforeConstr, afterConstr) =
          partitionLeadingTrailing(comments, constr.loc);

        attach(t.leading, constr.loc, beforeConstr);
        attach(t.trailing, constr.loc, afterConstr);
      | [@implicit_arity] Ppat_construct(constr, Some(pat)) =>
        let (leading, trailing) =
          partitionLeadingTrailing(comments, constr.loc);
        attach(t.leading, constr.loc, leading);
        let (leading, inside, trailing) =
          partitionByLoc(trailing, pat.ppat_loc);
        attach(t.leading, pat.ppat_loc, leading);
        walkPattern(pat, t, inside);
        attach(t.trailing, pat.ppat_loc, trailing);
      | [@implicit_arity] Ppat_variant(_label, None) => ()
      | [@implicit_arity] Ppat_variant(_label, Some(pat)) =>
        walkPattern(pat, t, comments)
      | Ppat_type(_) => ()
      | [@implicit_arity] Ppat_record(recordRows, _) =>
        walkList(
          ~getLoc=
            (
              (longidentLoc, pattern): (
                Asttypes.loc(Longident.t),
                Parsetree.pattern,
              ),
            ) =>
              {
                ...longidentLoc.loc,
                loc_end: pattern.Parsetree.ppat_loc.loc_end,
              },
          ~walkNode=walkPatternRecordRow,
          recordRows,
          t,
          comments,
        )
      | [@implicit_arity] Ppat_or(pattern1, pattern2) =>
        let (beforePattern1, insidePattern1, afterPattern1) =
          partitionByLoc(comments, pattern1.ppat_loc);

        attach(t.leading, pattern1.ppat_loc, beforePattern1);
        walkPattern(pattern1, t, insidePattern1);
        let (afterPattern1, rest) =
          partitionAdjacentTrailing(pattern1.ppat_loc, afterPattern1);

        attach(t.trailing, pattern1.ppat_loc, afterPattern1);
        let (beforePattern2, insidePattern2, afterPattern2) =
          partitionByLoc(rest, pattern2.ppat_loc);

        attach(t.leading, pattern2.ppat_loc, beforePattern2);
        walkPattern(pattern2, t, insidePattern2);
        attach(t.trailing, pattern2.ppat_loc, afterPattern2);
      | [@implicit_arity] Ppat_constraint(pattern, typ) =>
        let (beforePattern, insidePattern, afterPattern) =
          partitionByLoc(comments, pattern.ppat_loc);

        attach(t.leading, pattern.ppat_loc, beforePattern);
        walkPattern(pattern, t, insidePattern);
        let (afterPattern, rest) =
          partitionAdjacentTrailing(pattern.ppat_loc, afterPattern);

        attach(t.trailing, pattern.ppat_loc, afterPattern);
        let (beforeTyp, insideTyp, afterTyp) =
          partitionByLoc(rest, typ.ptyp_loc);

        attach(t.leading, typ.ptyp_loc, beforeTyp);
        walkTypExpr(typ, t, insideTyp);
        attach(t.trailing, typ.ptyp_loc, afterTyp);
      | Ppat_lazy(pattern)
      | Ppat_exception(pattern) =>
        let (leading, inside, trailing) =
          partitionByLoc(comments, pattern.ppat_loc);
        attach(t.leading, pattern.ppat_loc, leading);
        walkPattern(pattern, t, inside);
        attach(t.trailing, pattern.ppat_loc, trailing);
      | Ppat_unpack(stringLoc) =>
        let (leading, trailing) =
          partitionLeadingTrailing(comments, stringLoc.loc);
        attach(t.leading, stringLoc.loc, leading);
        attach(t.trailing, stringLoc.loc, trailing);
      | Ppat_extension(extension) => walkExtension(extension, t, comments)
      | _ => ()
      }
    )

  /* name: firstName */
  and walkPatternRecordRow = (row, t, comments) =>
    switch (row) {
    /* punned {x}*/
    | (
        {Location.txt: Longident.Lident(ident), loc: longidentLoc},
        {Parsetree.ppat_desc: Ppat_var({txt, _})},
      )
        when ident == txt =>
      let (beforeLbl, afterLbl) =
        partitionLeadingTrailing(comments, longidentLoc);

      attach(t.leading, longidentLoc, beforeLbl);
      attach(t.trailing, longidentLoc, afterLbl);
    | (longident, pattern) =>
      let (beforeLbl, afterLbl) =
        partitionLeadingTrailing(comments, longident.loc);

      attach(t.leading, longident.loc, beforeLbl);
      let (afterLbl, rest) =
        partitionAdjacentTrailing(longident.loc, afterLbl);
      attach(t.trailing, longident.loc, afterLbl);
      let (leading, inside, trailing) =
        partitionByLoc(rest, pattern.ppat_loc);
      attach(t.leading, pattern.ppat_loc, leading);
      walkPattern(pattern, t, inside);
      attach(t.trailing, pattern.ppat_loc, trailing);
    }

  and walkTypExpr = (typ, t, comments) =>
    switch (typ.Parsetree.ptyp_desc) {
    | _ when comments == [] => ()
    | Ptyp_tuple(typexprs) =>
      walkList(
        ~getLoc=n => n.Parsetree.ptyp_loc,
        ~walkNode=walkTypExpr,
        typexprs,
        t,
        comments,
      )
    | Ptyp_extension(extension) => walkExtension(extension, t, comments)
    | Ptyp_package(packageType) => walkPackageType(packageType, t, comments)
    | [@implicit_arity] Ptyp_alias(typexpr, _alias) =>
      let (beforeTyp, insideTyp, afterTyp) =
        partitionByLoc(comments, typexpr.ptyp_loc);
      attach(t.leading, typexpr.ptyp_loc, beforeTyp);
      walkTypExpr(typexpr, t, insideTyp);
      attach(t.trailing, typexpr.ptyp_loc, afterTyp);
    | [@implicit_arity] Ptyp_poly(strings, typexpr) =>
      let comments =
        visitListButContinueWithRemainingComments(
          ~getLoc=n => n.Asttypes.loc,
          ~walkNode=
            (longident, t, comments) => {
              let (beforeLongident, afterLongident) =
                partitionLeadingTrailing(comments, longident.loc);
              attach(t.leading, longident.loc, beforeLongident);
              attach(t.trailing, longident.loc, afterLongident);
            },
          ~newlineDelimited=false,
          strings,
          t,
          comments,
        );

      let (beforeTyp, insideTyp, afterTyp) =
        partitionByLoc(comments, typexpr.ptyp_loc);
      attach(t.leading, typexpr.ptyp_loc, beforeTyp);
      walkTypExpr(typexpr, t, insideTyp);
      attach(t.trailing, typexpr.ptyp_loc, afterTyp);
    | [@implicit_arity] Ptyp_constr(longident, typexprs) =>
      let (beforeLongident, _afterLongident) =
        partitionLeadingTrailing(comments, longident.loc);
      let (afterLongident, rest) =
        partitionAdjacentTrailing(longident.loc, comments);
      attach(t.leading, longident.loc, beforeLongident);
      attach(t.trailing, longident.loc, afterLongident);
      walkList(
        ~getLoc=n => n.Parsetree.ptyp_loc,
        ~walkNode=walkTypExpr,
        typexprs,
        t,
        rest,
      );
    | Ptyp_arrow(_) =>
      let (_, parameters, typexpr) = arrowType(typ);
      let comments = walkTypeParameters(parameters, t, comments);
      let (beforeTyp, insideTyp, afterTyp) =
        partitionByLoc(comments, typexpr.ptyp_loc);
      attach(t.leading, typexpr.ptyp_loc, beforeTyp);
      walkTypExpr(typexpr, t, insideTyp);
      attach(t.trailing, typexpr.ptyp_loc, afterTyp);
    | [@implicit_arity] Ptyp_object(fields, _) =>
      walkTypObjectFields(fields, t, comments)
    | _ => ()
    }

  and walkTypObjectFields = (fields, t, comments) =>
    walkList(
      ~getLoc=
        field =>
          switch (field) {
          | [@implicit_arity] Parsetree.Otag(lbl, _, typ) => {
              ...lbl.loc,
              loc_end: typ.ptyp_loc.loc_end,
            }
          | _ => Location.none
          },
      ~walkNode=walkTypObjectField,
      fields,
      t,
      comments,
    )

  and walkTypObjectField = (field, t, comments) =>
    switch (field) {
    | [@implicit_arity] Otag(lbl, _, typexpr) =>
      let (beforeLbl, afterLbl) =
        partitionLeadingTrailing(comments, lbl.loc);
      attach(t.leading, lbl.loc, beforeLbl);
      let (afterLbl, rest) = partitionAdjacentTrailing(lbl.loc, afterLbl);
      attach(t.trailing, lbl.loc, afterLbl);
      let (beforeTyp, insideTyp, afterTyp) =
        partitionByLoc(rest, typexpr.ptyp_loc);
      attach(t.leading, typexpr.ptyp_loc, beforeTyp);
      walkTypExpr(typexpr, t, insideTyp);
      attach(t.trailing, typexpr.ptyp_loc, afterTyp);
    | _ => ()
    }

  and walkTypeParameters = (typeParameters, t, comments) =>
    visitListButContinueWithRemainingComments(
      ~getLoc=((_, _, typexpr)) => typexpr.Parsetree.ptyp_loc,
      ~walkNode=walkTypeParameter,
      ~newlineDelimited=false,
      typeParameters,
      t,
      comments,
    )

  and walkTypeParameter = ((_attrs, _lbl, typexpr), t, comments) => {
    let (beforeTyp, insideTyp, afterTyp) =
      partitionByLoc(comments, typexpr.ptyp_loc);
    attach(t.leading, typexpr.ptyp_loc, beforeTyp);
    walkTypExpr(typexpr, t, insideTyp);
    attach(t.trailing, typexpr.ptyp_loc, afterTyp);
  }

  and walkPackageType = (packageType, t, comments) => {
    let (longident, packageConstraints) = packageType;
    let (beforeLongident, afterLongident) =
      partitionLeadingTrailing(comments, longident.loc);
    attach(t.leading, longident.loc, beforeLongident);
    let (afterLongident, rest) =
      partitionAdjacentTrailing(longident.loc, afterLongident);
    attach(t.trailing, longident.loc, afterLongident);
    walkPackageConstraints(packageConstraints, t, rest);
  }

  and walkPackageConstraints = (packageConstraints, t, comments) =>
    walkList(
      ~getLoc=
        ((longident, typexpr)) =>
          {
            ...longident.Asttypes.loc,
            loc_end: typexpr.Parsetree.ptyp_loc.loc_end,
          },
      ~walkNode=walkPackageConstraint,
      packageConstraints,
      t,
      comments,
    )

  and walkPackageConstraint = (packageConstraint, t, comments) => {
    let (longident, typexpr) = packageConstraint;
    let (beforeLongident, afterLongident) =
      partitionLeadingTrailing(comments, longident.loc);
    attach(t.leading, longident.loc, beforeLongident);
    let (afterLongident, rest) =
      partitionAdjacentTrailing(longident.loc, afterLongident);
    attach(t.trailing, longident.loc, afterLongident);
    let (beforeTyp, insideTyp, afterTyp) =
      partitionByLoc(rest, typexpr.ptyp_loc);
    attach(t.leading, typexpr.ptyp_loc, beforeTyp);
    walkTypExpr(typexpr, t, insideTyp);
    attach(t.trailing, typexpr.ptyp_loc, afterTyp);
  }

  and walkExtension = (extension, t, comments) => {
    let (id, payload) = extension;
    let (beforeId, afterId) = partitionLeadingTrailing(comments, id.loc);
    attach(t.leading, id.loc, beforeId);
    let (afterId, rest) = partitionAdjacentTrailing(id.loc, afterId);
    attach(t.trailing, id.loc, afterId);
    walkPayload(payload, t, rest);
  }

  and walkAttribute = ((id, payload), t, comments) => {
    let (beforeId, afterId) = partitionLeadingTrailing(comments, id.loc);
    attach(t.leading, id.loc, beforeId);
    let (afterId, rest) = partitionAdjacentTrailing(id.loc, afterId);
    attach(t.trailing, id.loc, afterId);
    walkPayload(payload, t, rest);
  }

  and walkPayload = (payload, t, comments) =>
    switch (payload) {
    | PStr(s) => walkStructure(s, t, comments)
    | _ => ()
    };
};

module Printer = {
  let addParens = doc =>
    Doc.group(
      Doc.concat([
        Doc.lparen,
        Doc.indent(Doc.concat([Doc.softLine, doc])),
        Doc.softLine,
        Doc.rparen,
      ]),
    );

  let addBraces = doc =>
    Doc.group(Doc.concat([Doc.lbrace, doc, Doc.rbrace]));

  let getFirstLeadingComment = (tbl, loc) =>
    switch (Hashtbl.find(tbl.CommentTable.leading, loc)) {
    | [comment, ..._] => Some(comment)
    | [] => None
    | exception Not_found => None
    };

  let printMultilineCommentContent = 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 indentStars = (lines, acc) =>
      switch (lines) {
      | [] => Doc.nil
      | [lastLine] =>
        let line = String.trim(lastLine);
        let doc = Doc.text(" " ++ line);
        let trailingSpace =
          if (String.length(line) > 0) {
            Doc.space;
          } else {
            Doc.nil;
          };
        List.rev([trailingSpace, doc, ...acc]) |> Doc.concat;
      | [line, ...lines] =>
        let line = String.trim(line);
        let len = String.length(line);
        if (len > 0 && line.[0] === '*') {
          let doc = Doc.text(" " ++ String.trim(line));
          indentStars(lines, [Doc.hardLine, doc, ...acc]);
        } else {
          let trailingSpace = {
            let len = String.length(txt);
            if (len > 0 && String.unsafe_get(txt, len - 1) == ' ') {
              Doc.space;
            } else {
              Doc.nil;
            };
          };

          let content = Comment.trimSpaces(txt);
          Doc.concat([Doc.text(content), trailingSpace]);
        };
      };

    let lines = String.split_on_char('\n', txt);
    switch (lines) {
    | [] => Doc.text("/* */")
    | [line] =>
      Doc.concat([
        Doc.text("/* "),
        Doc.text(Comment.trimSpaces(line)),
        Doc.text(" */"),
      ])
    | [first, ...rest] =>
      let firstLine = Comment.trimSpaces(first);
      Doc.concat([
        Doc.text("/*"),
        if (String.length(firstLine) > 0 && !String.equal(firstLine, "*")) {
          Doc.space;
        } else {
          Doc.nil;
        },
        indentStars(rest, [Doc.hardLine, Doc.text(firstLine)]),
        Doc.text("*/"),
      ]);
    };
  };

  let printTrailingComment = (nodeLoc: Location.t, comment) => {
    let singleLine = Comment.isSingleLineComment(comment);
    let content = {
      let txt = Comment.txt(comment);
      if (singleLine) {
        Doc.text("// " ++ String.trim(txt));
      } else {
        printMultilineCommentContent(txt);
      };
    };

    let diff = {
      let cmtStart = Comment.loc(comment).loc_start;
      let prevTokEndPos = Comment.prevTokEndPos(comment);
      cmtStart.pos_lnum - prevTokEndPos.pos_lnum;
    };

    let isBelow =
      Comment.loc(comment).loc_start.pos_lnum > nodeLoc.loc_end.pos_lnum;
    if (diff > 0 || isBelow) {
      Doc.concat([
        Doc.breakParent,
        Doc.lineSuffix(
          Doc.concat([
            Doc.hardLine,
            if (diff > 1) {
              Doc.hardLine;
            } else {
              Doc.nil;
            },
            content,
          ]),
        ),
      ]);
    } else if (!singleLine) {
      Doc.concat([Doc.space, content]);
    } else {
      Doc.lineSuffix(Doc.concat([Doc.space, content]));
    };
  };

  let printLeadingComment = (~nextComment=?, comment) => {
    let singleLine = Comment.isSingleLineComment(comment);
    let content = {
      let txt = Comment.txt(comment);
      if (singleLine) {
        Doc.text("// " ++ String.trim(txt));
      } else {
        printMultilineCommentContent(txt);
      };
    };

    let separator =
      Doc.concat([
        if (singleLine) {
          Doc.concat([Doc.hardLine, Doc.breakParent]);
        } else {
          Doc.nil;
        },
        switch (nextComment) {
        | Some(next) =>
          let nextLoc = Comment.loc(next);
          let currLoc = Comment.loc(comment);
          let diff =
            nextLoc.Location.loc_start.pos_lnum
            - currLoc.Location.loc_end.pos_lnum;

          let nextSingleLine = Comment.isSingleLineComment(next);
          if (singleLine && nextSingleLine) {
            if (diff > 1) {
              Doc.hardLine;
            } else {
              Doc.nil;
            };
          } else if (singleLine && !nextSingleLine) {
            if (diff > 1) {
              Doc.hardLine;
            } else {
              Doc.nil;
            };
          } else if (diff > 1) {
            Doc.concat([Doc.hardLine, Doc.hardLine]);
          } else if (diff === 1) {
            Doc.hardLine;
          } else {
            Doc.space;
          };
        | None => Doc.nil
        },
      ]);

    Doc.concat([content, separator]);
  };

  let printCommentsInside = (cmtTbl, loc) => {
    let rec loop = (acc, comments) =>
      switch (comments) {
      | [] => Doc.nil
      | [comment] =>
        let cmtDoc = printLeadingComment(comment);
        let doc =
          Doc.group(Doc.concat([Doc.concat(List.rev([cmtDoc, ...acc]))]));

        doc;
      | [comment, ...[nextComment, ..._comments] as rest] =>
        let cmtDoc = printLeadingComment(~nextComment, comment);
        loop([cmtDoc, ...acc], rest);
      };

    switch (Hashtbl.find(cmtTbl.CommentTable.inside, loc)) {
    | exception Not_found => Doc.nil
    | comments =>
      Hashtbl.remove(cmtTbl.inside, loc);
      Doc.group(loop([], comments));
    };
  };

  let printLeadingComments = (node, tbl, loc) => {
    let rec loop = (acc, comments) =>
      switch (comments) {
      | [] => node
      | [comment] =>
        let cmtDoc = printLeadingComment(comment);
        let diff =
          loc.Location.loc_start.pos_lnum
          - Comment.loc(comment).Location.loc_end.pos_lnum;

        let separator =
          if (Comment.isSingleLineComment(comment)) {
            if (diff > 1) {
              Doc.hardLine;
            } else {
              Doc.nil;
            };
          } else if (diff === 0) {
            Doc.space;
          } else if (diff > 1) {
            Doc.concat([Doc.hardLine, Doc.hardLine]);
          } else {
            Doc.hardLine;
          };

        let doc =
          Doc.group(
            Doc.concat([
              Doc.concat(List.rev([cmtDoc, ...acc])),
              separator,
              node,
            ]),
          );

        doc;
      | [comment, ...[nextComment, ..._comments] as rest] =>
        let cmtDoc = printLeadingComment(~nextComment, comment);
        loop([cmtDoc, ...acc], rest);
      };

    switch (Hashtbl.find(tbl, loc)) {
    | 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 printTrailingComments = (node, tbl, loc) => {
    let rec loop = (acc, comments) =>
      switch (comments) {
      | [] => Doc.concat(List.rev(acc))
      | [comment, ...comments] =>
        let cmtDoc = printTrailingComment(loc, comment);
        loop([cmtDoc, ...acc], comments);
      };

    switch (Hashtbl.find(tbl, loc)) {
    | 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 cmtsDoc = loop([], comments);
      Doc.concat([node, cmtsDoc]);
    };
  };

  let printComments = (doc, tbl: CommentTable.t, loc) => {
    let docWithLeadingComments = printLeadingComments(doc, tbl.leading, loc);
    printTrailingComments(docWithLeadingComments, tbl.trailing, loc);
  };

  let printList = (~getLoc, ~nodes, ~print, ~forceBreak=false, t) => {
    let rec loop = (prevLoc: Location.t, acc, nodes) =>
      switch (nodes) {
      | [] => (prevLoc, Doc.concat(List.rev(acc)))
      | [node, ...nodes] =>
        let loc = getLoc(node);
        let startPos =
          switch (getFirstLeadingComment(t, loc)) {
          | None => loc.loc_start
          | Some(comment) => Comment.loc(comment).loc_start
          };

        let sep =
          if (startPos.pos_lnum - prevLoc.loc_end.pos_lnum > 1) {
            Doc.concat([Doc.hardLine, Doc.hardLine]);
          } else {
            Doc.hardLine;
          };

        let doc = printComments(print(node, t), t, loc);
        loop(loc, [doc, sep, ...acc], nodes);
      };

    switch (nodes) {
    | [] => Doc.nil
    | [node, ...nodes] =>
      let firstLoc = getLoc(node);
      let doc = printComments(print(node, t), t, firstLoc);
      let (lastLoc, docs) = loop(firstLoc, [doc], nodes);
      let forceBreak =
        forceBreak || firstLoc.loc_start.pos_lnum !== lastLoc.loc_end.pos_lnum;

      Doc.breakableGroup(~forceBreak, docs);
    };
  };

  let printListi = (~getLoc, ~nodes, ~print, ~forceBreak=false, t) => {
    let rec loop = (i, prevLoc: Location.t, acc, nodes) =>
      switch (nodes) {
      | [] => (prevLoc, Doc.concat(List.rev(acc)))
      | [node, ...nodes] =>
        let loc = getLoc(node);
        let startPos =
          switch (getFirstLeadingComment(t, loc)) {
          | None => loc.loc_start
          | Some(comment) => Comment.loc(comment).loc_start
          };

        let sep =
          if (startPos.pos_lnum - prevLoc.loc_end.pos_lnum > 1) {
            Doc.concat([Doc.hardLine, Doc.hardLine]);
          } else {
            Doc.line;
          };

        let doc = printComments(print(node, t, i), t, loc);
        loop(i + 1, loc, [doc, sep, ...acc], nodes);
      };

    switch (nodes) {
    | [] => Doc.nil
    | [node, ...nodes] =>
      let firstLoc = getLoc(node);
      let doc = printComments(print(node, t, 0), t, firstLoc);
      let (lastLoc, docs) = loop(1, firstLoc, [doc], nodes);
      let forceBreak =
        forceBreak || firstLoc.loc_start.pos_lnum !== lastLoc.loc_end.pos_lnum;

      Doc.breakableGroup(~forceBreak, docs);
    };
  };

  let rec printLongidentAux = accu =>
    fun
    | Longident.Lident(s) => [Doc.text(s), ...accu]
    | [@implicit_arity] Ldot(lid, s) =>
      printLongidentAux([Doc.text(s), ...accu], lid)
    | [@implicit_arity] Lapply(lid1, lid2) => {
        let d1 = Doc.join(~sep=Doc.dot, printLongidentAux([], lid1));
        let d2 = Doc.join(~sep=Doc.dot, printLongidentAux([], lid2));
        [Doc.concat([d1, Doc.lparen, d2, Doc.rparen]), ...accu];
      };

  let printLongident =
    fun
    | Longident.Lident(txt) => Doc.text(txt)
    | lid => Doc.join(~sep=Doc.dot, printLongidentAux([], lid));

  type identifierStyle =
    | ExoticIdent
    | NormalIdent;

  let classifyIdentContent = (~allowUident=false, txt) => {
    let len = String.length(txt);
    let rec go = i =>
      if (i === len) {
        NormalIdent;
      } else {
        let c = String.unsafe_get(txt, i);
        if (i === 0
            && !(
                 allowUident
                 && c >= 'A'
                 && c <= 'Z'
                 || c >= 'a'
                 && c <= 'z'
                 || c == '_'
                 || c >= '0'
                 && c <= '9'
               )) {
          ExoticIdent;
        } else if (!(
                     c >= 'a'
                     && c <= 'z'
                     || c >= 'A'
                     && c <= 'Z'
                     || c == '\''
                     || c == '_'
                     || c >= '0'
                     && c <= '9'
                   )) {
          ExoticIdent;
        } else {
          go(i + 1);
        };
      };

    if (Token.isKeywordTxt(txt) && txt != "list") {
      ExoticIdent;
    } else {
      go(0);
    };
  };

  let printIdentLike = (~allowUident=?, txt) =>
    switch (classifyIdentContent(~allowUident?, txt)) {
    | ExoticIdent =>
      Doc.concat([Doc.text("\\\""), Doc.text(txt), Doc.text("\"")])
    | NormalIdent => Doc.text(txt)
    };

  let printLident = l =>
    switch (l) {
    | Longident.Lident(txt) => printIdentLike(txt)
    | [@implicit_arity] Longident.Ldot(path, txt) =>
      let txts = Longident.flatten(path);
      Doc.concat([
        Doc.join(~sep=Doc.dot, List.map(Doc.text, txts)),
        Doc.dot,
        printIdentLike(txt),
      ]);
    | _ => Doc.text("printLident: Longident.Lapply is not supported")
    };

  let printLongidentLocation = (l, cmtTbl) => {
    let doc = printLongident(l.Location.txt);
    printComments(doc, cmtTbl, l.loc);
  };

  /* Module.SubModule.x */
  let printLidentPath = (path, cmtTbl) => {
    let doc = printLident(path.Location.txt);
    printComments(doc, cmtTbl, path.loc);
  };

  /* Module.SubModule.x or Module.SubModule.X */
  let printIdentPath = (path, cmtTbl) => {
    let doc = printLident(path.Location.txt);
    printComments(doc, cmtTbl, path.loc);
  };

  let printStringLoc = (sloc, cmtTbl) => {
    let doc = printIdentLike(sloc.Location.txt);
    printComments(doc, cmtTbl, sloc.loc);
  };

  let printConstant = c =>
    switch (c) {
    | [@implicit_arity] Parsetree.Pconst_integer(s, suffix) =>
      switch (suffix) {
      | Some(c) => Doc.text(s ++ Char.escaped(c))
      | None => Doc.text(s)
      }
    | [@implicit_arity] Pconst_string(txt, None) =>
      Doc.text("\"" ++ txt ++ "\"")
    | [@implicit_arity] Pconst_string(txt, Some(prefix)) =>
      Doc.concat([
        if (prefix == "") {
          Doc.nil;
        } else {
          Doc.text(prefix);
        },
        Doc.text("`" ++ txt ++ "`"),
      ])
    | [@implicit_arity] Pconst_float(s, _) => Doc.text(s)
    | Pconst_char(c) => Doc.text("'" ++ Char.escaped(c) ++ "'")
    };

  let rec printStructure = (s: Parsetree.structure, t) =>
    switch (s) {
    | [] => printCommentsInside(t, Location.none)
    | structure =>
      printList(
        ~getLoc=s => s.Parsetree.pstr_loc,
        ~nodes=structure,
        ~print=printStructureItem,
        t,
      )
    }

  and printStructureItem = (si: Parsetree.structure_item, cmtTbl) =>
    switch (si.pstr_desc) {
    | [@implicit_arity] Pstr_value(rec_flag, valueBindings) =>
      let recFlag =
        switch (rec_flag) {
        | Asttypes.Nonrecursive => Doc.nil
        | Asttypes.Recursive => Doc.text("rec ")
        };

      printValueBindings(~recFlag, valueBindings, cmtTbl);
    | [@implicit_arity] Pstr_type(recFlag, typeDeclarations) =>
      let recFlag =
        switch (recFlag) {
        | Asttypes.Nonrecursive => Doc.nil
        | Asttypes.Recursive => Doc.text("rec ")
        };

      printTypeDeclarations(~recFlag, typeDeclarations, cmtTbl);
    | Pstr_primitive(valueDescription) =>
      printValueDescription(valueDescription, cmtTbl)
    | [@implicit_arity] Pstr_eval(expr, attrs) =>
      let exprDoc = {
        let doc = printExpressionWithComments(expr, cmtTbl);
        switch (Parens.structureExpr(expr)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, expr, braces)
        | Nothing => doc
        };
      };

      Doc.concat([printAttributes(attrs), exprDoc]);
    | Pstr_attribute(attr) =>
      Doc.concat([Doc.text("@"), printAttributeWithComments(attr, cmtTbl)])
    | [@implicit_arity] Pstr_extension(extension, attrs) =>
      Doc.concat([
        printAttributes(attrs),
        Doc.concat([
          printExtensionWithComments(~atModuleLvl=true, extension, cmtTbl),
        ]),
      ])
    | Pstr_include(includeDeclaration) =>
      printIncludeDeclaration(includeDeclaration, cmtTbl)
    | Pstr_open(openDescription) =>
      printOpenDescription(openDescription, cmtTbl)
    | Pstr_modtype(modTypeDecl) =>
      printModuleTypeDeclaration(modTypeDecl, cmtTbl)
    | Pstr_module(moduleBinding) =>
      printModuleBinding(~isRec=false, moduleBinding, cmtTbl, 0)
    | Pstr_recmodule(moduleBindings) =>
      printListi(
        ~getLoc=mb => mb.Parsetree.pmb_loc,
        ~nodes=moduleBindings,
        ~print=printModuleBinding(~isRec=true),
        cmtTbl,
      )
    | Pstr_exception(extensionConstructor) =>
      printExceptionDef(extensionConstructor, cmtTbl)
    | Pstr_typext(typeExtension) => printTypeExtension(typeExtension, cmtTbl)
    | Pstr_class(_)
    | Pstr_class_type(_) => Doc.nil
    }

  and printTypeExtension = (te: Parsetree.type_extension, cmtTbl) => {
    let prefix = Doc.text("type ");
    let name = printLidentPath(te.ptyext_path, cmtTbl);
    let typeParams = printTypeParams(te.ptyext_params, cmtTbl);
    let extensionConstructors = {
      let ecs = te.ptyext_constructors;
      let forceBreak =
        switch (ecs, List.rev(ecs)) {
        | ([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
        };

      let privateFlag =
        switch (te.ptyext_private) {
        | Asttypes.Private => Doc.concat([Doc.text("private"), Doc.line])
        | Public => Doc.nil
        };

      let rows =
        printListi(
          ~getLoc=n => n.Parsetree.pext_loc,
          ~print=printExtensionConstructor,
          ~nodes=ecs,
          ~forceBreak,
          cmtTbl,
        );

      Doc.breakableGroup(
        ~forceBreak,
        Doc.indent(
          Doc.concat([
            Doc.line,
            privateFlag,
            rows,
            /* Doc.join ~sep:Doc.line ( */
            /* List.mapi printExtensionConstructor ecs */
            /* ) */
          ]),
        ),
      );
    };

    Doc.group(
      Doc.concat([
        printAttributes(~loc=te.ptyext_path.loc, te.ptyext_attributes),
        prefix,
        name,
        typeParams,
        Doc.text(" +="),
        extensionConstructors,
      ]),
    );
  }

  and printModuleBinding = (~isRec, moduleBinding, cmtTbl, i) => {
    let prefix =
      if (i == 0) {
        Doc.concat([
          Doc.text("module "),
          if (isRec) {
            Doc.text("rec ");
          } else {
            Doc.nil;
          },
        ]);
      } else {
        Doc.text("and ");
      };

    let (modExprDoc, modConstraintDoc) =
      switch (moduleBinding.pmb_expr) {
      | {pmod_desc: [@implicit_arity] Pmod_constraint(modExpr, modType)} => (
          printModExpr(modExpr, cmtTbl),
          Doc.concat([Doc.text(": "), printModType(modType, cmtTbl)]),
        )
      | modExpr => (printModExpr(modExpr, cmtTbl), Doc.nil)
      };

    let modName = {
      let doc = Doc.text(moduleBinding.pmb_name.Location.txt);
      printComments(doc, cmtTbl, moduleBinding.pmb_name.loc);
    };

    let doc =
      Doc.concat([
        printAttributes(
          ~loc=moduleBinding.pmb_name.loc,
          moduleBinding.pmb_attributes,
        ),
        prefix,
        modName,
        modConstraintDoc,
        Doc.text(" = "),
        modExprDoc,
      ]);
    printComments(doc, cmtTbl, moduleBinding.pmb_loc);
  }

  and printModuleTypeDeclaration =
      (modTypeDecl: Parsetree.module_type_declaration, cmtTbl) => {
    let modName = {
      let doc = Doc.text(modTypeDecl.pmtd_name.txt);
      printComments(doc, cmtTbl, modTypeDecl.pmtd_name.loc);
    };

    Doc.concat([
      printAttributes(modTypeDecl.pmtd_attributes),
      Doc.text("module type "),
      modName,
      switch (modTypeDecl.pmtd_type) {
      | None => Doc.nil
      | Some(modType) =>
        Doc.concat([Doc.text(" = "), printModType(modType, cmtTbl)])
      },
    ]);
  }

  and printModType = (modType, cmtTbl) => {
    let modTypeDoc =
      switch (modType.pmty_desc) {
      | Parsetree.Pmty_ident(longident) =>
        Doc.concat([
          printAttributes(~loc=longident.loc, modType.pmty_attributes),
          printLongidentLocation(longident, cmtTbl),
        ])
      | Pmty_signature(signature) =>
        let signatureDoc =
          Doc.breakableGroup(
            ~forceBreak=true,
            Doc.concat([
              Doc.lbrace,
              Doc.indent(
                Doc.concat([Doc.line, printSignature(signature, cmtTbl)]),
              ),
              Doc.line,
              Doc.rbrace,
            ]),
          );
        Doc.concat([printAttributes(modType.pmty_attributes), signatureDoc]);
      | Pmty_functor(_) =>
        let (parameters, returnType) = ParsetreeViewer.functorType(modType);
        let parametersDoc =
          switch (parameters) {
          | [] => Doc.nil
          | [(attrs, {Location.txt: "_", loc}, Some(modType))] =>
            let cmtLoc = {
              ...loc,
              loc_end: modType.Parsetree.pmty_loc.loc_end,
            };

            let attrs =
              switch (attrs) {
              | [] => Doc.nil
              | attrs =>
                Doc.concat([
                  Doc.join(~sep=Doc.line, List.map(printAttribute, attrs)),
                  Doc.line,
                ])
              };
            let doc = Doc.concat([attrs, printModType(modType, cmtTbl)]);
            printComments(doc, cmtTbl, cmtLoc);
          | params =>
            Doc.group(
              Doc.concat([
                Doc.lparen,
                Doc.indent(
                  Doc.concat([
                    Doc.softLine,
                    Doc.join(
                      ~sep=Doc.concat([Doc.comma, Doc.line]),
                      List.map(
                        ((attrs, lbl, modType)) => {
                          let cmtLoc =
                            switch (modType) {
                            | None => lbl.Asttypes.loc
                            | Some(modType) => {
                                ...lbl.Asttypes.loc,
                                loc_end: modType.Parsetree.pmty_loc.loc_end,
                              }
                            };

                          let attrs =
                            switch (attrs) {
                            | [] => Doc.nil
                            | attrs =>
                              Doc.concat([
                                Doc.join(
                                  ~sep=Doc.line,
                                  List.map(printAttribute, attrs),
                                ),
                                Doc.line,
                              ])
                            };
                          let lblDoc =
                            if (lbl.Location.txt == "_") {
                              Doc.nil;
                            } else {
                              let doc = Doc.text(lbl.txt);
                              printComments(doc, cmtTbl, lbl.loc);
                            };

                          let doc =
                            Doc.concat([
                              attrs,
                              lblDoc,
                              switch (modType) {
                              | None => Doc.nil
                              | Some(modType) =>
                                Doc.concat([
                                  if (lbl.txt == "_") {
                                    Doc.nil;
                                  } else {
                                    Doc.text(": ");
                                  },
                                  printModType(modType, cmtTbl),
                                ])
                              },
                            ]);
                          printComments(doc, cmtTbl, cmtLoc);
                        },
                        params,
                      ),
                    ),
                  ]),
                ),
                Doc.trailingComma,
                Doc.softLine,
                Doc.rparen,
              ]),
            )
          };

        let returnDoc = {
          let doc = printModType(returnType, cmtTbl);
          if (Parens.modTypeFunctorReturn(returnType)) {
            addParens(doc);
          } else {
            doc;
          };
        };

        Doc.group(
          Doc.concat([
            parametersDoc,
            Doc.group(Doc.concat([Doc.text(" =>"), Doc.line, returnDoc])),
          ]),
        );
      | Pmty_typeof(modExpr) =>
        Doc.concat([
          Doc.text("module type of "),
          printModExpr(modExpr, cmtTbl),
        ])
      | Pmty_extension(extension) =>
        printExtensionWithComments(~atModuleLvl=false, extension, cmtTbl)
      | Pmty_alias(longident) =>
        Doc.concat([
          Doc.text("module "),
          printLongidentLocation(longident, cmtTbl),
        ])
      | [@implicit_arity] Pmty_with(modType, withConstraints) =>
        let operand = {
          let doc = printModType(modType, cmtTbl);
          if (Parens.modTypeWithOperand(modType)) {
            addParens(doc);
          } else {
            doc;
          };
        };

        Doc.group(
          Doc.concat([
            operand,
            Doc.indent(
              Doc.concat([
                Doc.line,
                printWithConstraints(withConstraints, cmtTbl),
              ]),
            ),
          ]),
        );
      };

    let attrsAlreadyPrinted =
      switch (modType.pmty_desc) {
      | Pmty_functor(_)
      | Pmty_signature(_)
      | Pmty_ident(_) => true
      | _ => false
      };

    let doc =
      Doc.concat([
        if (attrsAlreadyPrinted) {
          Doc.nil;
        } else {
          printAttributes(modType.pmty_attributes);
        },
        modTypeDoc,
      ]);
    printComments(doc, cmtTbl, modType.pmty_loc);
  }

  and printWithConstraints = (withConstraints, cmtTbl) => {
    let rows =
      List.mapi(
        (i, withConstraint) =>
          Doc.group(
            Doc.concat([
              if (i === 0) {
                Doc.text("with ");
              } else {
                Doc.text("and ");
              },
              printWithConstraint(withConstraint, cmtTbl),
            ]),
          ),
        withConstraints,
      );

    Doc.join(~sep=Doc.line, rows);
  }

  and printWithConstraint =
      (withConstraint: Parsetree.with_constraint, cmtTbl) =>
    switch (withConstraint) {
    /* with type X.t = ... */
    | [@implicit_arity] Pwith_type(longident, typeDeclaration) =>
      Doc.group(
        printTypeDeclaration(
          ~name=printLidentPath(longident, cmtTbl),
          ~equalSign="=",
          ~recFlag=Doc.nil,
          0,
          typeDeclaration,
          CommentTable.empty,
        ),
      )
    /* with module X.Y = Z */
    | [@implicit_arity] Pwith_module({txt: longident1}, {txt: longident2}) =>
      Doc.concat([
        Doc.text("module "),
        printLongident(longident1),
        Doc.text(" ="),
        Doc.indent(Doc.concat([Doc.line, printLongident(longident2)])),
      ])
    /* with type X.t := ..., same format as [Pwith_type] */
    | [@implicit_arity] Pwith_typesubst(longident, typeDeclaration) =>
      Doc.group(
        printTypeDeclaration(
          ~name=printLidentPath(longident, cmtTbl),
          ~equalSign=":=",
          ~recFlag=Doc.nil,
          0,
          typeDeclaration,
          CommentTable.empty,
        ),
      )
    | [@implicit_arity] Pwith_modsubst({txt: longident1}, {txt: longident2}) =>
      Doc.concat([
        Doc.text("module "),
        printLongident(longident1),
        Doc.text(" :="),
        Doc.indent(Doc.concat([Doc.line, printLongident(longident2)])),
      ])
    }

  and printSignature = (signature, cmtTbl) =>
    switch (signature) {
    | [] => printCommentsInside(cmtTbl, Location.none)
    | signature =>
      printList(
        ~getLoc=s => s.Parsetree.psig_loc,
        ~nodes=signature,
        ~print=printSignatureItem,
        cmtTbl,
      )
    }

  and printSignatureItem = (si: Parsetree.signature_item, cmtTbl) =>
    switch (si.psig_desc) {
    | Parsetree.Psig_value(valueDescription) =>
      printValueDescription(valueDescription, cmtTbl)
    | [@implicit_arity] Psig_type(recFlag, typeDeclarations) =>
      let recFlag =
        switch (recFlag) {
        | Asttypes.Nonrecursive => Doc.nil
        | Asttypes.Recursive => Doc.text("rec ")
        };

      printTypeDeclarations(~recFlag, typeDeclarations, cmtTbl);
    | Psig_typext(typeExtension) => printTypeExtension(typeExtension, cmtTbl)
    | Psig_exception(extensionConstructor) =>
      printExceptionDef(extensionConstructor, cmtTbl)
    | Psig_module(moduleDeclaration) =>
      printModuleDeclaration(moduleDeclaration, cmtTbl)
    | Psig_recmodule(moduleDeclarations) =>
      printRecModuleDeclarations(moduleDeclarations, cmtTbl)
    | Psig_modtype(modTypeDecl) =>
      printModuleTypeDeclaration(modTypeDecl, cmtTbl)
    | Psig_open(openDescription) =>
      printOpenDescription(openDescription, cmtTbl)
    | Psig_include(includeDescription) =>
      printIncludeDescription(includeDescription, cmtTbl)
    | Psig_attribute(attr) =>
      Doc.concat([Doc.text("@"), printAttributeWithComments(attr, cmtTbl)])
    | [@implicit_arity] Psig_extension(extension, attrs) =>
      Doc.concat([
        printAttributes(attrs),
        Doc.concat([
          printExtensionWithComments(~atModuleLvl=true, extension, cmtTbl),
        ]),
      ])
    | Psig_class(_)
    | Psig_class_type(_) => Doc.nil
    }

  and printRecModuleDeclarations = (moduleDeclarations, cmtTbl) =>
    printListi(
      ~getLoc=n => n.Parsetree.pmd_loc,
      ~nodes=moduleDeclarations,
      ~print=printRecModuleDeclaration,
      cmtTbl,
    )

  and printRecModuleDeclaration = (md, cmtTbl, i) => {
    let body =
      switch (md.pmd_type.pmty_desc) {
      | Parsetree.Pmty_alias(longident) =>
        Doc.concat([
          Doc.text(" = "),
          printLongidentLocation(longident, cmtTbl),
        ])
      | _ =>
        let needsParens =
          switch (md.pmd_type.pmty_desc) {
          | Pmty_with(_) => true
          | _ => false
          };

        let modTypeDoc = {
          let doc = printModType(md.pmd_type, cmtTbl);
          if (needsParens) {
            addParens(doc);
          } else {
            doc;
          };
        };

        Doc.concat([Doc.text(": "), modTypeDoc]);
      };

    let prefix =
      if (i < 1) {
        "module rec ";
      } else {
        "and ";
      };
    Doc.concat([
      printAttributes(~loc=md.pmd_name.loc, md.pmd_attributes),
      Doc.text(prefix),
      printComments(Doc.text(md.pmd_name.txt), cmtTbl, md.pmd_name.loc),
      body,
    ]);
  }

  and printModuleDeclaration = (md: Parsetree.module_declaration, cmtTbl) => {
    let body =
      switch (md.pmd_type.pmty_desc) {
      | Parsetree.Pmty_alias(longident) =>
        Doc.concat([
          Doc.text(" = "),
          printLongidentLocation(longident, cmtTbl),
        ])
      | _ => Doc.concat([Doc.text(": "), printModType(md.pmd_type, cmtTbl)])
      };

    Doc.concat([
      printAttributes(~loc=md.pmd_name.loc, md.pmd_attributes),
      Doc.text("module "),
      printComments(Doc.text(md.pmd_name.txt), cmtTbl, md.pmd_name.loc),
      body,
    ]);
  }

  and printOpenDescription = (openDescription: Parsetree.open_description, p) =>
    Doc.concat([
      printAttributes(openDescription.popen_attributes),
      Doc.text("open"),
      switch (openDescription.popen_override) {
      | Asttypes.Fresh => Doc.space
      | Asttypes.Override => Doc.text("! ")
      },
      printLongidentLocation(openDescription.popen_lid, p),
    ])

  and printIncludeDescription =
      (includeDescription: Parsetree.include_description, cmtTbl) =>
    Doc.concat([
      printAttributes(includeDescription.pincl_attributes),
      Doc.text("include "),
      printModType(includeDescription.pincl_mod, cmtTbl),
    ])

  and printIncludeDeclaration =
      (includeDeclaration: Parsetree.include_declaration, cmtTbl) => {
    let isJsFfiImport =
      List.exists(
        attr =>
          switch (attr) {
          | ({Location.txt: "ns.jsFfi"}, _) => true
          | _ => false
          },
        includeDeclaration.pincl_attributes,
      );

    if (isJsFfiImport) {
      printJsFfiImportDeclaration(includeDeclaration, cmtTbl);
    } else {
      Doc.concat([
        printAttributes(includeDeclaration.pincl_attributes),
        Doc.text("include "),
        {
          let includeDoc = printModExpr(includeDeclaration.pincl_mod, cmtTbl);

          if (Parens.includeModExpr(includeDeclaration.pincl_mod)) {
            addParens(includeDoc);
          } else {
            includeDoc;
          };
        },
      ]);
    };
  }

  and printJsFfiImport =
      (valueDescription: Parsetree.value_description, cmtTbl) => {
    let attrs =
      List.filter(
        attr =>
          switch (attr) {
          | ({Location.txt: "bs.val" | "genType.import" | "bs.scope"}, _) =>
            false
          | _ => true
          },
        valueDescription.pval_attributes,
      );
    let (ident, alias) =
      switch (valueDescription.pval_prim) {
      | [primitive, ..._] =>
        if (primitive != valueDescription.pval_name.txt) {
          (
            printIdentLike(primitive),
            Doc.concat([
              Doc.text(" as "),
              printIdentLike(valueDescription.pval_name.txt),
            ]),
          );
        } else {
          (printIdentLike(primitive), Doc.nil);
        }
      | _ => (printIdentLike(valueDescription.pval_name.txt), Doc.nil)
      };

    Doc.concat([
      printAttributes(~loc=valueDescription.pval_name.loc, attrs),
      ident,
      alias,
      Doc.text(": "),
      printTypExpr(valueDescription.pval_type, cmtTbl),
    ]);
  }

  and printJsFfiImportScope = (scope: ParsetreeViewer.jsImportScope) =>
    switch (scope) {
    | JsGlobalImport => Doc.nil
    | JsModuleImport(modName) =>
      Doc.concat([
        Doc.text(" from "),
        Doc.doubleQuote,
        Doc.text(modName),
        Doc.doubleQuote,
      ])
    | JsScopedImport(idents) =>
      Doc.concat([
        Doc.text(" from "),
        Doc.join(~sep=Doc.dot, List.map(Doc.text, idents)),
      ])
    }

  and printJsFfiImportDeclaration =
      (includeDeclaration: Parsetree.include_declaration, cmtTbl) => {
    let attrs =
      List.filter(
        attr =>
          switch (attr) {
          | ({Location.txt: "ns.jsFfi"}, _) => false
          | _ => true
          },
        includeDeclaration.pincl_attributes,
      );

    let imports =
      ParsetreeViewer.extractValueDescriptionFromModExpr(
        includeDeclaration.pincl_mod,
      );
    let scope =
      switch (imports) {
      | [vd, ..._] => ParsetreeViewer.classifyJsImport(vd)
      | [] => ParsetreeViewer.JsGlobalImport
      };

    let scopeDoc = printJsFfiImportScope(scope);
    Doc.group(
      Doc.concat([
        printAttributes(attrs),
        Doc.text("import "),
        Doc.group(
          Doc.concat([
            Doc.lbrace,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.comma, Doc.line]),
                  List.map(vd => printJsFfiImport(vd, cmtTbl), imports),
                ),
              ]),
            ),
            Doc.trailingComma,
            Doc.softLine,
            Doc.rbrace,
          ]),
        ),
        scopeDoc,
      ]),
    );
  }

  and printValueBindings =
      (~recFlag, vbs: list(Parsetree.value_binding), cmtTbl) =>
    printListi(
      ~getLoc=vb => vb.Parsetree.pvb_loc,
      ~nodes=vbs,
      ~print=printValueBinding(~recFlag),
      cmtTbl,
    )

  and printValueDescription = (valueDescription, cmtTbl) => {
    let isExternal =
      switch (valueDescription.pval_prim) {
      | [] => false
      | _ => true
      };

    Doc.group(
      Doc.concat([
        printAttributes(valueDescription.pval_attributes),
        Doc.text(if (isExternal) {"external "} else {"let "}),
        printComments(
          printIdentLike(valueDescription.pval_name.txt),
          cmtTbl,
          valueDescription.pval_name.loc,
        ),
        Doc.text(": "),
        printTypExpr(valueDescription.pval_type, cmtTbl),
        if (isExternal) {
          Doc.group(
            Doc.concat([
              Doc.text(" ="),
              Doc.indent(
                Doc.concat([
                  Doc.line,
                  Doc.join(
                    ~sep=Doc.line,
                    List.map(
                      s =>
                        Doc.concat([
                          Doc.text("\""),
                          Doc.text(s),
                          Doc.text("\""),
                        ]),
                      valueDescription.pval_prim,
                    ),
                  ),
                ]),
              ),
            ]),
          );
        } else {
          Doc.nil;
        },
      ]),
    );
  }

  and printTypeDeclarations = (~recFlag, typeDeclarations, cmtTbl) =>
    printListi(
      ~getLoc=n => n.Parsetree.ptype_loc,
      ~nodes=typeDeclarations,
      ~print=printTypeDeclaration2(~recFlag),
      cmtTbl,
    )

  /*
   * 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 printTypeDeclaration =
      (~name, ~equalSign, ~recFlag, i, td: Parsetree.type_declaration, cmtTbl) => {
    let (hasGenType, attrs) =
      ParsetreeViewer.splitGenTypeAttr(td.ptype_attributes);
    let attrs = printAttributes(~loc=td.ptype_loc, attrs);
    let prefix =
      if (i > 0) {
        Doc.concat([
          Doc.text("and "),
          if (hasGenType) {
            Doc.text("export ");
          } else {
            Doc.nil;
          },
        ]);
      } else {
        Doc.concat([
          Doc.text(if (hasGenType) {"export type "} else {"type "}),
          recFlag,
        ]);
      };

    let typeName = name;
    let typeParams = printTypeParams(td.ptype_params, cmtTbl);
    let manifestAndKind =
      switch (td.ptype_kind) {
      | Ptype_abstract =>
        switch (td.ptype_manifest) {
        | None => Doc.nil
        | Some(typ) =>
          Doc.concat([
            Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
            printPrivateFlag(td.ptype_private),
            printTypExpr(typ, cmtTbl),
          ])
        }
      | Ptype_open =>
        Doc.concat([
          Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
          printPrivateFlag(td.ptype_private),
          Doc.text(".."),
        ])
      | Ptype_record(lds) =>
        let manifest =
          switch (td.ptype_manifest) {
          | None => Doc.nil
          | Some(typ) =>
            Doc.concat([
              Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
              printTypExpr(typ, cmtTbl),
            ])
          };

        Doc.concat([
          manifest,
          Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
          printPrivateFlag(td.ptype_private),
          printRecordDeclaration(lds, cmtTbl),
        ]);
      | Ptype_variant(cds) =>
        let manifest =
          switch (td.ptype_manifest) {
          | None => Doc.nil
          | Some(typ) =>
            Doc.concat([
              Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
              printTypExpr(typ, cmtTbl),
            ])
          };

        Doc.concat([
          manifest,
          Doc.concat([Doc.space, Doc.text(equalSign)]),
          printConstructorDeclarations(
            ~privateFlag=td.ptype_private,
            cds,
            cmtTbl,
          ),
        ]);
      };

    let constraints = printTypeDefinitionConstraints(td.ptype_cstrs);
    Doc.group(
      Doc.concat([
        attrs,
        prefix,
        typeName,
        typeParams,
        manifestAndKind,
        constraints,
      ]),
    );
  }

  and printTypeDeclaration2 =
      (~recFlag, td: Parsetree.type_declaration, cmtTbl, i) => {
    let name = {
      let doc = printIdentLike(td.Parsetree.ptype_name.txt);
      printComments(doc, cmtTbl, td.ptype_name.loc);
    };

    let equalSign = "=";
    let (hasGenType, attrs) =
      ParsetreeViewer.splitGenTypeAttr(td.ptype_attributes);
    let attrs = printAttributes(~loc=td.ptype_loc, attrs);
    let prefix =
      if (i > 0) {
        Doc.concat([
          Doc.text("and "),
          if (hasGenType) {
            Doc.text("export ");
          } else {
            Doc.nil;
          },
        ]);
      } else {
        Doc.concat([
          Doc.text(if (hasGenType) {"export type "} else {"type "}),
          recFlag,
        ]);
      };

    let typeName = name;
    let typeParams = printTypeParams(td.ptype_params, cmtTbl);
    let manifestAndKind =
      switch (td.ptype_kind) {
      | Ptype_abstract =>
        switch (td.ptype_manifest) {
        | None => Doc.nil
        | Some(typ) =>
          Doc.concat([
            Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
            printPrivateFlag(td.ptype_private),
            printTypExpr(typ, cmtTbl),
          ])
        }
      | Ptype_open =>
        Doc.concat([
          Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
          printPrivateFlag(td.ptype_private),
          Doc.text(".."),
        ])
      | Ptype_record(lds) =>
        let manifest =
          switch (td.ptype_manifest) {
          | None => Doc.nil
          | Some(typ) =>
            Doc.concat([
              Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
              printTypExpr(typ, cmtTbl),
            ])
          };

        Doc.concat([
          manifest,
          Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
          printPrivateFlag(td.ptype_private),
          printRecordDeclaration(lds, cmtTbl),
        ]);
      | Ptype_variant(cds) =>
        let manifest =
          switch (td.ptype_manifest) {
          | None => Doc.nil
          | Some(typ) =>
            Doc.concat([
              Doc.concat([Doc.space, Doc.text(equalSign), Doc.space]),
              printTypExpr(typ, cmtTbl),
            ])
          };

        Doc.concat([
          manifest,
          Doc.concat([Doc.space, Doc.text(equalSign)]),
          printConstructorDeclarations(
            ~privateFlag=td.ptype_private,
            cds,
            cmtTbl,
          ),
        ]);
      };

    let constraints = printTypeDefinitionConstraints(td.ptype_cstrs);
    Doc.group(
      Doc.concat([
        attrs,
        prefix,
        typeName,
        typeParams,
        manifestAndKind,
        constraints,
      ]),
    );
  }

  and printTypeDefinitionConstraints = cstrs =>
    switch (cstrs) {
    | [] => Doc.nil
    | cstrs =>
      Doc.indent(
        Doc.group(
          Doc.concat([
            Doc.line,
            Doc.group(
              Doc.join(
                ~sep=Doc.line,
                List.map(printTypeDefinitionConstraint, cstrs),
              ),
            ),
          ]),
        ),
      )
    }

  and printTypeDefinitionConstraint =
      (
        (typ1, typ2, _loc): (
          Parsetree.core_type,
          Parsetree.core_type,
          Location.t,
        ),
      ) =>
    Doc.concat([
      Doc.text("constraint "),
      printTypExpr(typ1, CommentTable.empty),
      Doc.text(" = "),
      printTypExpr(typ2, CommentTable.empty),
    ])

  and printPrivateFlag = (flag: Asttypes.private_flag) =>
    switch (flag) {
    | Private => Doc.text("private ")
    | Public => Doc.nil
    }

  and printTypeParams = (typeParams, cmtTbl) =>
    switch (typeParams) {
    | [] => Doc.nil
    | typeParams =>
      Doc.group(
        Doc.concat([
          Doc.lessThan,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(
                  typeParam => {
                    let doc = printTypeParam(typeParam, cmtTbl);
                    printComments(
                      doc,
                      cmtTbl,
                      fst(typeParam).Parsetree.ptyp_loc,
                    );
                  },
                  typeParams,
                ),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.greaterThan,
        ]),
      )
    }

  and printTypeParam =
      (param: (Parsetree.core_type, Asttypes.variance), cmtTbl) => {
    let (typ, variance) = param;
    let printedVariance =
      switch (variance) {
      | Covariant => Doc.text("+")
      | Contravariant => Doc.text("-")
      | Invariant => Doc.nil
      };

    Doc.concat([printedVariance, printTypExpr(typ, cmtTbl)]);
  }

  and printRecordDeclaration =
      (lds: list(Parsetree.label_declaration), cmtTbl) => {
    let forceBreak =
      switch (lds, List.rev(lds)) {
      | ([first, ..._], [last, ..._]) =>
        first.pld_loc.loc_start.pos_lnum < last.pld_loc.loc_end.pos_lnum
      | _ => false
      };

    Doc.breakableGroup(
      ~forceBreak,
      Doc.concat([
        Doc.lbrace,
        Doc.indent(
          Doc.concat([
            Doc.softLine,
            Doc.join(
              ~sep=Doc.concat([Doc.comma, Doc.line]),
              List.map(
                ld => {
                  let doc = printLabelDeclaration(ld, cmtTbl);
                  printComments(doc, cmtTbl, ld.Parsetree.pld_loc);
                },
                lds,
              ),
            ),
          ]),
        ),
        Doc.trailingComma,
        Doc.softLine,
        Doc.rbrace,
      ]),
    );
  }

  and printConstructorDeclarations =
      (~privateFlag, cds: list(Parsetree.constructor_declaration), cmtTbl) => {
    let forceBreak =
      switch (cds, List.rev(cds)) {
      | ([first, ..._], [last, ..._]) =>
        first.pcd_loc.loc_start.pos_lnum < last.pcd_loc.loc_end.pos_lnum
      | _ => false
      };

    let privateFlag =
      switch (privateFlag) {
      | Asttypes.Private => Doc.concat([Doc.text("private"), Doc.line])
      | Public => Doc.nil
      };

    let rows =
      printListi(
        ~getLoc=cd => cd.Parsetree.pcd_loc,
        ~nodes=cds,
        ~print=
          (cd, cmtTbl, i) => {
            let doc = printConstructorDeclaration2(i, cd, cmtTbl);
            printComments(doc, cmtTbl, cd.Parsetree.pcd_loc);
          },
        ~forceBreak,
        cmtTbl,
      );

    Doc.breakableGroup(
      ~forceBreak,
      Doc.indent(Doc.concat([Doc.line, privateFlag, rows])),
    );
  }

  and printConstructorDeclaration2 =
      (i, cd: Parsetree.constructor_declaration, cmtTbl) => {
    let attrs = printAttributes(cd.pcd_attributes);
    let bar =
      if (i > 0) {
        Doc.text("| ");
      } else {
        Doc.ifBreaks(Doc.text("| "), Doc.nil);
      };

    let constrName = {
      let doc = Doc.text(cd.pcd_name.txt);
      printComments(doc, cmtTbl, cd.pcd_name.loc);
    };

    let constrArgs =
      printConstructorArguments(~indent=true, cd.pcd_args, cmtTbl);
    let gadt =
      switch (cd.pcd_res) {
      | None => Doc.nil
      | Some(typ) =>
        Doc.indent(Doc.concat([Doc.text(": "), printTypExpr(typ, cmtTbl)]))
      };

    Doc.concat([
      bar,
      Doc.group(
        Doc.concat([
          attrs, /* TODO: fix parsing of attributes, so when can print them above the bar? */
          constrName,
          constrArgs,
          gadt,
        ]),
      ),
    ]);
  }

  and printConstructorArguments =
      (~indent, cdArgs: Parsetree.constructor_arguments, cmtTbl) =>
    switch (cdArgs) {
    | Pcstr_tuple([]) => Doc.nil
    | Pcstr_tuple(types) =>
      let args =
        Doc.concat([
          Doc.lparen,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(typexpr => printTypExpr(typexpr, cmtTbl), types),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.rparen,
        ]);
      Doc.group(
        if (indent) {
          Doc.indent(args);
        } else {
          args;
        },
      );
    | Pcstr_record(lds) =>
      let args =
        Doc.concat([
          Doc.lparen,
          /* manually inline the printRecordDeclaration, gives better layout */
          Doc.lbrace,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(
                  ld => {
                    let doc = printLabelDeclaration(ld, cmtTbl);
                    printComments(doc, cmtTbl, ld.Parsetree.pld_loc);
                  },
                  lds,
                ),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.rbrace,
          Doc.rparen,
        ]);
      if (indent) {
        Doc.indent(args);
      } else {
        args;
      };
    }

  and printLabelDeclaration = (ld: Parsetree.label_declaration, cmtTbl) => {
    let attrs = printAttributes(~loc=ld.pld_name.loc, ld.pld_attributes);
    let mutableFlag =
      switch (ld.pld_mutable) {
      | Mutable => Doc.text("mutable ")
      | Immutable => Doc.nil
      };

    let name = {
      let doc = printIdentLike(ld.pld_name.txt);
      printComments(doc, cmtTbl, ld.pld_name.loc);
    };

    Doc.group(
      Doc.concat([
        attrs,
        mutableFlag,
        name,
        Doc.text(": "),
        printTypExpr(ld.pld_type, cmtTbl),
      ]),
    );
  }

  and printTypExpr = (typExpr: Parsetree.core_type, cmtTbl) => {
    let renderedType =
      switch (typExpr.ptyp_desc) {
      | Ptyp_any => Doc.text("_")
      | Ptyp_var(var) => Doc.concat([Doc.text("'"), printIdentLike(var)])
      | Ptyp_extension(extension) =>
        printExtensionWithComments(~atModuleLvl=false, extension, cmtTbl)
      | [@implicit_arity] 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 needsParens =
            switch (typ.ptyp_desc) {
            | Ptyp_arrow(_) => true
            | _ => false
            };

          let doc = printTypExpr(typ, cmtTbl);
          if (needsParens) {
            Doc.concat([Doc.lparen, doc, Doc.rparen]);
          } else {
            doc;
          };
        };

        Doc.concat([
          typ,
          Doc.text(" as "),
          Doc.concat([Doc.text("'"), printIdentLike(alias)]),
        ]);
      | [@implicit_arity]
        Ptyp_constr(
          {
            txt: [@implicit_arity] Longident.Ldot(Longident.Lident("Js"), "t"),
          },
          [
            {ptyp_desc: [@implicit_arity] Ptyp_object(_fields, _openFlag)} as typ,
          ],
        ) =>
        let bsObject = printTypExpr(typ, cmtTbl);
        switch (typExpr.ptyp_attributes) {
        | [] => bsObject
        | attrs =>
          Doc.concat([
            Doc.group(
              Doc.join(~sep=Doc.line, List.map(printAttribute, attrs)),
            ),
            Doc.space,
            printTypExpr(typ, cmtTbl),
          ])
        };
      | [@implicit_arity]
        Ptyp_constr(
          longidentLoc,
          [{ptyp_desc: Parsetree.Ptyp_tuple(tuple)}],
        ) =>
        let constrName = printLidentPath(longidentLoc, cmtTbl);
        Doc.group(
          Doc.concat([
            constrName,
            Doc.lessThan,
            printTupleType(~inline=true, tuple, cmtTbl),
            Doc.greaterThan,
          ]),
        );
      | [@implicit_arity] Ptyp_constr(longidentLoc, constrArgs) =>
        let constrName = printLidentPath(longidentLoc, cmtTbl);
        switch (constrArgs) {
        | [] => constrName
        | [
            {
              Parsetree.ptyp_desc:
                [@implicit_arity]
                Ptyp_constr(
                  {
                    txt:
                      [@implicit_arity]
                      Longident.Ldot(Longident.Lident("Js"), "t"),
                  },
                  [
                    {
                      ptyp_desc:
                        [@implicit_arity] Ptyp_object(fields, openFlag),
                    },
                  ],
                ),
            },
          ] =>
          Doc.concat([
            constrName,
            Doc.lessThan,
            printBsObjectSugar(~inline=true, fields, openFlag, cmtTbl),
            Doc.greaterThan,
          ])
        | _args =>
          Doc.group(
            Doc.concat([
              constrName,
              Doc.lessThan,
              Doc.indent(
                Doc.concat([
                  Doc.softLine,
                  Doc.join(
                    ~sep=Doc.concat([Doc.comma, Doc.line]),
                    List.map(
                      typexpr => printTypExpr(typexpr, cmtTbl),
                      constrArgs,
                    ),
                  ),
                ]),
              ),
              Doc.trailingComma,
              Doc.softLine,
              Doc.greaterThan,
            ]),
          )
        };
      | Ptyp_arrow(_) =>
        let (attrsBefore, args, returnType) =
          ParsetreeViewer.arrowType(typExpr);
        let returnTypeNeedsParens =
          switch (returnType.ptyp_desc) {
          | Ptyp_alias(_) => true
          | _ => false
          };

        let returnDoc = {
          let doc = printTypExpr(returnType, cmtTbl);
          if (returnTypeNeedsParens) {
            Doc.concat([Doc.lparen, doc, Doc.rparen]);
          } else {
            doc;
          };
        };

        let (isUncurried, attrs) =
          ParsetreeViewer.processUncurriedAttribute(attrsBefore);

        switch (args) {
        | [] => Doc.nil
        | [([], Nolabel, n)] when !isUncurried =>
          let hasAttrsBefore = !(attrs == []);
          let attrs =
            if (hasAttrsBefore) {
              Doc.concat([
                Doc.join(
                  ~sep=Doc.line,
                  List.map(printAttribute, attrsBefore),
                ),
                Doc.space,
              ]);
            } else {
              Doc.nil;
            };

          let typDoc = {
            let doc = printTypExpr(n, cmtTbl);
            switch (n.ptyp_desc) {
            | Ptyp_arrow(_)
            | Ptyp_tuple(_) => addParens(doc)
            | _ => doc
            };
          };

          Doc.group(
            Doc.concat([
              Doc.group(attrs),
              Doc.group(
                if (hasAttrsBefore) {
                  Doc.concat([
                    Doc.lparen,
                    Doc.indent(
                      Doc.concat([
                        Doc.softLine,
                        typDoc,
                        Doc.text(" => "),
                        returnDoc,
                      ]),
                    ),
                    Doc.softLine,
                    Doc.rparen,
                  ]);
                } else {
                  Doc.concat([typDoc, Doc.text(" => "), returnDoc]);
                },
              ),
            ]),
          );
        | args =>
          let attrs =
            switch (attrs) {
            | [] => Doc.nil
            | attrs =>
              Doc.concat([
                Doc.join(~sep=Doc.line, List.map(printAttribute, attrs)),
                Doc.space,
              ])
            };

          let renderedArgs =
            Doc.concat([
              attrs,
              Doc.text("("),
              Doc.indent(
                Doc.concat([
                  Doc.softLine,
                  if (isUncurried) {
                    Doc.concat([Doc.dot, Doc.space]);
                  } else {
                    Doc.nil;
                  },
                  Doc.join(
                    ~sep=Doc.concat([Doc.comma, Doc.line]),
                    List.map(tp => printTypeParameter(tp, cmtTbl), args),
                  ),
                ]),
              ),
              Doc.trailingComma,
              Doc.softLine,
              Doc.text(")"),
            ]);
          Doc.group(
            Doc.concat([renderedArgs, Doc.text(" => "), returnDoc]),
          );
        };
      | Ptyp_tuple(types) => printTupleType(~inline=false, types, cmtTbl)
      | [@implicit_arity] Ptyp_object(fields, openFlag) =>
        printBsObjectSugar(~inline=false, fields, openFlag, cmtTbl)
      | [@implicit_arity] Ptyp_poly([], typ) => printTypExpr(typ, cmtTbl)
      | [@implicit_arity] Ptyp_poly(stringLocs, typ) =>
        Doc.concat([
          Doc.join(
            ~sep=Doc.space,
            List.map(
              ({Location.txt, loc}) => {
                let doc = Doc.concat([Doc.text("'"), Doc.text(txt)]);
                printComments(doc, cmtTbl, loc);
              },
              stringLocs,
            ),
          ),
          Doc.dot,
          Doc.space,
          printTypExpr(typ, cmtTbl),
        ])
      | Ptyp_package(packageType) =>
        printPackageType(
          ~printModuleKeywordAndParens=true,
          packageType,
          cmtTbl,
        )
      | Ptyp_class(_) => Doc.text("classes are not supported in types")
      | [@implicit_arity] Ptyp_variant(rowFields, closedFlag, labelsOpt) =>
        let printRowField = (
          fun
          | [@implicit_arity] Parsetree.Rtag({txt}, attrs, true, []) =>
            Doc.concat([
              printAttributes(attrs),
              Doc.concat([
                Doc.text("#"),
                printIdentLike(~allowUident=true, txt),
              ]),
            ])
          | [@implicit_arity] Rtag({txt}, attrs, truth, types) => {
              let doType = t =>
                switch (t.Parsetree.ptyp_desc) {
                | Ptyp_tuple(_) => printTypExpr(t, cmtTbl)
                | _ =>
                  Doc.concat([
                    Doc.lparen,
                    printTypExpr(t, cmtTbl),
                    Doc.rparen,
                  ])
                };

              let printedTypes = List.map(doType, types);
              let cases =
                Doc.join(
                  ~sep=Doc.concat([Doc.line, Doc.text("& ")]),
                  printedTypes,
                );
              let cases =
                if (truth) {
                  Doc.concat([Doc.line, Doc.text("& "), cases]);
                } else {
                  cases;
                };
              Doc.group(
                Doc.concat([
                  printAttributes(attrs),
                  Doc.concat([
                    Doc.text("#"),
                    printIdentLike(~allowUident=true, txt),
                  ]),
                  cases,
                ]),
              );
            }
          | Rinherit(coreType) => printTypExpr(coreType, cmtTbl)
        );

        let docs = List.map(printRowField, rowFields);
        let cases =
          Doc.join(~sep=Doc.concat([Doc.line, Doc.text("| ")]), docs);
        let cases =
          if (docs == []) {
            cases;
          } else {
            Doc.concat([Doc.text("| "), cases]);
          };
        let openingSymbol =
          if (closedFlag == Open) {
            Doc.greaterThan;
          } else if (labelsOpt == None) {
            Doc.nil;
          } else {
            Doc.lessThan;
          };
        let hasLabels = labelsOpt != None && labelsOpt != Some([]);
        let labels =
          switch (labelsOpt) {
          | None
          | Some([]) => Doc.nil
          | Some(labels) =>
            Doc.concat(
              List.map(
                label =>
                  Doc.concat([
                    Doc.line,
                    Doc.text("#"),
                    printIdentLike(~allowUident=true, label),
                  ]),
                labels,
              ),
            )
          };

        let closingSymbol =
          if (hasLabels) {
            Doc.text(" >");
          } else {
            Doc.nil;
          };
        Doc.group(
          Doc.concat([
            Doc.lbracket,
            openingSymbol,
            Doc.line,
            cases,
            closingSymbol,
            labels,
            Doc.line,
            Doc.rbracket,
          ]),
        );
      };

    let shouldPrintItsOwnAttributes =
      switch (typExpr.ptyp_desc) {
      | Ptyp_arrow(_) /* es6 arrow types print their own attributes */
      | [@implicit_arity]
        Ptyp_constr(
          {
            txt: [@implicit_arity] Longident.Ldot(Longident.Lident("Js"), "t"),
          },
          _,
        ) =>
        true
      | _ => false
      };

    let doc =
      switch (typExpr.ptyp_attributes) {
      | [_, ..._] as attrs when !shouldPrintItsOwnAttributes =>
        Doc.group(Doc.concat([printAttributes(attrs), renderedType]))
      | _ => renderedType
      };

    printComments(doc, cmtTbl, typExpr.ptyp_loc);
  }

  and printBsObjectSugar = (~inline, fields, openFlag, cmtTbl) => {
    let doc =
      switch (fields) {
      | [] =>
        Doc.concat([
          Doc.lbrace,
          switch (openFlag) {
          | Asttypes.Closed => Doc.dot
          | Open => Doc.dotdot
          },
          Doc.rbrace,
        ])
      | fields =>
        Doc.concat([
          Doc.lbrace,
          switch (openFlag) {
          | Asttypes.Closed => Doc.nil
          | Open => Doc.dotdot
          },
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(field => printObjectField(field, cmtTbl), fields),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.rbrace,
        ])
      };

    if (inline) {
      doc;
    } else {
      Doc.group(doc);
    };
  }

  and printTupleType = (~inline, types: list(Parsetree.core_type), cmtTbl) => {
    let tuple =
      Doc.concat([
        Doc.lparen,
        Doc.indent(
          Doc.concat([
            Doc.softLine,
            Doc.join(
              ~sep=Doc.concat([Doc.comma, Doc.line]),
              List.map(typexpr => printTypExpr(typexpr, cmtTbl), types),
            ),
          ]),
        ),
        Doc.trailingComma,
        Doc.softLine,
        Doc.rparen,
      ]);

    if (inline === false) {
      Doc.group(tuple);
    } else {
      tuple;
    };
  }

  and printObjectField = (field: Parsetree.object_field, cmtTbl) =>
    switch (field) {
    | [@implicit_arity] Otag(labelLoc, attrs, typ) =>
      let lbl = {
        let doc = Doc.text("\"" ++ labelLoc.txt ++ "\"");
        printComments(doc, cmtTbl, labelLoc.loc);
      };

      let doc =
        Doc.concat([
          printAttributes(~loc=labelLoc.loc, attrs),
          lbl,
          Doc.text(": "),
          printTypExpr(typ, cmtTbl),
        ]);
      let cmtLoc = {...labelLoc.loc, loc_end: typ.ptyp_loc.loc_end};
      printComments(doc, cmtTbl, cmtLoc);
    | _ => Doc.nil
    }

  /* es6 arrow type arg
   * type t = (~foo: string, ~bar: float=?, unit) => unit
   * i.e. ~foo: string, ~bar: float */
  and printTypeParameter = ((attrs, lbl, typ), cmtTbl) => {
    let (isUncurried, attrs) =
      ParsetreeViewer.processUncurriedAttribute(attrs);
    let uncurried =
      if (isUncurried) {
        Doc.concat([Doc.dot, Doc.space]);
      } else {
        Doc.nil;
      };
    let attrs =
      switch (attrs) {
      | [] => Doc.nil
      | attrs =>
        Doc.concat([
          Doc.join(~sep=Doc.line, List.map(printAttribute, attrs)),
          Doc.line,
        ])
      };
    let label =
      switch (lbl) {
      | Asttypes.Nolabel => Doc.nil
      | Labelled(lbl) =>
        Doc.concat([Doc.text("~"), printIdentLike(lbl), Doc.text(": ")])
      | Optional(lbl) =>
        Doc.concat([Doc.text("~"), printIdentLike(lbl), Doc.text(": ")])
      };

    let optionalIndicator =
      switch (lbl) {
      | Asttypes.Nolabel
      | Labelled(_) => Doc.nil
      | Optional(_lbl) => Doc.text("=?")
      };

    let doc =
      Doc.group(
        Doc.concat([
          uncurried,
          attrs,
          label,
          printTypExpr(typ, cmtTbl),
          optionalIndicator,
        ]),
      );
    printComments(doc, cmtTbl, typ.ptyp_loc);
  }

  and printValueBinding = (~recFlag, vb, cmtTbl, i) => {
    let (hasGenType, attrs) =
      ParsetreeViewer.splitGenTypeAttr(vb.pvb_attributes);
    let attrs = printAttributes(~loc=vb.pvb_pat.ppat_loc, attrs);
    let header =
      if (i === 0) {
        Doc.concat([
          if (hasGenType) {
            Doc.text("export ");
          } else {
            Doc.text("let ");
          },
          recFlag,
        ]);
      } else {
        Doc.concat([
          Doc.text("and "),
          if (hasGenType) {
            Doc.text("export ");
          } else {
            Doc.nil;
          },
        ]);
      };

    switch (vb) {
    | {
        pvb_pat: {
          ppat_desc:
            [@implicit_arity]
            Ppat_constraint(pattern, {ptyp_desc: Ptyp_poly(_)}),
        },
        pvb_expr: {pexp_desc: Pexp_newtype(_)} as expr,
      } =>
      let (_attrs, parameters, returnExpr) = ParsetreeViewer.funExpr(expr);
      let abstractType =
        switch (parameters) {
        | [NewTypes({locs: vars})] =>
          Doc.concat([
            Doc.text("type "),
            Doc.join(
              ~sep=Doc.space,
              List.map(var => Doc.text(var.Asttypes.txt), vars),
            ),
            Doc.dot,
          ])
        | _ => Doc.nil
        };

      switch (returnExpr.pexp_desc) {
      | [@implicit_arity] Pexp_constraint(expr, typ) =>
        Doc.group(
          Doc.concat([
            attrs,
            header,
            printPattern(pattern, cmtTbl),
            Doc.text(":"),
            Doc.indent(
              Doc.concat([
                Doc.line,
                abstractType,
                Doc.space,
                printTypExpr(typ, cmtTbl),
                Doc.text(" ="),
                Doc.concat([
                  Doc.line,
                  printExpressionWithComments(expr, cmtTbl),
                ]),
              ]),
            ),
          ]),
        )
      | _ => Doc.nil
      };
    | _ =>
      let (optBraces, expr) = ParsetreeViewer.processBracesAttr(vb.pvb_expr);
      let printedExpr = {
        let doc = printExpressionWithComments(vb.pvb_expr, cmtTbl);
        switch (Parens.expr(vb.pvb_expr)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, expr, braces)
        | Nothing => doc
        };
      };

      if (ParsetreeViewer.isPipeExpr(vb.pvb_expr)) {
        Doc.customLayout([
          Doc.group(
            Doc.concat([
              attrs,
              header,
              printPattern(vb.pvb_pat, cmtTbl),
              Doc.text(" ="),
              Doc.space,
              printedExpr,
            ]),
          ),
          Doc.group(
            Doc.concat([
              attrs,
              header,
              printPattern(vb.pvb_pat, cmtTbl),
              Doc.text(" ="),
              Doc.indent(Doc.concat([Doc.line, printedExpr])),
            ]),
          ),
        ]);
      } else {
        let shouldIndent =
          switch (optBraces) {
          | Some(_) => false
          | _ =>
            ParsetreeViewer.isBinaryExpression(expr)
            || (
              switch (vb.pvb_expr) {
              | {
                  pexp_attributes: [({Location.txt: "ns.ternary"}, _)],
                  pexp_desc: [@implicit_arity] Pexp_ifthenelse(ifExpr, _, _),
                } =>
                ParsetreeViewer.isBinaryExpression(ifExpr)
                || ParsetreeViewer.hasAttributes(ifExpr.pexp_attributes)
              | {pexp_desc: Pexp_newtype(_)} => false
              | e =>
                ParsetreeViewer.hasAttributes(e.pexp_attributes)
                || ParsetreeViewer.isArrayAccess(e)
              }
            )
          };

        Doc.group(
          Doc.concat([
            attrs,
            header,
            printPattern(vb.pvb_pat, cmtTbl),
            Doc.text(" ="),
            if (shouldIndent) {
              Doc.indent(Doc.concat([Doc.line, printedExpr]));
            } else {
              Doc.concat([Doc.space, printedExpr]);
            },
          ]),
        );
      };
    };
  }

  and printPackageType =
      (
        ~printModuleKeywordAndParens,
        packageType: Parsetree.package_type,
        cmtTbl,
      ) => {
    let doc =
      switch (packageType) {
      | (longidentLoc, []) =>
        Doc.group(
          Doc.concat([printLongidentLocation(longidentLoc, cmtTbl)]),
        )
      | (longidentLoc, packageConstraints) =>
        Doc.group(
          Doc.concat([
            printLongidentLocation(longidentLoc, cmtTbl),
            printPackageConstraints(packageConstraints, cmtTbl),
            Doc.softLine,
          ]),
        )
      };

    if (printModuleKeywordAndParens) {
      Doc.concat([Doc.text("module("), doc, Doc.rparen]);
    } else {
      doc;
    };
  }

  and printPackageConstraints = (packageConstraints, cmtTbl) =>
    Doc.concat([
      Doc.text(" with"),
      Doc.indent(
        Doc.concat([
          Doc.line,
          Doc.join(
            ~sep=Doc.line,
            List.mapi(
              (i, pc) => {
                let (longident, typexpr) = pc;
                let cmtLoc = {
                  ...longident.Asttypes.loc,
                  loc_end: typexpr.Parsetree.ptyp_loc.loc_end,
                };
                let doc = printPackageConstraint(i, cmtTbl, pc);
                printComments(doc, cmtTbl, cmtLoc);
              },
              packageConstraints,
            ),
          ),
        ]),
      ),
    ])

  and printPackageConstraint = (i, cmtTbl, (longidentLoc, typ)) => {
    let prefix =
      if (i === 0) {
        Doc.text("type ");
      } else {
        Doc.text("and type ");
      };
    Doc.concat([
      prefix,
      printLongidentLocation(longidentLoc, cmtTbl),
      Doc.text(" = "),
      printTypExpr(typ, cmtTbl),
    ]);
  }

  and printExtensionWithComments =
      (~atModuleLvl, (stringLoc, payload), cmtTbl) => {
    let extName = {
      let doc =
        Doc.concat([
          Doc.text("%"),
          if (atModuleLvl) {
            Doc.text("%");
          } else {
            Doc.nil;
          },
          Doc.text(stringLoc.Location.txt),
        ]);
      printComments(doc, cmtTbl, stringLoc.Location.loc);
    };

    switch (payload) {
    | Parsetree.PStr([
        {pstr_desc: [@implicit_arity] Pstr_eval(expr, attrs)},
      ]) =>
      let exprDoc = printExpressionWithComments(expr, cmtTbl);
      let needsParens =
        switch (attrs) {
        | [] => false
        | _ => true
        };
      Doc.group(
        Doc.concat([
          extName,
          addParens(
            Doc.concat([
              printAttributes(attrs),
              if (needsParens) {
                addParens(exprDoc);
              } else {
                exprDoc;
              },
            ]),
          ),
        ]),
      );
    | _ => extName
    };
  }

  and printPattern = (p: Parsetree.pattern, cmtTbl) => {
    let patternWithoutAttributes =
      switch (p.ppat_desc) {
      | Ppat_any => Doc.text("_")
      | Ppat_var(var) => printIdentLike(var.txt)
      | Ppat_constant(c) => printConstant(c)
      | Ppat_tuple(patterns) =>
        Doc.group(
          Doc.concat([
            Doc.lparen,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.text(","), Doc.line]),
                  List.map(pat => printPattern(pat, cmtTbl), patterns),
                ),
              ]),
            ),
            Doc.trailingComma,
            Doc.softLine,
            Doc.rparen,
          ]),
        )
      | Ppat_array([]) =>
        Doc.concat([
          Doc.lbracket,
          printCommentsInside(cmtTbl, p.ppat_loc),
          Doc.rbracket,
        ])
      | Ppat_array(patterns) =>
        Doc.group(
          Doc.concat([
            Doc.text("["),
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.text(","), Doc.line]),
                  List.map(pat => printPattern(pat, cmtTbl), patterns),
                ),
              ]),
            ),
            Doc.trailingComma,
            Doc.softLine,
            Doc.text("]"),
          ]),
        )
      | [@implicit_arity] Ppat_construct({txt: Longident.Lident("()")}, _) =>
        Doc.concat([
          Doc.lparen,
          printCommentsInside(cmtTbl, p.ppat_loc),
          Doc.rparen,
        ])
      | [@implicit_arity] Ppat_construct({txt: Longident.Lident("[]")}, _) =>
        Doc.concat([
          Doc.text("list["),
          printCommentsInside(cmtTbl, p.ppat_loc),
          Doc.rbracket,
        ])
      | [@implicit_arity] Ppat_construct({txt: Longident.Lident("::")}, _) =>
        let (patterns, tail) =
          ParsetreeViewer.collectPatternsFromListConstruct([], p);
        let shouldHug =
          switch (patterns, tail) {
          | (
              [pat],
              {
                ppat_desc:
                  [@implicit_arity]
                  Ppat_construct({txt: Longident.Lident("[]")}, _),
              },
            )
              when ParsetreeViewer.isHuggablePattern(pat) =>
            true
          | _ => false
          };

        let children =
          Doc.concat([
            if (shouldHug) {Doc.nil} else {Doc.softLine},
            Doc.join(
              ~sep=Doc.concat([Doc.text(","), Doc.line]),
              List.map(pat => printPattern(pat, cmtTbl), patterns),
            ),
            switch (tail.Parsetree.ppat_desc) {
            | [@implicit_arity]
              Ppat_construct({txt: Longident.Lident("[]")}, _) => Doc.nil
            | _ =>
              let doc =
                Doc.concat([Doc.text("..."), printPattern(tail, cmtTbl)]);
              let tail = printComments(doc, cmtTbl, tail.ppat_loc);
              Doc.concat([Doc.text(","), Doc.line, tail]);
            },
          ]);
        Doc.group(
          Doc.concat([
            Doc.text("list["),
            if (shouldHug) {
              children;
            } else {
              Doc.concat([
                Doc.indent(children),
                Doc.ifBreaks(Doc.text(","), Doc.nil),
                Doc.softLine,
              ]);
            },
            Doc.rbracket,
          ]),
        );
      | [@implicit_arity] Ppat_construct(constrName, constructorArgs) =>
        let constrName = printLongident(constrName.txt);
        let argsDoc =
          switch (constructorArgs) {
          | None => Doc.nil
          | Some({
              ppat_loc,
              ppat_desc:
                [@implicit_arity]
                Ppat_construct({txt: Longident.Lident("()")}, _),
            }) =>
            Doc.concat([
              Doc.lparen,
              printCommentsInside(cmtTbl, ppat_loc),
              Doc.rparen,
            ])
          | Some({ppat_desc: Ppat_tuple([]), ppat_loc: loc}) =>
            Doc.concat([
              Doc.lparen,
              Doc.softLine,
              printCommentsInside(cmtTbl, loc),
              Doc.rparen,
            ])
          /* Some((1, 2) */
          | Some({
              ppat_desc: Ppat_tuple([{ppat_desc: Ppat_tuple(_)} as arg]),
            }) =>
            Doc.concat([Doc.lparen, printPattern(arg, cmtTbl), Doc.rparen])
          | Some({ppat_desc: Ppat_tuple(patterns)}) =>
            Doc.concat([
              Doc.lparen,
              Doc.indent(
                Doc.concat([
                  Doc.softLine,
                  Doc.join(
                    ~sep=Doc.concat([Doc.comma, Doc.line]),
                    List.map(pat => printPattern(pat, cmtTbl), patterns),
                  ),
                ]),
              ),
              Doc.trailingComma,
              Doc.softLine,
              Doc.rparen,
            ])
          | Some(arg) =>
            let argDoc = printPattern(arg, cmtTbl);
            let shouldHug = ParsetreeViewer.isHuggablePattern(arg);
            Doc.concat([
              Doc.lparen,
              if (shouldHug) {
                argDoc;
              } else {
                Doc.concat([
                  Doc.indent(Doc.concat([Doc.softLine, argDoc])),
                  Doc.trailingComma,
                  Doc.softLine,
                ]);
              },
              Doc.rparen,
            ]);
          };

        Doc.group(Doc.concat([constrName, argsDoc]));
      | [@implicit_arity] Ppat_variant(label, None) =>
        Doc.concat([
          Doc.text("#"),
          printIdentLike(~allowUident=true, label),
        ])
      | [@implicit_arity] Ppat_variant(label, variantArgs) =>
        let variantName =
          Doc.concat([
            Doc.text("#"),
            printIdentLike(~allowUident=true, label),
          ]);
        let argsDoc =
          switch (variantArgs) {
          | None => Doc.nil
          | Some({
              ppat_desc:
                [@implicit_arity]
                Ppat_construct({txt: Longident.Lident("()")}, _),
            }) =>
            Doc.text("()")
          | Some({ppat_desc: Ppat_tuple([]), ppat_loc: loc}) =>
            Doc.concat([
              Doc.lparen,
              Doc.softLine,
              printCommentsInside(cmtTbl, loc),
              Doc.rparen,
            ])
          /* Some((1, 2) */
          | Some({
              ppat_desc: Ppat_tuple([{ppat_desc: Ppat_tuple(_)} as arg]),
            }) =>
            Doc.concat([Doc.lparen, printPattern(arg, cmtTbl), Doc.rparen])
          | Some({ppat_desc: Ppat_tuple(patterns)}) =>
            Doc.concat([
              Doc.lparen,
              Doc.indent(
                Doc.concat([
                  Doc.softLine,
                  Doc.join(
                    ~sep=Doc.concat([Doc.comma, Doc.line]),
                    List.map(pat => printPattern(pat, cmtTbl), patterns),
                  ),
                ]),
              ),
              Doc.trailingComma,
              Doc.softLine,
              Doc.rparen,
            ])
          | Some(arg) =>
            let argDoc = printPattern(arg, cmtTbl);
            let shouldHug = ParsetreeViewer.isHuggablePattern(arg);
            Doc.concat([
              Doc.lparen,
              if (shouldHug) {
                argDoc;
              } else {
                Doc.concat([
                  Doc.indent(Doc.concat([Doc.softLine, argDoc])),
                  Doc.trailingComma,
                  Doc.softLine,
                ]);
              },
              Doc.rparen,
            ]);
          };

        Doc.group(Doc.concat([variantName, argsDoc]));
      | Ppat_type(ident) =>
        Doc.concat([Doc.text("##"), printIdentPath(ident, cmtTbl)])
      | [@implicit_arity] Ppat_record(rows, openFlag) =>
        Doc.group(
          Doc.concat([
            Doc.lbrace,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.text(","), Doc.line]),
                  List.map(row => printPatternRecordRow(row, cmtTbl), rows),
                ),
                switch (openFlag) {
                | Open =>
                  Doc.concat([Doc.text(","), Doc.line, Doc.text("_")])
                | Closed => Doc.nil
                },
              ]),
            ),
            Doc.ifBreaks(Doc.text(","), Doc.nil),
            Doc.softLine,
            Doc.rbrace,
          ]),
        )

      | Ppat_exception(p) =>
        let needsParens =
          switch (p.ppat_desc) {
          | [@implicit_arity] Ppat_or(_, _)
          | [@implicit_arity] Ppat_alias(_, _) => true
          | _ => false
          };

        let pat = {
          let p = printPattern(p, cmtTbl);
          if (needsParens) {
            Doc.concat([Doc.text("("), p, Doc.text(")")]);
          } else {
            p;
          };
        };

        Doc.group(Doc.concat([Doc.text("exception"), Doc.line, pat]));
      | Ppat_or(_) =>
        /* Blue | Red | Green -> [Blue; Red; Green] */
        let orChain = ParsetreeViewer.collectOrPatternChain(p);
        let docs =
          List.mapi(
            (i, pat) => {
              let patternDoc = printPattern(pat, cmtTbl);
              Doc.concat([
                if (i === 0) {
                  Doc.nil;
                } else {
                  Doc.concat([Doc.line, Doc.text("| ")]);
                },
                switch (pat.ppat_desc) {
                /* (Blue | Red) | (Green | Black) | White */
                | Ppat_or(_) => addParens(patternDoc)
                | _ => patternDoc
                },
              ]);
            },
            orChain,
          );
        Doc.group(Doc.concat(docs));
      | Ppat_extension(ext) =>
        printExtensionWithComments(~atModuleLvl=false, ext, cmtTbl)
      | Ppat_lazy(p) =>
        let needsParens =
          switch (p.ppat_desc) {
          | [@implicit_arity] Ppat_or(_, _)
          | [@implicit_arity] Ppat_alias(_, _) => true
          | _ => false
          };

        let pat = {
          let p = printPattern(p, cmtTbl);
          if (needsParens) {
            Doc.concat([Doc.text("("), p, Doc.text(")")]);
          } else {
            p;
          };
        };

        Doc.concat([Doc.text("lazy "), pat]);
      | [@implicit_arity] Ppat_alias(p, aliasLoc) =>
        let needsParens =
          switch (p.ppat_desc) {
          | [@implicit_arity] Ppat_or(_, _)
          | [@implicit_arity] Ppat_alias(_, _) => true
          | _ => false
          };

        let renderedPattern = {
          let p = printPattern(p, cmtTbl);
          if (needsParens) {
            Doc.concat([Doc.text("("), p, Doc.text(")")]);
          } else {
            p;
          };
        };

        Doc.concat([
          renderedPattern,
          Doc.text(" as "),
          printStringLoc(aliasLoc, cmtTbl),
        ]);

      /* Note: module(P : S) is represented as */
      /* Ppat_constraint(Ppat_unpack, Ptyp_package) */
      | [@implicit_arity]
        Ppat_constraint(
          {ppat_desc: Ppat_unpack(stringLoc)},
          {ptyp_desc: Ptyp_package(packageType), ptyp_loc},
        ) =>
        Doc.concat([
          Doc.text("module("),
          printComments(Doc.text(stringLoc.txt), cmtTbl, stringLoc.loc),
          Doc.text(": "),
          printComments(
            printPackageType(
              ~printModuleKeywordAndParens=false,
              packageType,
              cmtTbl,
            ),
            cmtTbl,
            ptyp_loc,
          ),
          Doc.rparen,
        ])
      | [@implicit_arity] Ppat_constraint(pattern, typ) =>
        Doc.concat([
          printPattern(pattern, cmtTbl),
          Doc.text(": "),
          printTypExpr(typ, cmtTbl),
        ])

      /* Note: module(P : S) is represented as */
      /* Ppat_constraint(Ppat_unpack, Ptyp_package) */
      | Ppat_unpack(stringLoc) =>
        Doc.concat([
          Doc.text("module("),
          printComments(Doc.text(stringLoc.txt), cmtTbl, stringLoc.loc),
          Doc.rparen,
        ])
      | [@implicit_arity] Ppat_interval(a, b) =>
        Doc.concat([printConstant(a), Doc.text(" .. "), printConstant(b)])
      | Ppat_open(_) => Doc.nil
      };

    let doc =
      switch (p.ppat_attributes) {
      | [] => patternWithoutAttributes
      | attrs =>
        Doc.group(
          Doc.concat([printAttributes(attrs), patternWithoutAttributes]),
        )
      };

    printComments(doc, cmtTbl, p.ppat_loc);
  }

  and printPatternRecordRow = (row, cmtTbl) =>
    switch (row) {
    /* punned {x}*/
    | (
        {Location.txt: Longident.Lident(ident)} as longident,
        {Parsetree.ppat_desc: Ppat_var({txt, _})},
      )
        when ident == txt =>
      printLidentPath(longident, cmtTbl)
    | (longident, pattern) =>
      let locForComments = {
        ...longident.loc,
        loc_end: pattern.Parsetree.ppat_loc.loc_end,
      };
      let doc =
        Doc.group(
          Doc.concat([
            printLidentPath(longident, cmtTbl),
            Doc.text(": "),
            Doc.indent(
              Doc.concat([Doc.softLine, printPattern(pattern, cmtTbl)]),
            ),
          ]),
        );
      printComments(doc, cmtTbl, locForComments);
    }

  and printExpressionWithComments = (expr, cmtTbl) => {
    let doc = printExpression(expr, cmtTbl);
    printComments(doc, cmtTbl, expr.Parsetree.pexp_loc);
  }

  and printExpression = (e: Parsetree.expression, cmtTbl) => {
    let printedExpression =
      switch (e.pexp_desc) {
      | Parsetree.Pexp_constant(c) => printConstant(c)
      | Pexp_construct(_)
          when ParsetreeViewer.hasJsxAttribute(e.pexp_attributes) =>
        printJsxFragment(e, cmtTbl)
      | [@implicit_arity] Pexp_construct({txt: Longident.Lident("()")}, _) =>
        Doc.text("()")
      | [@implicit_arity] Pexp_construct({txt: Longident.Lident("[]")}, _) =>
        Doc.concat([
          Doc.text("list["),
          printCommentsInside(cmtTbl, e.pexp_loc),
          Doc.rbracket,
        ])
      | [@implicit_arity] Pexp_construct({txt: Longident.Lident("::")}, _) =>
        let (expressions, spread) =
          ParsetreeViewer.collectListExpressions(e);
        let spreadDoc =
          switch (spread) {
          | Some(expr) =>
            Doc.concat([
              Doc.text(","),
              Doc.line,
              Doc.dotdotdot,
              {
                let doc = printExpressionWithComments(expr, cmtTbl);
                switch (Parens.expr(expr)) {
                | Parens.Parenthesized => addParens(doc)
                | Braced(braces) => printBraces(doc, expr, braces)
                | Nothing => doc
                };
              },
            ])
          | None => Doc.nil
          };

        Doc.group(
          Doc.concat([
            Doc.text("list["),
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.text(","), Doc.line]),
                  List.map(
                    expr => {
                      let doc = printExpressionWithComments(expr, cmtTbl);
                      switch (Parens.expr(expr)) {
                      | Parens.Parenthesized => addParens(doc)
                      | Braced(braces) => printBraces(doc, expr, braces)
                      | Nothing => doc
                      };
                    },
                    expressions,
                  ),
                ),
                spreadDoc,
              ]),
            ),
            Doc.trailingComma,
            Doc.softLine,
            Doc.rbracket,
          ]),
        );
      | [@implicit_arity] Pexp_construct(longidentLoc, args) =>
        let constr = printLongidentLocation(longidentLoc, cmtTbl);
        let args =
          switch (args) {
          | None => Doc.nil
          | Some({
              pexp_desc:
                [@implicit_arity]
                Pexp_construct({txt: Longident.Lident("()")}, _),
            }) =>
            Doc.text("()")
          /* Some((1, 2)) */
          | Some({
              pexp_desc: Pexp_tuple([{pexp_desc: Pexp_tuple(_)} as arg]),
            }) =>
            Doc.concat([
              Doc.lparen,
              {
                let doc = printExpressionWithComments(arg, cmtTbl);
                switch (Parens.expr(arg)) {
                | Parens.Parenthesized => addParens(doc)
                | Braced(braces) => printBraces(doc, arg, braces)
                | Nothing => doc
                };
              },
              Doc.rparen,
            ])
          | Some({pexp_desc: Pexp_tuple(args)}) =>
            Doc.concat([
              Doc.lparen,
              Doc.indent(
                Doc.concat([
                  Doc.softLine,
                  Doc.join(
                    ~sep=Doc.concat([Doc.comma, Doc.line]),
                    List.map(
                      expr => {
                        let doc = printExpressionWithComments(expr, cmtTbl);
                        switch (Parens.expr(expr)) {
                        | Parens.Parenthesized => addParens(doc)
                        | Braced(braces) => printBraces(doc, expr, braces)
                        | Nothing => doc
                        };
                      },
                      args,
                    ),
                  ),
                ]),
              ),
              Doc.trailingComma,
              Doc.softLine,
              Doc.rparen,
            ])
          | Some(arg) =>
            let argDoc = {
              let doc = printExpressionWithComments(arg, cmtTbl);
              switch (Parens.expr(arg)) {
              | Parens.Parenthesized => addParens(doc)
              | Braced(braces) => printBraces(doc, arg, braces)
              | Nothing => doc
              };
            };

            let shouldHug = ParsetreeViewer.isHuggableExpression(arg);
            Doc.concat([
              Doc.lparen,
              if (shouldHug) {
                argDoc;
              } else {
                Doc.concat([
                  Doc.indent(Doc.concat([Doc.softLine, argDoc])),
                  Doc.trailingComma,
                  Doc.softLine,
                ]);
              },
              Doc.rparen,
            ]);
          };

        Doc.group(Doc.concat([constr, args]));
      | Pexp_ident(path) => printLidentPath(path, cmtTbl)
      | Pexp_tuple(exprs) =>
        Doc.group(
          Doc.concat([
            Doc.lparen,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.text(","), Doc.line]),
                  List.map(
                    expr => {
                      let doc = printExpressionWithComments(expr, cmtTbl);
                      switch (Parens.expr(expr)) {
                      | Parens.Parenthesized => addParens(doc)
                      | Braced(braces) => printBraces(doc, expr, braces)
                      | Nothing => doc
                      };
                    },
                    exprs,
                  ),
                ),
              ]),
            ),
            Doc.ifBreaks(Doc.text(","), Doc.nil),
            Doc.softLine,
            Doc.rparen,
          ]),
        )
      | Pexp_array([]) =>
        Doc.concat([
          Doc.lbracket,
          printCommentsInside(cmtTbl, e.pexp_loc),
          Doc.rbracket,
        ])
      | Pexp_array(exprs) =>
        Doc.group(
          Doc.concat([
            Doc.lbracket,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.text(","), Doc.line]),
                  List.map(
                    expr => {
                      let doc = printExpressionWithComments(expr, cmtTbl);
                      switch (Parens.expr(expr)) {
                      | Parens.Parenthesized => addParens(doc)
                      | Braced(braces) => printBraces(doc, expr, braces)
                      | Nothing => doc
                      };
                    },
                    exprs,
                  ),
                ),
              ]),
            ),
            Doc.trailingComma,
            Doc.softLine,
            Doc.rbracket,
          ]),
        )
      | [@implicit_arity] Pexp_variant(label, args) =>
        let variantName =
          Doc.concat([
            Doc.text("#"),
            printIdentLike(~allowUident=true, label),
          ]);
        let args =
          switch (args) {
          | None => Doc.nil
          | Some({
              pexp_desc:
                [@implicit_arity]
                Pexp_construct({txt: Longident.Lident("()")}, _),
            }) =>
            Doc.text("()")
          /* #poly((1, 2) */
          | Some({
              pexp_desc: Pexp_tuple([{pexp_desc: Pexp_tuple(_)} as arg]),
            }) =>
            Doc.concat([
              Doc.lparen,
              {
                let doc = printExpressionWithComments(arg, cmtTbl);
                switch (Parens.expr(arg)) {
                | Parens.Parenthesized => addParens(doc)
                | Braced(braces) => printBraces(doc, arg, braces)
                | Nothing => doc
                };
              },
              Doc.rparen,
            ])
          | Some({pexp_desc: Pexp_tuple(args)}) =>
            Doc.concat([
              Doc.lparen,
              Doc.indent(
                Doc.concat([
                  Doc.softLine,
                  Doc.join(
                    ~sep=Doc.concat([Doc.comma, Doc.line]),
                    List.map(
                      expr => {
                        let doc = printExpressionWithComments(expr, cmtTbl);
                        switch (Parens.expr(expr)) {
                        | Parens.Parenthesized => addParens(doc)
                        | Braced(braces) => printBraces(doc, expr, braces)
                        | Nothing => doc
                        };
                      },
                      args,
                    ),
                  ),
                ]),
              ),
              Doc.trailingComma,
              Doc.softLine,
              Doc.rparen,
            ])
          | Some(arg) =>
            let argDoc = {
              let doc = printExpressionWithComments(arg, cmtTbl);
              switch (Parens.expr(arg)) {
              | Parens.Parenthesized => addParens(doc)
              | Braced(braces) => printBraces(doc, arg, braces)
              | Nothing => doc
              };
            };

            let shouldHug = ParsetreeViewer.isHuggableExpression(arg);
            Doc.concat([
              Doc.lparen,
              if (shouldHug) {
                argDoc;
              } else {
                Doc.concat([
                  Doc.indent(Doc.concat([Doc.softLine, argDoc])),
                  Doc.trailingComma,
                  Doc.softLine,
                ]);
              },
              Doc.rparen,
            ]);
          };

        Doc.group(Doc.concat([variantName, args]));
      | [@implicit_arity] Pexp_record(rows, spreadExpr) =>
        let spread =
          switch (spreadExpr) {
          | None => Doc.nil
          | Some(expr) =>
            Doc.concat([
              Doc.dotdotdot,
              {
                let doc = printExpressionWithComments(expr, cmtTbl);
                switch (Parens.expr(expr)) {
                | Parens.Parenthesized => addParens(doc)
                | Braced(braces) => printBraces(doc, expr, braces)
                | Nothing => doc
                };
              },
              Doc.comma,
              Doc.line,
            ])
          };

        /* 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 forceBreak =
          e.pexp_loc.loc_start.pos_lnum < e.pexp_loc.loc_end.pos_lnum;

        Doc.breakableGroup(
          ~forceBreak,
          Doc.concat([
            Doc.lbrace,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                spread,
                Doc.join(
                  ~sep=Doc.concat([Doc.text(","), Doc.line]),
                  List.map(row => printRecordRow(row, cmtTbl), rows),
                ),
              ]),
            ),
            Doc.trailingComma,
            Doc.softLine,
            Doc.rbrace,
          ]),
        );
      | Pexp_extension(extension) =>
        switch (extension) {
        | (
            {txt: "bs.obj"},
            PStr([
              {
                pstr_loc: loc,
                pstr_desc:
                  [@implicit_arity]
                  Pstr_eval(
                    {pexp_desc: [@implicit_arity] Pexp_record(rows, _)},
                    [],
                  ),
              },
            ]),
          ) =>
          /* 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 forceBreak = loc.loc_start.pos_lnum < loc.loc_end.pos_lnum;

          Doc.breakableGroup(
            ~forceBreak,
            Doc.concat([
              Doc.lbrace,
              Doc.indent(
                Doc.concat([
                  Doc.softLine,
                  Doc.join(
                    ~sep=Doc.concat([Doc.text(","), Doc.line]),
                    List.map(row => printBsObjectRow(row, cmtTbl), rows),
                  ),
                ]),
              ),
              Doc.trailingComma,
              Doc.softLine,
              Doc.rbrace,
            ]),
          );
        | extension =>
          printExtensionWithComments(~atModuleLvl=false, extension, cmtTbl)
        }
      | Pexp_apply(_) =>
        if (ParsetreeViewer.isUnaryExpression(e)) {
          printUnaryExpression(e, cmtTbl);
        } else if (ParsetreeViewer.isTemplateLiteral(e)) {
          printTemplateLiteral(e, cmtTbl);
        } else if (ParsetreeViewer.isBinaryExpression(e)) {
          printBinaryExpression(e, cmtTbl);
        } else {
          printPexpApply(e, cmtTbl);
        }
      | Pexp_unreachable => Doc.dot
      | [@implicit_arity] Pexp_field(expr, longidentLoc) =>
        let lhs = {
          let doc = printExpressionWithComments(expr, cmtTbl);
          switch (Parens.fieldExpr(expr)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, expr, braces)
          | Nothing => doc
          };
        };

        Doc.concat([lhs, Doc.dot, printLidentPath(longidentLoc, cmtTbl)]);
      | [@implicit_arity] Pexp_setfield(expr1, longidentLoc, expr2) =>
        printSetFieldExpr(
          e.pexp_attributes,
          expr1,
          longidentLoc,
          expr2,
          e.pexp_loc,
          cmtTbl,
        )
      | [@implicit_arity] Pexp_ifthenelse(_ifExpr, _thenExpr, _elseExpr) =>
        if (ParsetreeViewer.isTernaryExpr(e)) {
          let (parts, alternate) = ParsetreeViewer.collectTernaryParts(e);
          let ternaryDoc =
            switch (parts) {
            | [(condition1, consequent1), ...rest] =>
              Doc.group(
                Doc.concat([
                  printTernaryOperand(condition1, cmtTbl),
                  Doc.indent(
                    Doc.concat([
                      Doc.line,
                      Doc.indent(
                        Doc.concat([
                          Doc.text("? "),
                          printTernaryOperand(consequent1, cmtTbl),
                        ]),
                      ),
                      Doc.concat(
                        List.map(
                          ((condition, consequent)) =>
                            Doc.concat([
                              Doc.line,
                              Doc.text(": "),
                              printTernaryOperand(condition, cmtTbl),
                              Doc.line,
                              Doc.text("? "),
                              printTernaryOperand(consequent, cmtTbl),
                            ]),
                          rest,
                        ),
                      ),
                      Doc.line,
                      Doc.text(": "),
                      Doc.indent(printTernaryOperand(alternate, cmtTbl)),
                    ]),
                  ),
                ]),
              )
            | _ => Doc.nil
            };

          let attrs =
            ParsetreeViewer.filterTernaryAttributes(e.pexp_attributes);
          let needsParens =
            switch (ParsetreeViewer.filterParsingAttrs(attrs)) {
            | [] => false
            | _ => true
            };

          Doc.concat([
            printAttributes(attrs),
            if (needsParens) {
              addParens(ternaryDoc);
            } else {
              ternaryDoc;
            },
          ]);
        } else {
          let (ifs, elseExpr) = ParsetreeViewer.collectIfExpressions(e);
          let ifDocs =
            Doc.join(
              ~sep=Doc.space,
              List.mapi(
                (i, (ifExpr, thenExpr)) => {
                  let ifTxt =
                    if (i > 0) {
                      Doc.text("else if ");
                    } else {
                      Doc.text("if ");
                    };
                  let condition =
                    if (ParsetreeViewer.isBlockExpr(ifExpr)) {
                      printExpressionBlock(~braces=true, ifExpr, cmtTbl);
                    } else {
                      let doc = printExpressionWithComments(ifExpr, cmtTbl);
                      switch (Parens.expr(ifExpr)) {
                      | Parens.Parenthesized => addParens(doc)
                      | Braced(braces) => printBraces(doc, ifExpr, braces)
                      | Nothing => Doc.ifBreaks(addParens(doc), doc)
                      };
                    };

                  Doc.concat([
                    ifTxt,
                    Doc.group(condition),
                    Doc.space,
                    {
                      let thenExpr =
                        switch (ParsetreeViewer.processBracesAttr(thenExpr)) {
                        /* This case only happens when coming from Reason, we strip braces */
                        | (Some(_), expr) => expr
                        | _ => thenExpr
                        };

                      printExpressionBlock(~braces=true, thenExpr, cmtTbl);
                    },
                  ]);
                },
                ifs,
              ),
            );
          let elseDoc =
            switch (elseExpr) {
            | None => Doc.nil
            | Some(expr) =>
              Doc.concat([
                Doc.text(" else "),
                printExpressionBlock(~braces=true, expr, cmtTbl),
              ])
            };

          Doc.concat([printAttributes(e.pexp_attributes), ifDocs, elseDoc]);
        }
      | [@implicit_arity] Pexp_while(expr1, expr2) =>
        let condition = {
          let doc = printExpressionWithComments(expr1, cmtTbl);
          switch (Parens.expr(expr1)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, expr1, braces)
          | Nothing => doc
          };
        };

        Doc.breakableGroup(
          ~forceBreak=true,
          Doc.concat([
            Doc.text("while "),
            if (ParsetreeViewer.isBlockExpr(expr1)) {
              condition;
            } else {
              Doc.group(Doc.ifBreaks(addParens(condition), condition));
            },
            Doc.space,
            printExpressionBlock(~braces=true, expr2, cmtTbl),
          ]),
        );
      | [@implicit_arity]
        Pexp_for(pattern, fromExpr, toExpr, directionFlag, body) =>
        Doc.breakableGroup(
          ~forceBreak=true,
          Doc.concat([
            Doc.text("for "),
            printPattern(pattern, cmtTbl),
            Doc.text(" in "),
            {
              let doc = printExpressionWithComments(fromExpr, cmtTbl);
              switch (Parens.expr(fromExpr)) {
              | Parens.Parenthesized => addParens(doc)
              | Braced(braces) => printBraces(doc, fromExpr, braces)
              | Nothing => doc
              };
            },
            printDirectionFlag(directionFlag),
            {
              let doc = printExpressionWithComments(toExpr, cmtTbl);
              switch (Parens.expr(toExpr)) {
              | Parens.Parenthesized => addParens(doc)
              | Braced(braces) => printBraces(doc, toExpr, braces)
              | Nothing => doc
              };
            },
            Doc.space,
            printExpressionBlock(~braces=true, body, cmtTbl),
          ]),
        )
      | [@implicit_arity]
        Pexp_constraint(
          {pexp_desc: Pexp_pack(modExpr)},
          {ptyp_desc: Ptyp_package(packageType), ptyp_loc},
        ) =>
        Doc.group(
          Doc.concat([
            Doc.text("module("),
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                printModExpr(modExpr, cmtTbl),
                Doc.text(": "),
                printComments(
                  printPackageType(
                    ~printModuleKeywordAndParens=false,
                    packageType,
                    cmtTbl,
                  ),
                  cmtTbl,
                  ptyp_loc,
                ),
              ]),
            ),
            Doc.softLine,
            Doc.rparen,
          ]),
        )

      | [@implicit_arity] Pexp_constraint(expr, typ) =>
        let exprDoc = {
          let doc = printExpressionWithComments(expr, cmtTbl);
          switch (Parens.expr(expr)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, expr, braces)
          | Nothing => doc
          };
        };

        Doc.concat([exprDoc, Doc.text(": "), printTypExpr(typ, cmtTbl)]);
      | [@implicit_arity] Pexp_letmodule({txt: _modName}, _modExpr, _expr) =>
        printExpressionBlock(~braces=true, e, cmtTbl)
      | [@implicit_arity] Pexp_letexception(_extensionConstructor, _expr) =>
        printExpressionBlock(~braces=true, e, cmtTbl)
      | Pexp_assert(expr) =>
        let rhs = {
          let doc = printExpressionWithComments(expr, cmtTbl);
          switch (Parens.lazyOrAssertExprRhs(expr)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, expr, braces)
          | Nothing => doc
          };
        };

        Doc.concat([Doc.text("assert "), rhs]);
      | Pexp_lazy(expr) =>
        let rhs = {
          let doc = printExpressionWithComments(expr, cmtTbl);
          switch (Parens.lazyOrAssertExprRhs(expr)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, expr, braces)
          | Nothing => doc
          };
        };

        Doc.group(Doc.concat([Doc.text("lazy "), rhs]));
      | [@implicit_arity] Pexp_open(_overrideFlag, _longidentLoc, _expr) =>
        printExpressionBlock(~braces=true, e, cmtTbl)
      | Pexp_pack(modExpr) =>
        Doc.group(
          Doc.concat([
            Doc.text("module("),
            Doc.indent(
              Doc.concat([Doc.softLine, printModExpr(modExpr, cmtTbl)]),
            ),
            Doc.softLine,
            Doc.rparen,
          ]),
        )
      | Pexp_sequence(_) => printExpressionBlock(~braces=true, e, cmtTbl)
      | Pexp_let(_) => printExpressionBlock(~braces=true, e, cmtTbl)
      | [@implicit_arity]
        Pexp_fun(
          Nolabel,
          None,
          {ppat_desc: Ppat_var({txt: "__x"})},
          {pexp_desc: Pexp_apply(_)},
        ) =>
        /* (__x) => f(a, __x, c) -----> f(a, _, c)  */
        printExpressionWithComments(
          ParsetreeViewer.rewriteUnderscoreApply(e),
          cmtTbl,
        )
      | Pexp_fun(_)
      | Pexp_newtype(_) =>
        let (attrsOnArrow, parameters, returnExpr) =
          ParsetreeViewer.funExpr(e);
        let (uncurried, attrs) =
          ParsetreeViewer.processUncurriedAttribute(attrsOnArrow);

        let (returnExpr, typConstraint) =
          switch (returnExpr.pexp_desc) {
          | [@implicit_arity] Pexp_constraint(expr, typ) => (
              {
                ...expr,
                pexp_attributes:
                  List.concat([
                    expr.pexp_attributes,
                    returnExpr.pexp_attributes,
                  ]),
              },
              Some(typ),
            )
          | _ => (returnExpr, None)
          };

        let hasConstraint =
          switch (typConstraint) {
          | Some(_) => true
          | None => false
          };
        let parametersDoc =
          printExprFunParameters(
            ~inCallback=false,
            ~uncurried,
            ~hasConstraint,
            parameters,
            cmtTbl,
          );

        let returnExprDoc = {
          let (optBraces, _) = ParsetreeViewer.processBracesAttr(returnExpr);
          let shouldInline =
            switch (returnExpr.pexp_desc, optBraces) {
            | (_, Some(_)) => true
            | (
                Pexp_array(_) | Pexp_tuple(_) |
                [@implicit_arity] Pexp_construct(_, Some(_)) |
                Pexp_record(_),
                _,
              ) =>
              true
            | _ => false
            };

          let shouldIndent =
            switch (returnExpr.pexp_desc) {
            | Pexp_sequence(_)
            | Pexp_let(_)
            | Pexp_letmodule(_)
            | Pexp_letexception(_)
            | Pexp_open(_) => false
            | _ => true
            };

          let returnDoc = {
            let doc = printExpressionWithComments(returnExpr, cmtTbl);
            switch (Parens.expr(returnExpr)) {
            | Parens.Parenthesized => addParens(doc)
            | Braced(braces) => printBraces(doc, returnExpr, braces)
            | Nothing => doc
            };
          };

          if (shouldInline) {
            Doc.concat([Doc.space, returnDoc]);
          } else {
            Doc.group(
              if (shouldIndent) {
                Doc.indent(Doc.concat([Doc.line, returnDoc]));
              } else {
                Doc.concat([Doc.space, returnDoc]);
              },
            );
          };
        };

        let typConstraintDoc =
          switch (typConstraint) {
          | Some(typ) =>
            Doc.concat([Doc.text(": "), printTypExpr(typ, cmtTbl)])
          | _ => Doc.nil
          };

        let attrs = printAttributes(attrs);
        Doc.group(
          Doc.concat([
            attrs,
            parametersDoc,
            typConstraintDoc,
            Doc.text(" =>"),
            returnExprDoc,
          ]),
        );
      | [@implicit_arity] Pexp_try(expr, cases) =>
        let exprDoc = {
          let doc = printExpressionWithComments(expr, cmtTbl);
          switch (Parens.expr(expr)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, expr, braces)
          | Nothing => doc
          };
        };

        Doc.concat([
          Doc.text("try "),
          exprDoc,
          Doc.text(" catch "),
          printCases(cases, cmtTbl),
        ]);
      | [@implicit_arity] Pexp_match(expr, cases) =>
        let exprDoc = {
          let doc = printExpressionWithComments(expr, cmtTbl);
          switch (Parens.expr(expr)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, expr, braces)
          | Nothing => doc
          };
        };

        Doc.concat([
          Doc.text("switch "),
          exprDoc,
          Doc.space,
          printCases(cases, cmtTbl),
        ]);
      | Pexp_function(cases) =>
        Doc.concat([Doc.text("x => switch x "), printCases(cases, cmtTbl)])
      | [@implicit_arity] Pexp_coerce(expr, typOpt, typ) =>
        let docExpr = printExpressionWithComments(expr, cmtTbl);
        let docTyp = printTypExpr(typ, cmtTbl);
        let ofType =
          switch (typOpt) {
          | None => Doc.nil
          | Some(typ1) =>
            Doc.concat([Doc.text(": "), printTypExpr(typ1, cmtTbl)])
          };

        Doc.concat([
          Doc.lparen,
          docExpr,
          ofType,
          Doc.text(" :> "),
          docTyp,
          Doc.rparen,
        ]);
      | Pexp_send(_) => Doc.text("Pexp_send not impemented in printer")
      | Pexp_new(_) => Doc.text("Pexp_new not impemented in printer")
      | Pexp_setinstvar(_) =>
        Doc.text("Pexp_setinstvar not impemented in printer")
      | Pexp_override(_) =>
        Doc.text("Pexp_override not impemented in printer")
      | Pexp_poly(_) => Doc.text("Pexp_poly not impemented in printer")
      | Pexp_object(_) => Doc.text("Pexp_object not impemented in printer")
      };

    let shouldPrintItsOwnAttributes =
      switch (e.pexp_desc) {
      | Pexp_apply(_)
      | Pexp_fun(_)
      | Pexp_newtype(_)
      | Pexp_setfield(_)
      | Pexp_ifthenelse(_) => true
      | Pexp_construct(_)
          when ParsetreeViewer.hasJsxAttribute(e.pexp_attributes) =>
        true
      | _ => false
      };

    switch (e.pexp_attributes) {
    | [] => printedExpression
    | attrs when !shouldPrintItsOwnAttributes =>
      Doc.group(Doc.concat([printAttributes(attrs), printedExpression]))
    | _ => printedExpression
    };
  }

  and printPexpFun = (~inCallback, e, cmtTbl) => {
    let (attrsOnArrow, parameters, returnExpr) = ParsetreeViewer.funExpr(e);
    let (uncurried, attrs) =
      ParsetreeViewer.processUncurriedAttribute(attrsOnArrow);

    let (returnExpr, typConstraint) =
      switch (returnExpr.pexp_desc) {
      | [@implicit_arity] Pexp_constraint(expr, typ) => (
          {
            ...expr,
            pexp_attributes:
              List.concat([expr.pexp_attributes, returnExpr.pexp_attributes]),
          },
          Some(typ),
        )
      | _ => (returnExpr, None)
      };

    let parametersDoc =
      printExprFunParameters(
        ~inCallback,
        ~uncurried,
        ~hasConstraint=
          switch (typConstraint) {
          | Some(_) => true
          | None => false
          },
        parameters,
        cmtTbl,
      );
    let returnShouldIndent =
      switch (returnExpr.pexp_desc) {
      | Pexp_sequence(_)
      | Pexp_let(_)
      | Pexp_letmodule(_)
      | Pexp_letexception(_)
      | Pexp_open(_) => false
      | _ => true
      };

    let returnExprDoc = {
      let (optBraces, _) = ParsetreeViewer.processBracesAttr(returnExpr);
      let shouldInline =
        switch (returnExpr.pexp_desc, optBraces) {
        | (_, Some(_)) => true
        | (
            Pexp_array(_) | Pexp_tuple(_) |
            [@implicit_arity] Pexp_construct(_, Some(_)) |
            Pexp_record(_),
            _,
          ) =>
          true
        | _ => false
        };

      let returnDoc = {
        let doc = printExpressionWithComments(returnExpr, cmtTbl);
        switch (Parens.expr(returnExpr)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, returnExpr, braces)
        | Nothing => doc
        };
      };

      if (shouldInline) {
        Doc.concat([Doc.space, returnDoc]);
      } else {
        Doc.group(
          if (returnShouldIndent) {
            Doc.concat([
              Doc.indent(Doc.concat([Doc.line, returnDoc])),
              if (inCallback) {Doc.softLine} else {Doc.nil},
            ]);
          } else {
            Doc.concat([Doc.space, returnDoc]);
          },
        );
      };
    };

    let typConstraintDoc =
      switch (typConstraint) {
      | Some(typ) => Doc.concat([Doc.text(": "), printTypExpr(typ, cmtTbl)])
      | _ => Doc.nil
      };

    Doc.group(
      Doc.concat([
        printAttributes(attrs),
        parametersDoc,
        typConstraintDoc,
        Doc.text(" =>"),
        returnExprDoc,
      ]),
    );
  }

  and printTernaryOperand = (expr, cmtTbl) => {
    let doc = printExpressionWithComments(expr, cmtTbl);
    switch (Parens.ternaryOperand(expr)) {
    | Parens.Parenthesized => addParens(doc)
    | Braced(braces) => printBraces(doc, expr, braces)
    | Nothing => doc
    };
  }

  and printSetFieldExpr = (attrs, lhs, longidentLoc, rhs, loc, cmtTbl) => {
    let rhsDoc = {
      let doc = printExpressionWithComments(rhs, cmtTbl);
      switch (Parens.setFieldExprRhs(rhs)) {
      | Parens.Parenthesized => addParens(doc)
      | Braced(braces) => printBraces(doc, rhs, braces)
      | Nothing => doc
      };
    };

    let lhsDoc = {
      let doc = printExpressionWithComments(lhs, cmtTbl);
      switch (Parens.fieldExpr(lhs)) {
      | Parens.Parenthesized => addParens(doc)
      | Braced(braces) => printBraces(doc, lhs, braces)
      | Nothing => doc
      };
    };

    let shouldIndent = ParsetreeViewer.isBinaryExpression(rhs);
    let doc =
      Doc.group(
        Doc.concat([
          lhsDoc,
          Doc.dot,
          printLidentPath(longidentLoc, cmtTbl),
          Doc.text(" ="),
          if (shouldIndent) {
            Doc.group(Doc.indent(Doc.concat([Doc.line, rhsDoc])));
          } else {
            Doc.concat([Doc.space, rhsDoc]);
          },
        ]),
      );
    let doc =
      switch (attrs) {
      | [] => doc
      | attrs => Doc.group(Doc.concat([printAttributes(attrs), doc]))
      };

    printComments(doc, cmtTbl, loc);
  }

  and printTemplateLiteral = (expr, cmtTbl) => {
    let tag = ref("j");
    let rec walkExpr = expr =>
      Parsetree.(
        switch (expr.pexp_desc) {
        | [@implicit_arity]
          Pexp_apply(
            {pexp_desc: Pexp_ident({txt: Longident.Lident("^")})},
            [(Nolabel, arg1), (Nolabel, arg2)],
          ) =>
          let lhs = walkExpr(arg1);
          let rhs = walkExpr(arg2);
          Doc.concat([lhs, rhs]);
        | Pexp_constant([@implicit_arity] Pconst_string(txt, Some(prefix))) =>
          tag := prefix;
          Doc.text(txt);
        | _ =>
          let doc = printExpressionWithComments(expr, cmtTbl);
          Doc.concat([Doc.text("${"), doc, Doc.rbrace]);
        }
      );

    let content = walkExpr(expr);
    Doc.concat([
      if (tag^ == "j") {
        Doc.nil;
      } else {
        Doc.text(tag^);
      },
      Doc.text("`"),
      content,
      Doc.text("`"),
    ]);
  }

  and printUnaryExpression = (expr, cmtTbl) => {
    let printUnaryOperator = op =>
      Doc.text(
        switch (op) {
        | "~+" => "+"
        | "~+." => "+."
        | "~-" => "-"
        | "~-." => "-."
        | "not" => "!"
        | _ => assert(false)
        },
      );
    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_apply(
        {pexp_desc: Pexp_ident({txt: Longident.Lident(operator)})},
        [(Nolabel, operand)],
      ) =>
      let printedOperand = {
        let doc = printExpressionWithComments(operand, cmtTbl);
        switch (Parens.unaryExprOperand(operand)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, operand, braces)
        | Nothing => doc
        };
      };

      let doc = Doc.concat([printUnaryOperator(operator), printedOperand]);
      printComments(doc, cmtTbl, expr.pexp_loc);
    | _ => assert(false)
    };
  }

  and printBinaryExpression = (expr: Parsetree.expression, cmtTbl) => {
    let printBinaryOperator = (~inlineRhs, operator) => {
      let operatorTxt =
        switch (operator) {
        | "|." => "->"
        | "^" => "++"
        | "=" => "=="
        | "==" => "==="
        | "<>" => "!="
        | "!=" => "!=="
        | txt => txt
        };

      let spacingBeforeOperator =
        if (operator == "|.") {
          Doc.softLine;
        } else if (operator == "|>") {
          Doc.line;
        } else {
          Doc.space;
        };

      let spacingAfterOperator =
        if (operator == "|.") {
          Doc.nil;
        } else if (operator == "|>") {
          Doc.space;
        } else if (inlineRhs) {
          Doc.space;
        } else {
          Doc.line;
        };

      Doc.concat([
        spacingBeforeOperator,
        Doc.text(operatorTxt),
        spacingAfterOperator,
      ]);
    };

    let printOperand = (~isLhs, expr, parentOperator) => {
      let rec flatten = (~isLhs, expr, parentOperator) =>
        if (ParsetreeViewer.isBinaryExpression(expr)) {
          switch (expr) {
          | {
              pexp_desc:
                [@implicit_arity]
                Pexp_apply(
                  {
                    pexp_desc: Pexp_ident({txt: Longident.Lident(operator)}),
                  },
                  [(_, left), (_, right)],
                ),
            } =>
            if (ParsetreeViewer.flattenableOperators(parentOperator, operator)
                && !ParsetreeViewer.hasAttributes(expr.pexp_attributes)) {
              let leftPrinted = flatten(~isLhs=true, left, operator);
              let rightPrinted = {
                let (_, rightAttrs) =
                  ParsetreeViewer.partitionPrinteableAttributes(
                    right.pexp_attributes,
                  );

                let doc =
                  printExpressionWithComments(
                    {...right, pexp_attributes: rightAttrs},
                    cmtTbl,
                  );

                let doc =
                  if (Parens.flattenOperandRhs(parentOperator, right)) {
                    Doc.concat([Doc.lparen, doc, Doc.rparen]);
                  } else {
                    doc;
                  };

                let printeableAttrs =
                  ParsetreeViewer.filterPrinteableAttributes(
                    right.pexp_attributes,
                  );

                Doc.concat([printAttributes(printeableAttrs), doc]);
              };

              let doc =
                Doc.concat([
                  leftPrinted,
                  printBinaryOperator(~inlineRhs=false, operator),
                  rightPrinted,
                ]);
              let doc =
                if (!isLhs && Parens.rhsBinaryExprOperand(operator, expr)) {
                  Doc.concat([Doc.lparen, doc, Doc.rparen]);
                } else {
                  doc;
                };

              printComments(doc, cmtTbl, expr.pexp_loc);
            } else {
              let doc =
                printExpressionWithComments(
                  {...expr, pexp_attributes: []},
                  cmtTbl,
                );
              let doc =
                if (Parens.subBinaryExprOperand(parentOperator, operator)
                    || expr.pexp_attributes != []
                    && (
                      ParsetreeViewer.isBinaryExpression(expr)
                      || ParsetreeViewer.isTernaryExpr(expr)
                    )) {
                  Doc.concat([Doc.lparen, doc, Doc.rparen]);
                } else {
                  doc;
                };
              Doc.concat([printAttributes(expr.pexp_attributes), doc]);
            }
          | _ => assert(false)
          };
        } else {
          switch (expr.pexp_desc) {
          | [@implicit_arity] Pexp_setfield(lhs, field, rhs) =>
            let doc =
              printSetFieldExpr(
                expr.pexp_attributes,
                lhs,
                field,
                rhs,
                expr.pexp_loc,
                cmtTbl,
              );
            if (isLhs) {
              addParens(doc);
            } else {
              doc;
            };
          | [@implicit_arity]
            Pexp_apply(
              {pexp_desc: Pexp_ident({txt: Longident.Lident("#=")})},
              [(Nolabel, lhs), (Nolabel, rhs)],
            ) =>
            let rhsDoc = printExpressionWithComments(rhs, cmtTbl);
            let lhsDoc = printExpressionWithComments(lhs, cmtTbl);
            /* TODO: unify indentation of "=" */
            let shouldIndent = ParsetreeViewer.isBinaryExpression(rhs);
            let doc =
              Doc.group(
                Doc.concat([
                  lhsDoc,
                  Doc.text(" ="),
                  if (shouldIndent) {
                    Doc.group(Doc.indent(Doc.concat([Doc.line, rhsDoc])));
                  } else {
                    Doc.concat([Doc.space, rhsDoc]);
                  },
                ]),
              );
            let doc =
              switch (expr.pexp_attributes) {
              | [] => doc
              | attrs =>
                Doc.group(Doc.concat([printAttributes(attrs), doc]))
              };

            if (isLhs) {
              addParens(doc);
            } else {
              doc;
            };
          | _ =>
            let doc = printExpressionWithComments(expr, cmtTbl);
            switch (Parens.binaryExprOperand(~isLhs, expr)) {
            | Parens.Parenthesized => addParens(doc)
            | Braced(braces) => printBraces(doc, expr, braces)
            | Nothing => doc
            };
          };
        };

      flatten(~isLhs, expr, parentOperator);
    };

    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_apply(
        {
          pexp_desc: Pexp_ident({txt: Longident.Lident(("|." | "|>") as op)}),
        },
        [(Nolabel, lhs), (Nolabel, rhs)],
      )
        when
          !(
            ParsetreeViewer.isBinaryExpression(lhs)
            || ParsetreeViewer.isBinaryExpression(rhs)
          ) =>
      let lhsDoc = printOperand(~isLhs=true, lhs, op);
      let rhsDoc = printOperand(~isLhs=false, rhs, op);
      Doc.group(
        Doc.concat([
          lhsDoc,
          switch (op) {
          | "|." => Doc.text("->")
          | "|>" => Doc.text(" |> ")
          | _ => assert(false)
          },
          rhsDoc,
        ]),
      );
    | [@implicit_arity]
      Pexp_apply(
        {pexp_desc: Pexp_ident({txt: Longident.Lident(operator)})},
        [(Nolabel, lhs), (Nolabel, rhs)],
      ) =>
      let right = {
        let operatorWithRhs = {
          let rhsDoc = printOperand(~isLhs=false, rhs, operator);
          Doc.concat([
            printBinaryOperator(
              ~inlineRhs=ParsetreeViewer.shouldInlineRhsBinaryExpr(rhs),
              operator,
            ),
            rhsDoc,
          ]);
        };
        if (ParsetreeViewer.shouldIndentBinaryExpr(expr)) {
          Doc.group(Doc.indent(operatorWithRhs));
        } else {
          operatorWithRhs;
        };
      };

      let doc =
        Doc.group(
          Doc.concat([printOperand(~isLhs=true, lhs, operator), right]),
        );
      Doc.group(
        Doc.concat([
          printAttributes(expr.pexp_attributes),
          switch (
            Parens.binaryExpr({
              ...expr,
              pexp_attributes:
                List.filter(
                  attr =>
                    switch (attr) {
                    | ({Location.txt: "ns.braces"}, _) => false
                    | _ => true
                    },
                  expr.pexp_attributes,
                ),
            })
          ) {
          | Braced(bracesLoc) => printBraces(doc, expr, bracesLoc)
          | Parenthesized => addParens(doc)
          | Nothing => doc
          },
        ]),
      );
    | _ => Doc.nil
    };
  }

  /* callExpr(arg1, arg2) */
  and printPexpApply = (expr, cmtTbl) =>
    switch (expr.pexp_desc) {
    | [@implicit_arity]
      Pexp_apply(
        {pexp_desc: Pexp_ident({txt: Longident.Lident("##")})},
        [(Nolabel, parentExpr), (Nolabel, memberExpr)],
      ) =>
      let parentDoc = {
        let doc = printExpressionWithComments(parentExpr, cmtTbl);
        switch (Parens.unaryExprOperand(parentExpr)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, parentExpr, braces)
        | Nothing => doc
        };
      };

      let member = {
        let memberDoc =
          switch (memberExpr.pexp_desc) {
          | Pexp_ident(lident) =>
            printComments(
              printLongident(lident.txt),
              cmtTbl,
              memberExpr.pexp_loc,
            )
          | _ => printExpressionWithComments(memberExpr, cmtTbl)
          };

        Doc.concat([Doc.text("\""), memberDoc, Doc.text("\"")]);
      };

      Doc.group(
        Doc.concat([
          printAttributes(expr.pexp_attributes),
          parentDoc,
          Doc.lbracket,
          member,
          Doc.rbracket,
        ]),
      );
    | [@implicit_arity]
      Pexp_apply(
        {pexp_desc: Pexp_ident({txt: Longident.Lident("#=")})},
        [(Nolabel, lhs), (Nolabel, rhs)],
      ) =>
      let rhsDoc = {
        let doc = printExpressionWithComments(rhs, cmtTbl);
        switch (Parens.expr(rhs)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, rhs, braces)
        | Nothing => doc
        };
      };

      /* TODO: unify indentation of "=" */
      let shouldIndent =
        !ParsetreeViewer.isBracedExpr(rhs)
        && ParsetreeViewer.isBinaryExpression(rhs);
      let doc =
        Doc.group(
          Doc.concat([
            printExpressionWithComments(lhs, cmtTbl),
            Doc.text(" ="),
            if (shouldIndent) {
              Doc.group(Doc.indent(Doc.concat([Doc.line, rhsDoc])));
            } else {
              Doc.concat([Doc.space, rhsDoc]);
            },
          ]),
        );
      switch (expr.pexp_attributes) {
      | [] => doc
      | attrs => Doc.group(Doc.concat([printAttributes(attrs), doc]))
      };
    | [@implicit_arity]
      Pexp_apply(
        {
          pexp_desc:
            Pexp_ident({
              txt: [@implicit_arity] Longident.Ldot(Lident("Array"), "get"),
            }),
        },
        [(Nolabel, parentExpr), (Nolabel, memberExpr)],
      ) =>
      let member = {
        let memberDoc = {
          let doc = printExpressionWithComments(memberExpr, cmtTbl);
          switch (Parens.expr(memberExpr)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, memberExpr, braces)
          | Nothing => doc
          };
        };

        let shouldInline =
          switch (memberExpr.pexp_desc) {
          | Pexp_constant(_)
          | Pexp_ident(_) => true
          | _ => false
          };

        if (shouldInline) {
          memberDoc;
        } else {
          Doc.concat([
            Doc.indent(Doc.concat([Doc.softLine, memberDoc])),
            Doc.softLine,
          ]);
        };
      };

      let parentDoc = {
        let doc = printExpressionWithComments(parentExpr, cmtTbl);
        switch (Parens.unaryExprOperand(parentExpr)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, parentExpr, braces)
        | Nothing => doc
        };
      };

      Doc.group(
        Doc.concat([
          printAttributes(expr.pexp_attributes),
          parentDoc,
          Doc.lbracket,
          member,
          Doc.rbracket,
        ]),
      );
    | [@implicit_arity]
      Pexp_apply(
        {
          pexp_desc:
            Pexp_ident({
              txt: [@implicit_arity] Longident.Ldot(Lident("Array"), "set"),
            }),
        },
        [
          (Nolabel, parentExpr),
          (Nolabel, memberExpr),
          (Nolabel, targetExpr),
        ],
      ) =>
      let member = {
        let memberDoc = {
          let doc = printExpressionWithComments(memberExpr, cmtTbl);
          switch (Parens.expr(memberExpr)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, memberExpr, braces)
          | Nothing => doc
          };
        };

        let shouldInline =
          switch (memberExpr.pexp_desc) {
          | Pexp_constant(_)
          | Pexp_ident(_) => true
          | _ => false
          };

        if (shouldInline) {
          memberDoc;
        } else {
          Doc.concat([
            Doc.indent(Doc.concat([Doc.softLine, memberDoc])),
            Doc.softLine,
          ]);
        };
      };

      let shouldIndentTargetExpr =
        if (ParsetreeViewer.isBracedExpr(targetExpr)) {
          false;
        } else {
          ParsetreeViewer.isBinaryExpression(targetExpr)
          || (
            switch (targetExpr) {
            | {
                pexp_attributes: [({Location.txt: "ns.ternary"}, _)],
                pexp_desc: [@implicit_arity] Pexp_ifthenelse(ifExpr, _, _),
              } =>
              ParsetreeViewer.isBinaryExpression(ifExpr)
              || ParsetreeViewer.hasAttributes(ifExpr.pexp_attributes)
            | {pexp_desc: Pexp_newtype(_)} => false
            | e =>
              ParsetreeViewer.hasAttributes(e.pexp_attributes)
              || ParsetreeViewer.isArrayAccess(e)
            }
          );
        };

      let targetExpr = {
        let doc = printExpressionWithComments(targetExpr, cmtTbl);
        switch (Parens.expr(targetExpr)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, targetExpr, braces)
        | Nothing => doc
        };
      };

      let parentDoc = {
        let doc = printExpressionWithComments(parentExpr, cmtTbl);
        switch (Parens.unaryExprOperand(parentExpr)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, parentExpr, braces)
        | Nothing => doc
        };
      };

      Doc.group(
        Doc.concat([
          printAttributes(expr.pexp_attributes),
          parentDoc,
          Doc.lbracket,
          member,
          Doc.rbracket,
          Doc.text(" ="),
          if (shouldIndentTargetExpr) {
            Doc.indent(Doc.concat([Doc.line, targetExpr]));
          } else {
            Doc.concat([Doc.space, targetExpr]);
          },
        ]),
      );
    /* TODO: cleanup, are those branches even remotely performant? */
    | [@implicit_arity] Pexp_apply({pexp_desc: Pexp_ident(lident)}, args)
        when ParsetreeViewer.isJsxExpression(expr) =>
      printJsxExpression(lident, args, cmtTbl)
    | [@implicit_arity] Pexp_apply(callExpr, args) =>
      let args =
        List.map(
          ((lbl, arg)) =>
            (lbl, ParsetreeViewer.rewriteUnderscoreApply(arg)),
          args,
        );

      let (uncurried, attrs) =
        ParsetreeViewer.processUncurriedAttribute(expr.pexp_attributes);

      let callExprDoc = {
        let doc = printExpressionWithComments(callExpr, cmtTbl);
        switch (Parens.callExpr(callExpr)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, callExpr, braces)
        | Nothing => doc
        };
      };

      if (ParsetreeViewer.requiresSpecialCallbackPrintingFirstArg(args)) {
        let argsDoc =
          printArgumentsWithCallbackInFirstPosition(~uncurried, args, cmtTbl);

        Doc.concat([printAttributes(attrs), callExprDoc, argsDoc]);
      } else if (ParsetreeViewer.requiresSpecialCallbackPrintingLastArg(args)) {
        let argsDoc =
          printArgumentsWithCallbackInLastPosition(~uncurried, args, cmtTbl);

        Doc.concat([printAttributes(attrs), callExprDoc, argsDoc]);
      } else {
        let argsDoc = printArguments(~uncurried, args, cmtTbl);
        Doc.concat([printAttributes(attrs), callExprDoc, argsDoc]);
      };
    | _ => assert(false)
    }

  and printJsxExpression = (lident, args, cmtTbl) => {
    let name = printJsxName(lident);
    let (formattedProps, children) = printJsxProps(args, cmtTbl);
    /* <div className="test" /> */
    let isSelfClosing =
      switch (children) {
      | [] => true
      | _ => false
      };
    Doc.group(
      Doc.concat([
        Doc.group(
          Doc.concat([
            printComments(
              Doc.concat([Doc.lessThan, name]),
              cmtTbl,
              lident.Asttypes.loc,
            ),
            formattedProps,
            if (isSelfClosing) {
              Doc.concat([Doc.line, Doc.text("/>")]);
            } else {
              Doc.nil;
            },
          ]),
        ),
        if (isSelfClosing) {
          Doc.nil;
        } else {
          Doc.concat([
            Doc.greaterThan,
            Doc.indent(
              Doc.concat([Doc.line, printJsxChildren(children, cmtTbl)]),
            ),
            Doc.line,
            Doc.text("</"),
            name,
            Doc.greaterThan,
          ]);
        },
      ]),
    );
  }

  and printJsxFragment = (expr, cmtTbl) => {
    let opening = Doc.text("<>");
    let closing = Doc.text("</>");
    let (children, _) = ParsetreeViewer.collectListExpressions(expr);
    Doc.group(
      Doc.concat([
        opening,
        switch (children) {
        | [] => Doc.nil
        | children =>
          Doc.indent(
            Doc.concat([Doc.line, printJsxChildren(children, cmtTbl)]),
          )
        },
        Doc.line,
        closing,
      ]),
    );
  }

  and printJsxChildren = (children: list(Parsetree.expression), cmtTbl) =>
    Doc.group(
      Doc.join(
        ~sep=Doc.line,
        List.map(
          expr => {
            let exprDoc = printExpressionWithComments(expr, cmtTbl);
            switch (Parens.jsxChildExpr(expr)) {
            | Parenthesized
            | Braced(_) =>
              /* {(20: int)} make sure that we also protect the expression inside */
              addBraces(
                if (Parens.bracedExpr(expr)) {
                  addParens(exprDoc);
                } else {
                  exprDoc;
                },
              )
            | Nothing => exprDoc
            };
          },
          children,
        ),
      ),
    )

  and printJsxProps = (args, cmtTbl) => {
    let rec loop = (props, args) =>
      switch (args) {
      | [] => (Doc.nil, [])
      | [
          (Asttypes.Labelled("children"), children),
          (
            Asttypes.Nolabel,
            {
              Parsetree.pexp_desc:
                [@implicit_arity]
                Pexp_construct({txt: Longident.Lident("()")}, None),
            },
          ),
        ] =>
        let formattedProps =
          Doc.indent(
            switch (props) {
            | [] => Doc.nil
            | props =>
              Doc.concat([
                Doc.line,
                Doc.group(Doc.join(~sep=Doc.line, props |> List.rev)),
              ])
            },
          );
        let (children, _) = ParsetreeViewer.collectListExpressions(children);
        (formattedProps, children);
      | [arg, ...args] =>
        let propDoc = printJsxProp(arg, cmtTbl);
        loop([propDoc, ...props], args);
      };

    loop([], args);
  }

  and printJsxProp = (arg, cmtTbl) =>
    switch (arg) {
    | (
        (Asttypes.Labelled(lblTxt) | Optional(lblTxt)) as lbl,
        {
          Parsetree.pexp_attributes: [
            ({Location.txt: "ns.namedArgLoc", loc: argLoc}, _),
          ],
          pexp_desc: Pexp_ident({txt: Longident.Lident(ident)}),
        },
      )
        when lblTxt == ident /* jsx punning */ =>
      switch (lbl) {
      | Nolabel => Doc.nil
      | Labelled(_lbl) =>
        printComments(printIdentLike(ident), cmtTbl, argLoc)
      | Optional(_lbl) =>
        let doc = Doc.concat([Doc.question, printIdentLike(ident)]);
        printComments(doc, cmtTbl, argLoc);
      }
    | (
        (Asttypes.Labelled(lblTxt) | Optional(lblTxt)) as lbl,
        {
          Parsetree.pexp_attributes: [],
          pexp_desc: Pexp_ident({txt: Longident.Lident(ident)}),
        },
      )
        when lblTxt == ident /* jsx punning when printing from Reason */ =>
      switch (lbl) {
      | Nolabel => Doc.nil
      | Labelled(_lbl) => printIdentLike(ident)
      | Optional(_lbl) => Doc.concat([Doc.question, printIdentLike(ident)])
      }
    | (lbl, expr) =>
      let (argLoc, expr) =
        switch (expr.pexp_attributes) {
        | [({Location.txt: "ns.namedArgLoc", loc}, _), ...attrs] => (
            loc,
            {...expr, pexp_attributes: attrs},
          )
        | _ => (Location.none, expr)
        };

      let lblDoc =
        switch (lbl) {
        | Asttypes.Labelled(lbl) =>
          let lbl = printComments(printIdentLike(lbl), cmtTbl, argLoc);
          Doc.concat([lbl, Doc.equal]);
        | Asttypes.Optional(lbl) =>
          let lbl = printComments(printIdentLike(lbl), cmtTbl, argLoc);
          Doc.concat([lbl, Doc.equal, Doc.question]);
        | Nolabel => Doc.nil
        };

      let exprDoc = {
        let doc = printExpression(expr, cmtTbl);
        switch (Parens.jsxPropExpr(expr)) {
        | Parenthesized
        | Braced(_) =>
          /* {(20: int)} make sure that we also protect the expression inside */
          addBraces(
            if (Parens.bracedExpr(expr)) {
              addParens(doc);
            } else {
              doc;
            },
          )
        | _ => doc
        };
      };

      let fullLoc = {...argLoc, loc_end: expr.pexp_loc.loc_end};
      printComments(Doc.concat([lblDoc, exprDoc]), cmtTbl, fullLoc);
    }

  /* div -> div.
   * Navabar.createElement -> Navbar
   * Staff.Users.createElement -> Staff.Users */
  and printJsxName = ({txt: lident}) => {
    let rec flatten = (acc, lident) =>
      switch (lident) {
      | Longident.Lident(txt) => [txt, ...acc]
      | [@implicit_arity] Ldot(lident, txt) =>
        let acc =
          if (txt == "createElement") {
            acc;
          } else {
            [txt, ...acc];
          };
        flatten(acc, lident);
      | _ => acc
      };

    switch (lident) {
    | Longident.Lident(txt) => Doc.text(txt)
    | _ as lident =>
      let segments = flatten([], lident);
      Doc.join(~sep=Doc.dot, List.map(Doc.text, segments));
    };
  }

  and printArgumentsWithCallbackInFirstPosition = (~uncurried, args, cmtTbl) => {
    let (callback, printedArgs) =
      switch (args) {
      | [(lbl, expr), ...args] =>
        let lblDoc =
          switch (lbl) {
          | Asttypes.Nolabel => Doc.nil
          | Asttypes.Labelled(txt) =>
            Doc.concat([Doc.tilde, printIdentLike(txt), Doc.equal])
          | Asttypes.Optional(txt) =>
            Doc.concat([
              Doc.tilde,
              printIdentLike(txt),
              Doc.equal,
              Doc.question,
            ])
          };

        let callback =
          Doc.concat([lblDoc, printPexpFun(~inCallback=true, expr, cmtTbl)]);
        let printedArgs =
          List.map(arg => printArgument(arg, cmtTbl), args)
          |> Doc.join(~sep=Doc.concat([Doc.comma, Doc.line]));

        (callback, printedArgs);
      | _ => assert(false)
      };

    /* Thing.map((arg1, arg2) => MyModuleBlah.toList(argument), foo) */
    /* Thing.map((arg1, arg2) => {
     *   MyModuleBlah.toList(argument)
     * }, longArgumet, veryLooooongArgument)
     */
    let fitsOnOneLine =
      Doc.concat([
        if (uncurried) {
          Doc.text("(. ");
        } else {
          Doc.lparen;
        },
        callback,
        Doc.comma,
        Doc.line,
        printedArgs,
        Doc.rparen,
      ]);

    /* Thing.map(
     *   (param1, parm2) => doStuff(param1, parm2),
     *   arg1,
     *   arg2,
     *   arg3,
     * )
     */
    let breakAllArgs = printArguments(~uncurried, args, cmtTbl);
    Doc.customLayout([fitsOnOneLine, breakAllArgs]);
  }

  and printArgumentsWithCallbackInLastPosition = (~uncurried, args, cmtTbl) => {
    let rec loop = (acc, args) =>
      switch (args) {
      | [] => (Doc.nil, Doc.nil)
      | [(lbl, expr)] =>
        let lblDoc =
          switch (lbl) {
          | Asttypes.Nolabel => Doc.nil
          | Asttypes.Labelled(txt) =>
            Doc.concat([Doc.tilde, printIdentLike(txt), Doc.equal])
          | Asttypes.Optional(txt) =>
            Doc.concat([
              Doc.tilde,
              printIdentLike(txt),
              Doc.equal,
              Doc.question,
            ])
          };

        let callback = printPexpFun(~inCallback=true, expr, cmtTbl);
        (Doc.concat(List.rev(acc)), Doc.concat([lblDoc, callback]));
      | [arg, ...args] =>
        let argDoc = printArgument(arg, cmtTbl);
        loop([Doc.line, Doc.comma, argDoc, ...acc], args);
      };

    let (printedArgs, callback) = loop([], args);

    /* Thing.map(foo, (arg1, arg2) => MyModuleBlah.toList(argument)) */
    let fitsOnOneLine =
      Doc.concat([
        if (uncurried) {
          Doc.text("(.");
        } else {
          Doc.lparen;
        },
        printedArgs,
        callback,
        Doc.rparen,
      ]);

    /* Thing.map(longArgumet, veryLooooongArgument, (arg1, arg2) =>
     *   MyModuleBlah.toList(argument)
     * )
     */
    let arugmentsFitOnOneLine =
      Doc.concat([
        if (uncurried) {
          Doc.text("(.");
        } else {
          Doc.lparen;
        },
        Doc.softLine,
        printedArgs,
        Doc.breakableGroup(~forceBreak=true, callback),
        Doc.softLine,
        Doc.rparen,
      ]);

    /* Thing.map(
     *   arg1,
     *   arg2,
     *   arg3,
     *   (param1, parm2) => doStuff(param1, parm2)
     * )
     */
    let breakAllArgs = printArguments(~uncurried, args, cmtTbl);
    Doc.customLayout([fitsOnOneLine, arugmentsFitOnOneLine, breakAllArgs]);
  }

  and printArguments =
      (
        ~uncurried,
        args: list((Asttypes.arg_label, Parsetree.expression)),
        cmtTbl,
      ) =>
    switch (args) {
    | [
        (
          Nolabel,
          {
            pexp_desc:
              [@implicit_arity]
              Pexp_construct({txt: Longident.Lident("()")}, _),
          },
        ),
      ] =>
      if (uncurried) {
        Doc.text("(.)");
      } else {
        Doc.text("()");
      }
    | [(Nolabel, arg)] when ParsetreeViewer.isHuggableExpression(arg) =>
      let argDoc = {
        let doc = printExpressionWithComments(arg, cmtTbl);
        switch (Parens.expr(arg)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, arg, braces)
        | Nothing => doc
        };
      };

      Doc.concat([
        if (uncurried) {
          Doc.text("(.");
        } else {
          Doc.lparen;
        },
        argDoc,
        Doc.rparen,
      ]);
    | args =>
      Doc.group(
        Doc.concat([
          if (uncurried) {
            Doc.text("(.");
          } else {
            Doc.lparen;
          },
          Doc.indent(
            Doc.concat([
              if (uncurried) {Doc.line} else {Doc.softLine},
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(arg => printArgument(arg, cmtTbl), args),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          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 printArgument = ((argLbl, arg), cmtTbl) =>
    switch (argLbl, arg) {
    /* ~a (punned)*/
    | (
        Asttypes.Labelled(lbl),
        {
          pexp_desc: Pexp_ident({txt: Longident.Lident(name)}),
          pexp_attributes: [] | [({Location.txt: "ns.namedArgLoc"}, _)],
        } as argExpr,
      )
        when lbl == name && !ParsetreeViewer.isBracedExpr(argExpr) =>
      let loc =
        switch (arg.pexp_attributes) {
        | [({Location.txt: "ns.namedArgLoc", loc}, _), ..._] => loc
        | _ => arg.pexp_loc
        };

      let doc = Doc.concat([Doc.tilde, printIdentLike(lbl)]);
      printComments(doc, cmtTbl, loc);

    /* ~a: int (punned)*/
    | (
        Asttypes.Labelled(lbl),
        {
          pexp_desc:
            [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_ident({txt: Longident.Lident(name)})} as argExpr,
              typ,
            ),
          pexp_loc,
          pexp_attributes:
            ([] | [({Location.txt: "ns.namedArgLoc"}, _)]) as attrs,
        },
      )
        when lbl == name && !ParsetreeViewer.isBracedExpr(argExpr) =>
      let loc =
        switch (attrs) {
        | [({Location.txt: "ns.namedArgLoc", loc}, _), ..._] => {
            ...loc,
            loc_end: pexp_loc.loc_end,
          }
        | _ => arg.pexp_loc
        };

      let doc =
        Doc.concat([
          Doc.tilde,
          printIdentLike(lbl),
          Doc.text(": "),
          printTypExpr(typ, cmtTbl),
        ]);
      printComments(doc, cmtTbl, loc);
    /* ~a? (optional lbl punned)*/
    | (
        Asttypes.Optional(lbl),
        {
          pexp_desc: Pexp_ident({txt: Longident.Lident(name)}),
          pexp_attributes: [] | [({Location.txt: "ns.namedArgLoc"}, _)],
        },
      )
        when lbl == name =>
      let loc =
        switch (arg.pexp_attributes) {
        | [({Location.txt: "ns.namedArgLoc", loc}, _), ..._] => loc
        | _ => arg.pexp_loc
        };

      let doc = Doc.concat([Doc.tilde, printIdentLike(lbl), Doc.question]);
      printComments(doc, cmtTbl, loc);
    | (_lbl, expr) =>
      let (argLoc, expr) =
        switch (expr.pexp_attributes) {
        | [({Location.txt: "ns.namedArgLoc", loc}, _), ...attrs] => (
            loc,
            {...expr, pexp_attributes: attrs},
          )
        | _ => (expr.pexp_loc, expr)
        };

      let printedLbl =
        switch (argLbl) {
        | Asttypes.Nolabel => Doc.nil
        | Asttypes.Labelled(lbl) =>
          let doc = Doc.concat([Doc.tilde, printIdentLike(lbl), Doc.equal]);
          printComments(doc, cmtTbl, argLoc);
        | Asttypes.Optional(lbl) =>
          let doc =
            Doc.concat([
              Doc.tilde,
              printIdentLike(lbl),
              Doc.equal,
              Doc.question,
            ]);
          printComments(doc, cmtTbl, argLoc);
        };

      let printedExpr = {
        let doc = printExpressionWithComments(expr, cmtTbl);
        switch (Parens.expr(expr)) {
        | Parens.Parenthesized => addParens(doc)
        | Braced(braces) => printBraces(doc, expr, braces)
        | Nothing => doc
        };
      };

      let loc = {...argLoc, loc_end: expr.pexp_loc.loc_end};
      let doc = Doc.concat([printedLbl, printedExpr]);
      printComments(doc, cmtTbl, loc);
    }

  and printCases = (cases: list(Parsetree.case), cmtTbl) =>
    Doc.breakableGroup(
      ~forceBreak=true,
      Doc.concat([
        Doc.lbrace,
        Doc.concat([
          Doc.line,
          printList(
            ~getLoc=
              n =>
                {
                  ...n.Parsetree.pc_lhs.ppat_loc,
                  loc_end:
                    switch (
                      ParsetreeViewer.processBracesAttr(n.Parsetree.pc_rhs)
                    ) {
                    | (None, _) => n.pc_rhs.pexp_loc.loc_end
                    | (Some(({loc}, _)), _) => loc.Location.loc_end
                    },
                },
            ~print=printCase,
            ~nodes=cases,
            cmtTbl,
          ),
        ]),
        Doc.line,
        Doc.rbrace,
      ]),
    )

  and printCase = (case: Parsetree.case, cmtTbl) => {
    let rhs =
      switch (case.pc_rhs.pexp_desc) {
      | Pexp_let(_)
      | Pexp_letmodule(_)
      | Pexp_letexception(_)
      | Pexp_open(_)
      | Pexp_sequence(_) =>
        printExpressionBlock(
          ~braces=ParsetreeViewer.isBracedExpr(case.pc_rhs),
          case.pc_rhs,
          cmtTbl,
        )
      | _ =>
        let doc = printExpressionWithComments(case.pc_rhs, cmtTbl);
        switch (Parens.expr(case.pc_rhs)) {
        | Parenthesized => addParens(doc)
        | _ => doc
        };
      };

    let guard =
      switch (case.pc_guard) {
      | None => Doc.nil
      | Some(expr) =>
        Doc.group(
          Doc.concat([
            Doc.line,
            Doc.text("when "),
            printExpressionWithComments(expr, cmtTbl),
          ]),
        )
      };

    let shouldInlineRhs =
      switch (case.pc_rhs.pexp_desc) {
      | [@implicit_arity]
        Pexp_construct({txt: Longident.Lident("()" | "true" | "false")}, _)
      | Pexp_constant(_)
      | Pexp_ident(_) => true
      | _ when ParsetreeViewer.isHuggableRhs(case.pc_rhs) => true
      | _ => false
      };

    let shouldIndentPattern =
      switch (case.pc_lhs.ppat_desc) {
      | Ppat_or(_) => false
      | _ => true
      };

    let patternDoc = {
      let doc = printPattern(case.pc_lhs, cmtTbl);
      switch (case.pc_lhs.ppat_desc) {
      | Ppat_constraint(_) => addParens(doc)
      | _ => doc
      };
    };

    let content =
      Doc.concat([
        if (shouldIndentPattern) {
          Doc.indent(patternDoc);
        } else {
          patternDoc;
        },
        Doc.indent(guard),
        Doc.text(" =>"),
        Doc.indent(
          Doc.concat([if (shouldInlineRhs) {Doc.space} else {Doc.line}, rhs]),
        ),
      ]);
    Doc.group(Doc.concat([Doc.text("| "), content]));
  }

  and printExprFunParameters =
      (~inCallback, ~uncurried, ~hasConstraint, parameters, cmtTbl) =>
    switch (parameters) {
    /* let f = _ => () */
    | [
        ParsetreeViewer.Parameter({
          attrs: [],
          lbl: Asttypes.Nolabel,
          defaultExpr: None,
          pat: {Parsetree.ppat_desc: Ppat_any},
        }),
      ]
        when !uncurried =>
      if (hasConstraint) {
        Doc.text("(_)");
      } else {
        Doc.text("_");
      }
    /* let f = a => () */
    | [
        ParsetreeViewer.Parameter({
          attrs: [],
          lbl: Asttypes.Nolabel,
          defaultExpr: None,
          pat: {Parsetree.ppat_desc: Ppat_var(stringLoc)},
        }),
      ]
        when !uncurried =>
      let txtDoc = {
        let var = printIdentLike(stringLoc.txt);
        if (hasConstraint) {
          addParens(var);
        } else {
          var;
        };
      };

      printComments(txtDoc, cmtTbl, stringLoc.loc);
    /* let f = () => () */
    | [
        ParsetreeViewer.Parameter({
          attrs: [],
          lbl: Asttypes.Nolabel,
          defaultExpr: None,
          pat: {
            ppat_desc:
              [@implicit_arity]
              Ppat_construct({txt: Longident.Lident("()")}, None),
          },
        }),
      ]
        when !uncurried =>
      Doc.text("()")
    /* let f = (~greeting, ~from as hometown, ~x=?) => () */
    | parameters =>
      let lparen =
        if (uncurried) {
          Doc.text("(. ");
        } else {
          Doc.lparen;
        };
      let shouldHug = ParsetreeViewer.parametersShouldHug(parameters);
      let printedParamaters =
        Doc.concat([
          if (shouldHug || inCallback) {
            Doc.nil;
          } else {
            Doc.softLine;
          },
          Doc.join(
            ~sep=
              Doc.concat([
                Doc.comma,
                if (inCallback) {Doc.space} else {Doc.line},
              ]),
            List.map(p => printExpFunParameter(p, cmtTbl), parameters),
          ),
        ]);
      Doc.group(
        Doc.concat([
          lparen,
          if (shouldHug || inCallback) {
            printedParamaters;
          } else {
            Doc.indent(printedParamaters);
          },
          if (shouldHug || inCallback) {
            Doc.nil;
          } else {
            Doc.concat([Doc.trailingComma, Doc.softLine]);
          },
          Doc.rparen,
        ]),
      );
    }

  and printExpFunParameter = (parameter, cmtTbl) =>
    switch (parameter) {
    | ParsetreeViewer.NewTypes({attrs, locs: lbls}) =>
      Doc.group(
        Doc.concat([
          printAttributes(attrs),
          Doc.text("type "),
          Doc.join(
            ~sep=Doc.space,
            List.map(
              lbl =>
                printComments(
                  printIdentLike(lbl.Asttypes.txt),
                  cmtTbl,
                  lbl.Asttypes.loc,
                ),
              lbls,
            ),
          ),
        ]),
      )
    | Parameter({attrs, lbl, defaultExpr, pat: pattern}) =>
      let (isUncurried, attrs) =
        ParsetreeViewer.processUncurriedAttribute(attrs);
      let uncurried =
        if (isUncurried) {
          Doc.concat([Doc.dot, Doc.space]);
        } else {
          Doc.nil;
        };
      let attrs = printAttributes(attrs);
      /* =defaultValue */
      let defaultExprDoc =
        switch (defaultExpr) {
        | Some(expr) =>
          Doc.concat([
            Doc.text("="),
            printExpressionWithComments(expr, cmtTbl),
          ])
        | None => Doc.nil
        };

      /* ~from as hometown
       * ~from                   ->  punning */
      let labelWithPattern =
        switch (lbl, pattern) {
        | (Asttypes.Nolabel, pattern) => printPattern(pattern, cmtTbl)
        | (
            Asttypes.Labelled(lbl) | Optional(lbl),
            {
              ppat_desc: Ppat_var(stringLoc),
              ppat_attributes: [] | [({Location.txt: "ns.namedArgLoc"}, _)],
            },
          )
            when lbl == stringLoc.txt =>
          /* ~d */
          Doc.concat([Doc.text("~"), printIdentLike(lbl)])
        | (
            Asttypes.Labelled(lbl) | Optional(lbl),
            {
              ppat_desc:
                [@implicit_arity]
                Ppat_constraint({ppat_desc: Ppat_var({txt})}, typ),
              ppat_attributes: [] | [({Location.txt: "ns.namedArgLoc"}, _)],
            },
          )
            when lbl == txt =>
          /* ~d: e */
          Doc.concat([
            Doc.text("~"),
            printIdentLike(lbl),
            Doc.text(": "),
            printTypExpr(typ, cmtTbl),
          ])
        | (Asttypes.Labelled(lbl) | Optional(lbl), pattern) =>
          /* ~b as c */
          Doc.concat([
            Doc.text("~"),
            printIdentLike(lbl),
            Doc.text(" as "),
            printPattern(pattern, cmtTbl),
          ])
        };

      let optionalLabelSuffix =
        switch (lbl, defaultExpr) {
        | (Asttypes.Optional(_), None) => Doc.text("=?")
        | _ => Doc.nil
        };

      let doc =
        Doc.group(
          Doc.concat([
            uncurried,
            attrs,
            labelWithPattern,
            defaultExprDoc,
            optionalLabelSuffix,
          ]),
        );
      let cmtLoc =
        switch (defaultExpr) {
        | None =>
          switch (pattern.ppat_attributes) {
          | [({Location.txt: "ns.namedArgLoc", loc}, _), ..._] => {
              ...loc,
              loc_end: pattern.ppat_loc.loc_end,
            }
          | _ => pattern.ppat_loc
          }
        | Some(expr) =>
          let startPos =
            switch (pattern.ppat_attributes) {
            | [({Location.txt: "ns.namedArgLoc", loc}, _), ..._] =>
              loc.loc_start
            | _ => pattern.ppat_loc.loc_start
            };
          {
            ...pattern.ppat_loc,
            loc_start: startPos,
            loc_end: expr.pexp_loc.loc_end,
          };
        };

      printComments(doc, cmtTbl, cmtLoc);
    }

  and printExpressionBlock = (~braces, expr, cmtTbl) => {
    let rec collectRows = (acc, expr) =>
      switch (expr.Parsetree.pexp_desc) {
      | [@implicit_arity] Parsetree.Pexp_letmodule(modName, modExpr, expr2) =>
        let name = {
          let doc = Doc.text(modName.txt);
          printComments(doc, cmtTbl, modName.loc);
        };

        let letModuleDoc =
          Doc.concat([
            Doc.text("module "),
            name,
            Doc.text(" = "),
            printModExpr(modExpr, cmtTbl),
          ]);
        let loc = {...expr.pexp_loc, loc_end: modExpr.pmod_loc.loc_end};
        collectRows([(loc, letModuleDoc), ...acc], expr2);
      | [@implicit_arity] Pexp_letexception(extensionConstructor, expr2) =>
        let loc = {
          let loc = {
            ...expr.pexp_loc,
            loc_end: extensionConstructor.pext_loc.loc_end,
          };
          switch (getFirstLeadingComment(cmtTbl, loc)) {
          | None => loc
          | Some(comment) =>
            let cmtLoc = Comment.loc(comment);
            {...cmtLoc, loc_end: loc.loc_end};
          };
        };

        let letExceptionDoc = printExceptionDef(extensionConstructor, cmtTbl);
        collectRows([(loc, letExceptionDoc), ...acc], expr2);
      | [@implicit_arity] Pexp_open(overrideFlag, longidentLoc, expr2) =>
        let openDoc =
          Doc.concat([
            Doc.text("open"),
            printOverrideFlag(overrideFlag),
            Doc.space,
            printLongidentLocation(longidentLoc, cmtTbl),
          ]);
        let loc = {...expr.pexp_loc, loc_end: longidentLoc.loc.loc_end};
        collectRows([(loc, openDoc), ...acc], expr2);
      | [@implicit_arity] Pexp_sequence(expr1, expr2) =>
        let exprDoc = {
          let doc = printExpression(expr1, cmtTbl);
          switch (Parens.expr(expr1)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, expr1, braces)
          | Nothing => doc
          };
        };

        let loc = expr1.pexp_loc;
        collectRows([(loc, exprDoc), ...acc], expr2);
      | [@implicit_arity] Pexp_let(recFlag, valueBindings, expr2) =>
        let loc = {
          let loc =
            switch (valueBindings, List.rev(valueBindings)) {
            | ([vb, ..._], [lastVb, ..._]) => {
                ...vb.pvb_loc,
                loc_end: lastVb.pvb_loc.loc_end,
              }
            | _ => Location.none
            };

          switch (getFirstLeadingComment(cmtTbl, loc)) {
          | None => loc
          | Some(comment) =>
            let cmtLoc = Comment.loc(comment);
            {...cmtLoc, loc_end: loc.loc_end};
          };
        };

        let recFlag =
          switch (recFlag) {
          | Asttypes.Nonrecursive => Doc.nil
          | Asttypes.Recursive => Doc.text("rec ")
          };

        let letDoc = printValueBindings(~recFlag, valueBindings, cmtTbl);
        /* let () = {
         *   let () = foo()
         *   ()
         * }
         * We don't need to print the () on the last line of the block
         */
        switch (expr2.pexp_desc) {
        | [@implicit_arity] Pexp_construct({txt: Longident.Lident("()")}, _) =>
          List.rev([(loc, letDoc), ...acc])
        | _ => collectRows([(loc, letDoc), ...acc], expr2)
        };
      | _ =>
        let exprDoc = {
          let doc = printExpression(expr, cmtTbl);
          switch (Parens.expr(expr)) {
          | Parens.Parenthesized => addParens(doc)
          | Braced(braces) => printBraces(doc, expr, braces)
          | Nothing => doc
          };
        };

        List.rev([(expr.pexp_loc, exprDoc), ...acc]);
      };

    let rows = collectRows([], expr);
    let block =
      printList(
        ~getLoc=fst,
        ~nodes=rows,
        ~print=((_, doc), _) => doc,
        ~forceBreak=true,
        cmtTbl,
      );

    Doc.breakableGroup(
      ~forceBreak=true,
      if (braces) {
        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 printBraces = (doc, expr, bracesLoc) => {
    let overMultipleLines =
      Location.(bracesLoc.loc_end.pos_lnum > bracesLoc.loc_start.pos_lnum);

    switch (expr.Parsetree.pexp_desc) {
    | Pexp_letmodule(_)
    | Pexp_letexception(_)
    | Pexp_let(_)
    | Pexp_open(_)
    | Pexp_sequence(_) =>
      /* already has braces */
      doc
    | _ =>
      Doc.breakableGroup(
        ~forceBreak=overMultipleLines,
        Doc.concat([
          Doc.lbrace,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              if (Parens.bracedExpr(expr)) {
                addParens(doc);
              } else {
                doc;
              },
            ]),
          ),
          Doc.softLine,
          Doc.rbrace,
        ]),
      )
    };
  }

  and printOverrideFlag = overrideFlag =>
    switch (overrideFlag) {
    | Asttypes.Override => Doc.text("!")
    | Fresh => Doc.nil
    }

  and printDirectionFlag = flag =>
    switch (flag) {
    | Asttypes.Downto => Doc.text(" downto ")
    | Asttypes.Upto => Doc.text(" to ")
    }

  and printRecordRow = ((lbl, expr), cmtTbl) => {
    let cmtLoc = {...lbl.loc, loc_end: expr.pexp_loc.loc_end};
    let doc =
      Doc.group(
        Doc.concat([
          printLidentPath(lbl, cmtTbl),
          Doc.text(": "),
          {
            let doc = printExpressionWithComments(expr, cmtTbl);
            switch (Parens.expr(expr)) {
            | Parens.Parenthesized => addParens(doc)
            | Braced(braces) => printBraces(doc, expr, braces)
            | Nothing => doc
            };
          },
        ]),
      );
    printComments(doc, cmtTbl, cmtLoc);
  }

  and printBsObjectRow = ((lbl, expr), cmtTbl) => {
    let cmtLoc = {...lbl.loc, loc_end: expr.pexp_loc.loc_end};
    let lblDoc = {
      let doc =
        Doc.concat([
          Doc.text("\""),
          printLongident(lbl.txt),
          Doc.text("\""),
        ]);
      printComments(doc, cmtTbl, lbl.loc);
    };

    let doc =
      Doc.concat([
        lblDoc,
        Doc.text(": "),
        printExpressionWithComments(expr, cmtTbl),
      ]);
    printComments(doc, cmtTbl, cmtLoc);
  }

  /* 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 printAttributes = (~loc=?, attrs: Parsetree.attributes) =>
    switch (ParsetreeViewer.filterParsingAttrs(attrs)) {
    | [] => Doc.nil
    | attrs =>
      let lineBreak =
        switch (loc) {
        | None => Doc.line
        | Some(loc) =>
          switch (List.rev(attrs)) {
          | [({loc: firstLoc}, _), ..._]
              when loc.loc_start.pos_lnum > firstLoc.loc_end.pos_lnum => Doc.hardLine
          | _ => Doc.line
          }
        };

      Doc.concat([
        Doc.group(Doc.join(~sep=Doc.line, List.map(printAttribute, attrs))),
        lineBreak,
      ]);
    }

  and printAttribute = ((id, payload): Parsetree.attribute) => {
    let attrName = Doc.concat([Doc.text("@"), Doc.text(id.txt)]);
    switch (payload) {
    | PStr([{pstr_desc: [@implicit_arity] Pstr_eval(expr, attrs)}]) =>
      let exprDoc = printExpression(expr, CommentTable.empty);
      let needsParens =
        switch (attrs) {
        | [] => false
        | _ => true
        };
      Doc.group(
        Doc.concat([
          attrName,
          addParens(
            Doc.concat([
              printAttributes(attrs),
              if (needsParens) {
                addParens(exprDoc);
              } else {
                exprDoc;
              },
            ]),
          ),
        ]),
      );
    | PTyp(typ) =>
      Doc.group(
        Doc.concat([
          attrName,
          Doc.lparen,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.text(": "),
              printTypExpr(typ, CommentTable.empty),
            ]),
          ),
          Doc.softLine,
          Doc.rparen,
        ]),
      )
    | _ => attrName
    };
  }

  and printAttributeWithComments =
      ((id, payload): Parsetree.attribute, cmtTbl) => {
    let attrName = Doc.text("@" ++ id.txt);
    switch (payload) {
    | PStr([{pstr_desc: [@implicit_arity] Pstr_eval(expr, attrs)}]) =>
      let exprDoc = printExpressionWithComments(expr, cmtTbl);
      let needsParens =
        switch (attrs) {
        | [] => false
        | _ => true
        };
      Doc.group(
        Doc.concat([
          attrName,
          addParens(
            Doc.concat([
              printAttributes(attrs),
              if (needsParens) {
                addParens(exprDoc);
              } else {
                exprDoc;
              },
            ]),
          ),
        ]),
      );
    | _ => attrName
    };
  }

  and printModExpr = (modExpr, cmtTbl) => {
    let doc =
      switch (modExpr.pmod_desc) {
      | Pmod_ident(longidentLoc) =>
        printLongidentLocation(longidentLoc, cmtTbl)
      | Pmod_structure(structure) =>
        Doc.breakableGroup(
          ~forceBreak=true,
          Doc.concat([
            Doc.lbrace,
            Doc.indent(
              Doc.concat([Doc.softLine, printStructure(structure, cmtTbl)]),
            ),
            Doc.softLine,
            Doc.rbrace,
          ]),
        )
      | Pmod_unpack(expr) =>
        let shouldHug =
          switch (expr.pexp_desc) {
          | Pexp_let(_) => true
          | [@implicit_arity]
            Pexp_constraint(
              {pexp_desc: Pexp_let(_)},
              {ptyp_desc: Ptyp_package(_packageType)},
            ) =>
            true
          | _ => false
          };

        let (expr, moduleConstraint) =
          switch (expr.pexp_desc) {
          | [@implicit_arity]
            Pexp_constraint(
              expr,
              {ptyp_desc: Ptyp_package(packageType), ptyp_loc},
            ) =>
            let packageDoc = {
              let doc =
                printPackageType(
                  ~printModuleKeywordAndParens=false,
                  packageType,
                  cmtTbl,
                );
              printComments(doc, cmtTbl, ptyp_loc);
            };

            let typeDoc =
              Doc.group(
                Doc.concat([
                  Doc.text(":"),
                  Doc.indent(Doc.concat([Doc.line, packageDoc])),
                ]),
              );
            (expr, typeDoc);
          | _ => (expr, Doc.nil)
          };

        let unpackDoc =
          Doc.group(
            Doc.concat([
              printExpressionWithComments(expr, cmtTbl),
              moduleConstraint,
            ]),
          );
        Doc.group(
          Doc.concat([
            Doc.text("unpack("),
            if (shouldHug) {
              unpackDoc;
            } else {
              Doc.concat([
                Doc.indent(Doc.concat([Doc.softLine, unpackDoc])),
                Doc.softLine,
              ]);
            },
            Doc.rparen,
          ]),
        );
      | Pmod_extension(extension) =>
        printExtensionWithComments(~atModuleLvl=false, extension, cmtTbl)
      | Pmod_apply(_) =>
        let (args, callExpr) = ParsetreeViewer.modExprApply(modExpr);
        let isUnitSugar =
          switch (args) {
          | [{pmod_desc: Pmod_structure([])}] => true
          | _ => false
          };

        let shouldHug =
          switch (args) {
          | [{pmod_desc: Pmod_structure(_)}] => true
          | _ => false
          };

        Doc.group(
          Doc.concat([
            printModExpr(callExpr, cmtTbl),
            if (isUnitSugar) {
              printModApplyArg([@doesNotRaise] List.hd(args), cmtTbl);
            } else {
              Doc.concat([
                Doc.lparen,
                if (shouldHug) {
                  printModApplyArg([@doesNotRaise] List.hd(args), cmtTbl);
                } else {
                  Doc.indent(
                    Doc.concat([
                      Doc.softLine,
                      Doc.join(
                        ~sep=Doc.concat([Doc.comma, Doc.line]),
                        List.map(
                          modArg => printModApplyArg(modArg, cmtTbl),
                          args,
                        ),
                      ),
                    ]),
                  );
                },
                if (!shouldHug) {
                  Doc.concat([Doc.trailingComma, Doc.softLine]);
                } else {
                  Doc.nil;
                },
                Doc.rparen,
              ]);
            },
          ]),
        );
      | [@implicit_arity] Pmod_constraint(modExpr, modType) =>
        Doc.concat([
          printModExpr(modExpr, cmtTbl),
          Doc.text(": "),
          printModType(modType, cmtTbl),
        ])
      | Pmod_functor(_) => printModFunctor(modExpr, cmtTbl)
      };

    printComments(doc, cmtTbl, modExpr.pmod_loc);
  }

  and printModFunctor = (modExpr, cmtTbl) => {
    let (parameters, returnModExpr) =
      ParsetreeViewer.modExprFunctor(modExpr);
    /* let shouldInline = match returnModExpr.pmod_desc with */
    /* | Pmod_structure _ | Pmod_ident _ -> true */
    /* | Pmod_constraint ({pmod_desc = Pmod_structure _}, _) -> true */
    /* | _ -> false */
    /* in */
    let (returnConstraint, returnModExpr) =
      switch (returnModExpr.pmod_desc) {
      | [@implicit_arity] Pmod_constraint(modExpr, modType) =>
        let constraintDoc = {
          let doc = printModType(modType, cmtTbl);
          if (Parens.modExprFunctorConstraint(modType)) {
            addParens(doc);
          } else {
            doc;
          };
        };

        let modConstraint = Doc.concat([Doc.text(": "), constraintDoc]);
        (modConstraint, printModExpr(modExpr, cmtTbl));
      | _ => (Doc.nil, printModExpr(returnModExpr, cmtTbl))
      };

    let parametersDoc =
      switch (parameters) {
      | [(attrs, {txt: "*"}, None)] =>
        let attrs =
          switch (attrs) {
          | [] => Doc.nil
          | attrs =>
            Doc.concat([
              Doc.join(~sep=Doc.line, List.map(printAttribute, attrs)),
              Doc.line,
            ])
          };
        Doc.group(Doc.concat([attrs, Doc.text("()")]));
      | [([], {txt: lbl}, None)] => Doc.text(lbl)
      | parameters =>
        Doc.group(
          Doc.concat([
            Doc.lparen,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.comma, Doc.line]),
                  List.map(
                    param => printModFunctorParam(param, cmtTbl),
                    parameters,
                  ),
                ),
              ]),
            ),
            Doc.trailingComma,
            Doc.softLine,
            Doc.rparen,
          ]),
        )
      };

    Doc.group(
      Doc.concat([
        parametersDoc,
        returnConstraint,
        Doc.text(" => "),
        returnModExpr,
      ]),
    );
  }

  and printModFunctorParam = ((attrs, lbl, optModType), cmtTbl) => {
    let cmtLoc =
      switch (optModType) {
      | None => lbl.Asttypes.loc
      | Some(modType) => {
          ...lbl.loc,
          loc_end: modType.Parsetree.pmty_loc.loc_end,
        }
      };

    let attrs =
      switch (attrs) {
      | [] => Doc.nil
      | attrs =>
        Doc.concat([
          Doc.join(~sep=Doc.line, List.map(printAttribute, attrs)),
          Doc.line,
        ])
      };
    let lblDoc = {
      let doc = Doc.text(lbl.txt);
      printComments(doc, cmtTbl, lbl.loc);
    };

    let doc =
      Doc.group(
        Doc.concat([
          attrs,
          lblDoc,
          switch (optModType) {
          | None => Doc.nil
          | Some(modType) =>
            Doc.concat([Doc.text(": "), printModType(modType, cmtTbl)])
          },
        ]),
      );
    printComments(doc, cmtTbl, cmtLoc);
  }

  and printModApplyArg = (modExpr, cmtTbl) =>
    switch (modExpr.pmod_desc) {
    | Pmod_structure([]) => Doc.text("()")
    | _ => printModExpr(modExpr, cmtTbl)
    }

  and printExceptionDef = (constr: Parsetree.extension_constructor, cmtTbl) => {
    let kind =
      switch (constr.pext_kind) {
      | Pext_rebind(longident) =>
        Doc.indent(
          Doc.concat([
            Doc.text(" ="),
            Doc.line,
            printLongidentLocation(longident, cmtTbl),
          ]),
        )
      | [@implicit_arity] Pext_decl(Pcstr_tuple([]), None) => Doc.nil
      | [@implicit_arity] Pext_decl(args, gadt) =>
        let gadtDoc =
          switch (gadt) {
          | Some(typ) =>
            Doc.concat([Doc.text(": "), printTypExpr(typ, cmtTbl)])
          | None => Doc.nil
          };

        Doc.concat([
          printConstructorArguments(~indent=false, args, cmtTbl),
          gadtDoc,
        ]);
      };

    let name =
      printComments(
        Doc.text(constr.pext_name.txt),
        cmtTbl,
        constr.pext_name.loc,
      );

    let doc =
      Doc.group(
        Doc.concat([
          printAttributes(constr.pext_attributes),
          Doc.text("exception "),
          name,
          kind,
        ]),
      );
    printComments(doc, cmtTbl, constr.pext_loc);
  }

  and printExtensionConstructor =
      (constr: Parsetree.extension_constructor, cmtTbl, i) => {
    let attrs = printAttributes(constr.pext_attributes);
    let bar =
      if (i > 0) {
        Doc.text("| ");
      } else {
        Doc.ifBreaks(Doc.text("| "), Doc.nil);
      };

    let kind =
      switch (constr.pext_kind) {
      | Pext_rebind(longident) =>
        Doc.indent(
          Doc.concat([
            Doc.text(" ="),
            Doc.line,
            printLongidentLocation(longident, cmtTbl),
          ]),
        )
      | [@implicit_arity] Pext_decl(Pcstr_tuple([]), None) => Doc.nil
      | [@implicit_arity] Pext_decl(args, gadt) =>
        let gadtDoc =
          switch (gadt) {
          | Some(typ) =>
            Doc.concat([Doc.text(": "), printTypExpr(typ, cmtTbl)])
          | None => Doc.nil
          };

        Doc.concat([
          printConstructorArguments(~indent=false, args, cmtTbl),
          gadtDoc,
        ]);
      };

    let name =
      printComments(
        Doc.text(constr.pext_name.txt),
        cmtTbl,
        constr.pext_name.loc,
      );

    Doc.concat([bar, Doc.group(Doc.concat([attrs, name, kind]))]);
  };

  let printImplementation = (~width, s: Parsetree.structure, comments) => {
    let cmtTbl = CommentTable.make();
    CommentTable.walkStructure(s, cmtTbl, comments);
    /* CommentTable.log cmtTbl; */
    let doc = printStructure(s, cmtTbl);
    /* Doc.debug doc; */
    let stringDoc = Doc.toString(~width, doc);
    print_string(stringDoc);
  };

  let printInterface = (~width, s: Parsetree.signature, comments) => {
    let cmtTbl = CommentTable.make();
    CommentTable.walkSignature(s, cmtTbl, comments);
    let stringDoc = Doc.toString(~width, printSignature(s, cmtTbl));
    print_string(stringDoc);
  };
};

module Scanner = {
  type mode =
    | Template
    | Jsx
    | Diamond;

  type t = {
    filename: string,
    src: bytes,
    mutable err:
      (
        ~startPos: Lexing.position,
        ~endPos: Lexing.position,
        Diagnostics.category
      ) =>
      unit,
    mutable ch: int, /* current character */
    mutable offset: int, /* character offset */
    mutable rdOffset: int, /* reading offset (position after current character) */
    mutable lineOffset: int, /* current line offset */
    mutable lnum: int, /* current line number */
    mutable mode: list(mode),
  };

  let setDiamondMode = scanner => scanner.mode = [Diamond, ...scanner.mode];

  let setTemplateMode = scanner => scanner.mode = [Template, ...scanner.mode];

  let setJsxMode = scanner => scanner.mode = [Jsx, ...scanner.mode];

  let popMode = (scanner, mode) =>
    switch (scanner.mode) {
    | [m, ...ms] when m == mode => scanner.mode = ms
    | _ => ()
    };

  let inDiamondMode = scanner =>
    switch (scanner.mode) {
    | [Diamond, ..._] => true
    | _ => false
    };

  let inJsxMode = scanner =>
    switch (scanner.mode) {
    | [Jsx, ..._] => true
    | _ => false
    };

  let inTemplateMode = scanner =>
    switch (scanner.mode) {
    | [Template, ..._] => true
    | _ => false
    };

  let position = scanner =>
    Lexing.{
      pos_fname: scanner.filename,
      /* line number */
      pos_lnum: scanner.lnum,
      /* offset of the beginning of the line (number
         of characters between the beginning of the scanner and the beginning
         of the line) */
      pos_bol: scanner.lineOffset,
      /* [pos_cnum] is the offset of the position (number of
         characters between the beginning of the scanner and the position). */
      pos_cnum: scanner.offset,
    };

  let next = scanner =>
    if (scanner.rdOffset < Bytes.length(scanner.src)) {
      scanner.offset = scanner.rdOffset;
      let ch = ([@doesNotRaise] Bytes.get)(scanner.src, scanner.rdOffset);
      scanner.rdOffset = scanner.rdOffset + 1;
      scanner.ch = int_of_char(ch);
    } else {
      scanner.offset = Bytes.length(scanner.src);
      scanner.ch = (-1);
    };

  let peek = scanner =>
    if (scanner.rdOffset < Bytes.length(scanner.src)) {
      int_of_char(Bytes.unsafe_get(scanner.src, scanner.rdOffset));
    } else {
      (-1);
    };

  let make = (b, filename) => {
    let scanner = {
      filename,
      src: b,
      err: (~startPos as _, ~endPos as _, _) => (),
      ch: CharacterCodes.space,
      offset: 0,
      rdOffset: 0,
      lineOffset: 0,
      lnum: 1,
      mode: [],
    };
    next(scanner);
    scanner;
  };

  let skipWhitespace = scanner => {
    let rec scan = () =>
      if (scanner.ch === CharacterCodes.space
          || scanner.ch === CharacterCodes.tab) {
        next(scanner);
        scan();
      } else if (CharacterCodes.isLineBreak(scanner.ch)) {
        scanner.lineOffset = scanner.offset + 1;
        scanner.lnum = scanner.lnum + 1;
        next(scanner);
        scan();
      } else {
        ();
      };

    scan();
  };

  let scanIdentifier = scanner => {
    let startOff = scanner.offset;
    while (CharacterCodes.isLetter(scanner.ch)
           || CharacterCodes.isDigit(scanner.ch)
           || CharacterCodes.underscore === scanner.ch
           || CharacterCodes.singleQuote === scanner.ch) {
      next(scanner);
    };
    let str =
      Bytes.sub_string(scanner.src, startOff, scanner.offset - startOff);
    Token.lookupKeyword(str);
  };

  let scanDigits = (scanner, ~base) =>
    if (base <= 10) {
      while (CharacterCodes.isDigit(scanner.ch)
             || scanner.ch === CharacterCodes.underscore) {
        next(scanner);
      };
    } else {
      while (CharacterCodes.isHex(scanner.ch)
             || scanner.ch === CharacterCodes.underscore) {
        next(scanner);
      };
    };

  /* float: (0…9) { 0…9∣ _ } [. { 0…9∣ _ }] [(e∣ E) [+∣ -] (0…9) { 0…9∣ _ }]   */
  let scanNumber = scanner => {
    let startOff = scanner.offset;

    /* integer part */
    let (base, _prefix) =
      if (scanner.ch !== CharacterCodes.dot) {
        if (scanner.ch === CharacterCodes._0) {
          next(scanner);
          let ch = CharacterCodes.lower(scanner.ch);
          if (ch === CharacterCodes.Lower.x) {
            next(scanner);
            (16, 'x');
          } else if (ch === CharacterCodes.Lower.o) {
            next(scanner);
            (8, 'o');
          } else if (ch === CharacterCodes.Lower.b) {
            next(scanner);
            (2, 'b');
          } else {
            (8, '0');
          };
        } else {
          (10, ' ');
        };
      } else {
        (10, ' ');
      };

    scanDigits(scanner, ~base);

    /*  */
    let isFloat =
      if (CharacterCodes.dot === scanner.ch) {
        next(scanner);
        scanDigits(scanner, ~base);
        true;
      } else {
        false;
      };

    /* exponent part */
    let isFloat =
      if ({
            let exp = CharacterCodes.lower(scanner.ch);
            exp === CharacterCodes.Lower.e || exp === CharacterCodes.Lower.p;
          }) {
        next(scanner);
        if (scanner.ch === CharacterCodes.plus
            || scanner.ch === CharacterCodes.minus) {
          next(scanner);
        };
        scanDigits(scanner, ~base);
        true;
      } else {
        isFloat;
      };

    let literal =
      Bytes.sub_string(scanner.src, startOff, scanner.offset - startOff);

    /* suffix */
    let suffix =
      if (scanner.ch >= CharacterCodes.Lower.g
          && scanner.ch <= CharacterCodes.Lower.z
          || scanner.ch >= CharacterCodes.Upper.g
          && scanner.ch <= CharacterCodes.Upper.z) {
        let ch = scanner.ch;
        next(scanner);
        Some(Char.unsafe_chr(ch));
      } else {
        None;
      };

    if (isFloat) {
      Token.Float({f: literal, suffix});
    } else {
      Token.Int({i: literal, suffix});
    };
  };

  let scanExoticIdentifier = scanner => {
    next(scanner);
    let buffer = Buffer.create(20);
    let startPos = position(scanner);

    let rec scan = () =>
      if (scanner.ch === CharacterCodes.eof) {
        let endPos = position(scanner);
        scanner.err(
          ~startPos,
          ~endPos,
          Diagnostics.message("Did you forget a \" here?"),
        );
      } else if (scanner.ch === CharacterCodes.doubleQuote) {
        next(scanner);
      } else if (CharacterCodes.isLineBreak(scanner.ch)) {
        scanner.lineOffset = scanner.offset + 1;
        scanner.lnum = scanner.lnum + 1;
        let endPos = position(scanner);
        scanner.err(
          ~startPos,
          ~endPos,
          Diagnostics.message("Did you forget a \" here?"),
        );
        next(scanner);
      } else {
        Buffer.add_char(buffer, ([@doesNotRaise] Char.chr)(scanner.ch));
        next(scanner);
        scan();
      };

    scan();
    Token.Lident(Buffer.contents(buffer));
  };

  let scanStringEscapeSequence = (~startPos, scanner) =>
    /* \ already consumed */
    if (CharacterCodes.Lower.n === scanner.ch
        || CharacterCodes.Lower.t === scanner.ch
        || CharacterCodes.Lower.b === scanner.ch
        || CharacterCodes.Lower.r === scanner.ch
        || CharacterCodes.backslash === scanner.ch
        || CharacterCodes.space === scanner.ch
        || CharacterCodes.singleQuote === scanner.ch
        || CharacterCodes.doubleQuote === scanner.ch) {
      next(scanner);
    } else {
      let (n, base, max) =
        if (CharacterCodes.isDigit(scanner.ch)) {
          /* decimal */
          (3, 10, 255);
        } else if (scanner.ch === CharacterCodes.Lower.o) {
          /* octal */
          let () = next(scanner);
          (3, 8, 255);
        } else if (scanner.ch === CharacterCodes.Lower.x) {
          /* hex */
          let () = next(scanner);
          (2, 16, 255);
        } else {
          /* unknown escape sequence
           * TODO: we should warn the user here. Let's not make it a hard error for now, for reason compat */
          /* let pos = position scanner in */
          /* let () = */
          /* let msg = if scanner.ch == -1 then */
          /* "unclosed escape sequence" */
          /* else "unknown escape sequence" */
          /* in */
          /* scanner.err ~startPos ~endPos:pos (Diagnostics.message msg) */
          /* in */
          ((-1), (-1), (-1));
        };

      if (n < 0) {
        ();
      } else {
        let rec while_ = (n, x) =>
          if (n === 0) {
            x;
          } else {
            let d = CharacterCodes.digitValue(scanner.ch);
            if (d >= base) {
              let pos = position(scanner);
              let msg =
                if (scanner.ch === (-1)) {
                  "unclosed escape sequence";
                } else {
                  "unknown escape sequence";
                };

              scanner.err(~startPos, ~endPos=pos, Diagnostics.message(msg));
              (-1);
            } else {
              let () = next(scanner);
              while_(n - 1, x * base + d);
            };
          };

        let x = while_(n, 0);
        if (x > max) {
          let pos = position(scanner);
          let msg = "invalid escape sequence (value too high)";
          scanner.err(~startPos, ~endPos=pos, Diagnostics.message(msg));
          ();
        };
      };
    };

  let scanString = scanner => {
    let offs = scanner.offset;

    let startPos = position(scanner);
    let rec scan = () =>
      if (scanner.ch === CharacterCodes.eof) {
        let endPos = position(scanner);
        scanner.err(~startPos, ~endPos, Diagnostics.unclosedString);
      } else if (scanner.ch === CharacterCodes.doubleQuote) {
        next(scanner);
      } else if (scanner.ch === CharacterCodes.backslash) {
        let startPos = position(scanner);
        next(scanner);
        scanStringEscapeSequence(~startPos, scanner);
        scan();
      } else if (CharacterCodes.isLineBreak(scanner.ch)) {
        scanner.lineOffset = scanner.offset + 1;
        scanner.lnum = scanner.lnum + 1;
        next(scanner);
        scan();
      } else {
        next(scanner);
        scan();
      };

    scan();
    Token.String(
      Bytes.sub_string(scanner.src, offs, scanner.offset - offs - 1),
    );
  };

  /* I wonder if this gets inlined */
  let convertNumber = (scanner, ~n, ~base) => {
    let x = ref(0);
    for (_ in n downto 1) {
      let d = CharacterCodes.digitValue(scanner.ch);
      x := x^ * base + d;
      next(scanner);
    };
    x^;
  };

  let scanEscape = scanner => {
    /* let offset = scanner.offset in */
    let c =
      switch (scanner.ch) {
      | 98 /* b */ =>
        next(scanner);
        '\b';
      | 110 /* n */ =>
        next(scanner);
        '\n';
      | 114 /* r */ =>
        next(scanner);
        '\r';
      | 116 /* t */ =>
        next(scanner);
        '\t';
      | ch when CharacterCodes.isDigit(ch) =>
        let x = convertNumber(scanner, ~n=3, ~base=10);
        ([@doesNotRaise] Char.chr)(x);
      | ch when ch === CharacterCodes.Lower.x =>
        next(scanner);
        let x = convertNumber(scanner, ~n=2, ~base=16);
        ([@doesNotRaise] Char.chr)(x);
      | ch when ch === CharacterCodes.Lower.o =>
        next(scanner);
        let x = convertNumber(scanner, ~n=3, ~base=8);
        ([@doesNotRaise] Char.chr)(x);
      | ch =>
        next(scanner);
        ([@doesNotRaise] Char.chr)(ch);
      };

    next(scanner); /* Consume \' */
    Token.Character(c);
  };

  let scanSingleLineComment = scanner => {
    let startOff = scanner.offset;
    let startPos = position(scanner);
    while (!CharacterCodes.isLineBreak(scanner.ch) && scanner.ch >= 0) {
      next(scanner);
    };
    let endPos = position(scanner);
    Token.Comment(
      Comment.makeSingleLineComment(
        ~loc=
          Location.{loc_start: startPos, loc_end: endPos, loc_ghost: false},
        Bytes.sub_string(scanner.src, startOff, scanner.offset - startOff),
      ),
    );
  };

  let scanMultiLineComment = scanner => {
    let startOff = scanner.offset;
    let startPos = position(scanner);
    let rec scan = (~depth, ()) =>
      if (scanner.ch === CharacterCodes.asterisk
          && peek(scanner) === CharacterCodes.forwardslash) {
        next(scanner);
        next(scanner);
        if (depth > 0) {
          scan(~depth=depth - 1, ());
        } else {
          ();
        };
      } else if (scanner.ch === CharacterCodes.eof) {
        let endPos = position(scanner);
        scanner.err(~startPos, ~endPos, Diagnostics.unclosedComment);
      } else if (scanner.ch === CharacterCodes.forwardslash
                 && peek(scanner) === CharacterCodes.asterisk) {
        next(scanner);
        next(scanner);
        scan(~depth=depth + 1, ());
      } else {
        if (CharacterCodes.isLineBreak(scanner.ch)) {
          scanner.lineOffset = scanner.offset + 1;
          scanner.lnum = scanner.lnum + 1;
        };
        next(scanner);
        scan(~depth, ());
      };

    scan(~depth=0, ());
    Token.Comment(
      Comment.makeMultiLineComment(
        ~loc=
          Location.{
            loc_start: startPos,
            loc_end: position(scanner),
            loc_ghost: false,
          },
        Bytes.sub_string(
          scanner.src,
          startOff,
          scanner.offset - 2 - startOff,
        ),
      ),
    );
  };

  let scanTemplate = scanner => {
    let startOff = scanner.offset;
    let startPos = position(scanner);

    let rec scan = () =>
      if (scanner.ch === CharacterCodes.eof) {
        let endPos = position(scanner);
        scanner.err(~startPos, ~endPos, Diagnostics.unclosedTemplate);
        popMode(scanner, Template);
        Token.TemplateTail(
          Bytes.sub_string(
            scanner.src,
            startOff,
            scanner.offset - 2 - startOff,
          ),
        );
      } else if (scanner.ch === CharacterCodes.backslash) {
        next(scanner);
        if (scanner.ch === CharacterCodes.backtick
            || scanner.ch === CharacterCodes.backslash
            || scanner.ch === CharacterCodes.dollar) {
          next(scanner);
        };
        scan();
      } else if (scanner.ch === CharacterCodes.backtick) {
        next(scanner);
        let contents =
          Bytes.sub_string(
            scanner.src,
            startOff,
            scanner.offset - 1 - startOff,
          );

        popMode(scanner, Template);
        Token.TemplateTail(contents);
      } else if (scanner.ch === CharacterCodes.dollar
                 && peek(scanner) === CharacterCodes.lbrace) {
        next(scanner); /* consume $ */
        next(scanner); /* consume { */
        let contents =
          Bytes.sub_string(
            scanner.src,
            startOff,
            scanner.offset - 2 - startOff,
          );

        popMode(scanner, Template);
        Token.TemplatePart(contents);
      } else {
        if (CharacterCodes.isLineBreak(scanner.ch)) {
          scanner.lineOffset = scanner.offset + 1;
          scanner.lnum = scanner.lnum + 1;
        };
        next(scanner);
        scan();
      };

    scan();
  };

  let rec scan = scanner => {
    if (!inTemplateMode(scanner)) {
      skipWhitespace(scanner);
    };
    let startPos = position(scanner);
    let ch = scanner.ch;
    let token =
      if (inTemplateMode(scanner)) {
        scanTemplate(scanner);
      } else if (ch === CharacterCodes.underscore) {
        let nextCh = peek(scanner);
        if (nextCh === CharacterCodes.underscore
            || CharacterCodes.isDigit(nextCh)
            || CharacterCodes.isLetter(nextCh)) {
          scanIdentifier(scanner);
        } else {
          next(scanner);
          Token.Underscore;
        };
      } else if (CharacterCodes.isLetter(ch)) {
        scanIdentifier(scanner);
      } else if (CharacterCodes.isDigit(ch)) {
        scanNumber(scanner);
      } else {
        next(scanner);
        if (ch === CharacterCodes.dot) {
          if (scanner.ch === CharacterCodes.dot) {
            next(scanner);
            if (scanner.ch === CharacterCodes.dot) {
              next(scanner);
              Token.DotDotDot;
            } else {
              Token.DotDot;
            };
          } else {
            Token.Dot;
          };
        } else if (ch === CharacterCodes.doubleQuote) {
          scanString(scanner);
        } else if (ch === CharacterCodes.singleQuote) {
          if (scanner.ch === CharacterCodes.backslash
              && !(peek(scanner) === CharacterCodes.doubleQuote)) {
            /* start of exotic ident */

            next(scanner);
            scanEscape(scanner);
          } else if (peek(scanner) === CharacterCodes.singleQuote) {
            let ch = scanner.ch;
            next(scanner);
            next(scanner);
            Token.Character(([@doesNotRaise] Char.chr)(ch));
          } else {
            SingleQuote;
          };
        } else if (ch === CharacterCodes.bang) {
          if (scanner.ch === CharacterCodes.equal) {
            next(scanner);
            if (scanner.ch === CharacterCodes.equal) {
              next(scanner);
              Token.BangEqualEqual;
            } else {
              Token.BangEqual;
            };
          } else {
            Token.Bang;
          };
        } else if (ch === CharacterCodes.semicolon) {
          Token.Semicolon;
        } else if (ch === CharacterCodes.equal) {
          if (scanner.ch === CharacterCodes.greaterThan) {
            next(scanner);
            Token.EqualGreater;
          } else if (scanner.ch === CharacterCodes.equal) {
            next(scanner);
            if (scanner.ch === CharacterCodes.equal) {
              next(scanner);
              Token.EqualEqualEqual;
            } else {
              Token.EqualEqual;
            };
          } else {
            Token.Equal;
          };
        } else if (ch === CharacterCodes.bar) {
          if (scanner.ch === CharacterCodes.bar) {
            next(scanner);
            Token.Lor;
          } else if (scanner.ch === CharacterCodes.greaterThan) {
            next(scanner);
            Token.BarGreater;
          } else {
            Token.Bar;
          };
        } else if (ch === CharacterCodes.ampersand) {
          if (scanner.ch === CharacterCodes.ampersand) {
            next(scanner);
            Token.Land;
          } else {
            Token.Band;
          };
        } else if (ch === CharacterCodes.lparen) {
          Token.Lparen;
        } else if (ch === CharacterCodes.rparen) {
          Token.Rparen;
        } else if (ch === CharacterCodes.lbracket) {
          Token.Lbracket;
        } else if (ch === CharacterCodes.rbracket) {
          Token.Rbracket;
        } else if (ch === CharacterCodes.lbrace) {
          Token.Lbrace;
        } else if (ch === CharacterCodes.rbrace) {
          Token.Rbrace;
        } else if (ch === CharacterCodes.comma) {
          Token.Comma;
        } else if (ch === CharacterCodes.colon) {
          if (scanner.ch === CharacterCodes.equal) {
            next(scanner);
            Token.ColonEqual;
          } else if (scanner.ch === CharacterCodes.greaterThan) {
            next(scanner);
            Token.ColonGreaterThan;
          } else {
            Token.Colon;
          };
        } else if (ch === CharacterCodes.backslash) {
          scanExoticIdentifier(scanner);
        } else if (ch === CharacterCodes.forwardslash) {
          if (scanner.ch === CharacterCodes.forwardslash) {
            next(scanner);
            scanSingleLineComment(scanner);
          } else if (scanner.ch === CharacterCodes.asterisk) {
            next(scanner);
            scanMultiLineComment(scanner);
          } else if (scanner.ch === CharacterCodes.dot) {
            next(scanner);
            Token.ForwardslashDot;
          } else {
            Token.Forwardslash;
          };
        } else if (ch === CharacterCodes.minus) {
          if (scanner.ch === CharacterCodes.dot) {
            next(scanner);
            Token.MinusDot;
          } else if (scanner.ch === CharacterCodes.greaterThan) {
            next(scanner);
            Token.MinusGreater;
          } else {
            Token.Minus;
          };
        } else if (ch === CharacterCodes.plus) {
          if (scanner.ch === CharacterCodes.dot) {
            next(scanner);
            Token.PlusDot;
          } else if (scanner.ch === CharacterCodes.plus) {
            next(scanner);
            Token.PlusPlus;
          } else if (scanner.ch === CharacterCodes.equal) {
            next(scanner);
            Token.PlusEqual;
          } else {
            Token.Plus;
          };
        } else if (ch === CharacterCodes.greaterThan) {
          if (scanner.ch === CharacterCodes.equal && !inDiamondMode(scanner)) {
            next(scanner);
            Token.GreaterEqual;
          } else {
            Token.GreaterThan;
          };
        } else if (ch === CharacterCodes.lessThan) {
          /* Imagine the following: <div><
           * < indicates the start of a new jsx-element, the parser expects
           * the name of a new element after the <
           * Example: <div> <div
           * But what if we have a / here: example </ in  <div></div>
           * This signals a closing element. To simulate the two-token lookahead,
           * the </ is emitted as a single new token LessThanSlash */
          if (inJsxMode(scanner)) {
            skipWhitespace(scanner);
            if (scanner.ch === CharacterCodes.forwardslash) {
              let () = next(scanner);
              Token.LessThanSlash;
            } else {
              Token.LessThan;
            };
          } else if (scanner.ch === CharacterCodes.equal) {
            next(scanner);
            Token.LessEqual;
          } else {
            Token.LessThan;
          };
        } else if (ch === CharacterCodes.hash) {
          if (scanner.ch === CharacterCodes.hash) {
            next(scanner);
            Token.HashHash;
          } else if (scanner.ch === CharacterCodes.equal) {
            next(scanner);
            Token.HashEqual;
          } else {
            Token.Hash;
          };
        } else if (ch === CharacterCodes.asterisk) {
          if (scanner.ch === CharacterCodes.asterisk) {
            next(scanner);
            Token.Exponentiation;
          } else if (scanner.ch === CharacterCodes.dot) {
            next(scanner);
            Token.AsteriskDot;
          } else {
            Token.Asterisk;
          };
        } else if (ch === CharacterCodes.tilde) {
          Token.Tilde;
        } else if (ch === CharacterCodes.question) {
          Token.Question;
        } else if (ch === CharacterCodes.at) {
          if (scanner.ch === CharacterCodes.at) {
            next(scanner);
            Token.AtAt;
          } else {
            Token.At;
          };
        } else if (ch === CharacterCodes.percent) {
          if (scanner.ch === CharacterCodes.percent) {
            next(scanner);
            Token.PercentPercent;
          } else {
            Token.Percent;
          };
        } else if (ch === CharacterCodes.backtick) {
          Token.Backtick;
        } else if (ch === (-1)) {
          Token.Eof;
        } else {
          /* if we arrive here, we're dealing with an unkown character,
           * report the error and continue scanning… */
          let endPos = position(scanner);
          scanner.err(~startPos, ~endPos, Diagnostics.unknownUchar(ch));
          let (_, _, token) = scan(scanner);
          token;
        };
      };
    let endPos = position(scanner);
    (startPos, endPos, token);
  };

  /* Imagine: <div> <Navbar /> <
   * is `<` the start of a jsx-child? <div …
   * or is it the start of a closing tag?  </div>
   * reconsiderLessThan peeks at the next token and
   * determines the correct token to disambiguate */
  let reconsiderLessThan = scanner => {
    /* < consumed */
    skipWhitespace(scanner);
    if (scanner.ch === CharacterCodes.forwardslash) {
      let () = next(scanner);
      Token.LessThanSlash;
    } else {
      Token.LessThan;
    };
  };

  /* If an operator has whitespace around both sides, it's a binary operator */
  let isBinaryOp = (src, startCnum, endCnum) =>
    if (startCnum === 0) {
      false;
    } else {
      let leftOk = {
        let c =
          startCnum - 1 |> ([@doesNotRaise] Bytes.get)(src) |> Char.code;

        c === CharacterCodes.space
        || c === CharacterCodes.tab
        || CharacterCodes.isLineBreak(c);
      };

      let rightOk = {
        let c =
          if (endCnum === Bytes.length(src)) {
            (-1);
          } else {
            endCnum |> ([@doesNotRaise] Bytes.get)(src) |> Char.code;
          };

        c === CharacterCodes.space
        || c === CharacterCodes.tab
        || CharacterCodes.isLineBreak(c)
        || c === CharacterCodes.eof;
      };

      leftOk && rightOk;
    };
};

/* AST for js externals */
module JsFfi = {
  type scope =
    | Global
    | Module(string) /* bs.module("path") */
    | Scope(Longident.t); /* bs.scope(/"window", "location"/) */

  type label_declaration = {
    [@live]
    jld_attributes: Parsetree.attributes,
    jld_name: string,
    jld_alias: string,
    jld_type: Parsetree.core_type,
    jld_loc: Location.t,
  };

  type importSpec =
    | Default(label_declaration)
    | Spec(list(label_declaration));

  type import_description = {
    jid_loc: Location.t,
    jid_spec: importSpec,
    jid_scope: scope,
    jid_attributes: Parsetree.attributes,
  };

  let decl = (~attrs, ~loc, ~name, ~alias, ~typ) => {
    jld_loc: loc,
    jld_attributes: attrs,
    jld_name: name,
    jld_alias: alias,
    jld_type: typ,
  };

  let importDescr = (~attrs, ~scope, ~importSpec, ~loc) => {
    jid_loc: loc,
    jid_spec: importSpec,
    jid_scope: scope,
    jid_attributes: attrs,
  };

  let toParsetree = importDescr => {
    let bsVal = (Location.mknoloc("bs.val"), Parsetree.PStr([]));
    let attrs =
      switch (importDescr.jid_scope) {
      | Global => [bsVal]
      /* @genType.import("./MyMath"),
       * @genType.import(/"./MyMath", "default"/) */
      | Module(s) =>
        let structure = [
          [@implicit_arity] Parsetree.Pconst_string(s, None)
          |> Ast_helper.Exp.constant
          |> Ast_helper.Str.eval,
        ];
        let genType = (
          Location.mknoloc("genType.import"),
          Parsetree.PStr(structure),
        );
        [genType];
      | Scope(longident) =>
        let structureItem = {
          let expr =
            switch (
              Longident.flatten(longident)
              |> List.map(s =>
                   Ast_helper.Exp.constant(
                     [@implicit_arity] Parsetree.Pconst_string(s, None),
                   )
                 )
            ) {
            | [expr] => expr
            | [] as exprs
            | _ as exprs => exprs |> Ast_helper.Exp.tuple
            };

          Ast_helper.Str.eval(expr);
        };

        let bsScope = (
          Location.mknoloc("bs.scope"),
          Parsetree.PStr([structureItem]),
        );
        [bsVal, bsScope];
      };

    let valueDescrs =
      switch (importDescr.jid_spec) {
      | Default(decl) =>
        let prim = [decl.jld_name];
        let allAttrs =
          List.concat([attrs, importDescr.jid_attributes])
          |> List.map(attr =>
               switch (attr) {
               | (
                   {Location.txt: "genType.import"} as id,
                   Parsetree.PStr([
                     {
                       pstr_desc:
                         [@implicit_arity] Parsetree.Pstr_eval(moduleName, _),
                     },
                   ]),
                 ) =>
                 let default =
                   [@implicit_arity] Parsetree.Pconst_string("default", None)
                   |> Ast_helper.Exp.constant;

                 let structureItem =
                   [moduleName, default]
                   |> Ast_helper.Exp.tuple
                   |> Ast_helper.Str.eval;

                 (id, Parsetree.PStr([structureItem]));
               | attr => attr
               }
             );

        [
          Ast_helper.Val.mk(
            ~loc=importDescr.jid_loc,
            ~prim,
            ~attrs=allAttrs,
            Location.mknoloc(decl.jld_alias),
            decl.jld_type,
          )
          |> Ast_helper.Str.primitive,
        ];
      | Spec(decls) =>
        List.map(
          decl => {
            let prim = [decl.jld_name];
            let allAttrs = List.concat([attrs, decl.jld_attributes]);
            Ast_helper.Val.mk(
              ~loc=importDescr.jid_loc,
              ~prim,
              ~attrs=allAttrs,
              Location.mknoloc(decl.jld_alias),
              decl.jld_type,
            )
            |> Ast_helper.Str.primitive(~loc=decl.jld_loc);
          },
          decls,
        )
      };

    let jsFfiAttr = (Location.mknoloc("ns.jsFfi"), Parsetree.PStr([]));
    Ast_helper.Mod.structure(~loc=importDescr.jid_loc, valueDescrs)
    |> Ast_helper.Incl.mk(~attrs=[jsFfiAttr], ~loc=importDescr.jid_loc)
    |> Ast_helper.Str.include_(~loc=importDescr.jid_loc);
  };
};

module ParsetreeCompatibility = {
  let concatLongidents = (l1, l2) => {
    let parts1 = Longident.flatten(l1);
    let parts2 = Longident.flatten(l2);
    switch (List.concat([parts1, parts2]) |> Longident.unflatten) {
    | Some(longident) => longident
    | None => l2
    };
  };

  /* TODO: support nested open's ? */
  let rec rewritePpatOpen = (longidentOpen, pat) =>
    Parsetree.(
      switch (pat.ppat_desc) {
      | Ppat_array([first, ...rest]) =>
        /* Color.[Red, Blue, Green] -> [Color.Red, Blue, Green] */
        {
          ...pat,
          ppat_desc:
            Ppat_array([rewritePpatOpen(longidentOpen, first), ...rest]),
        }
      | Ppat_tuple([first, ...rest]) =>
        /* Color.(Red, Blue, Green) -> (Color.Red, Blue, Green) */
        {
          ...pat,
          ppat_desc:
            Ppat_tuple([rewritePpatOpen(longidentOpen, first), ...rest]),
        }
      | [@implicit_arity]
        Ppat_construct(
          {txt: Longident.Lident("::")} as listConstructor,
          Some({ppat_desc: Ppat_tuple([pat, ...rest])} as element),
        ) =>
        /* Color.(list[Red, Blue, Green]) -> list[Color.Red, Blue, Green] */
        {
          ...pat,
          ppat_desc:
            [@implicit_arity]
            Ppat_construct(
              listConstructor,
              Some({
                ...element,
                ppat_desc:
                  Ppat_tuple([rewritePpatOpen(longidentOpen, pat), ...rest]),
              }),
            ),
        }
      | [@implicit_arity]
        Ppat_construct({txt: constructor} as longidentLoc, optPattern) =>
        /* Foo.(Bar(a)) -> Foo.Bar(a) */
        {
          ...pat,
          ppat_desc:
            [@implicit_arity]
            Ppat_construct(
              {
                ...longidentLoc,
                txt: concatLongidents(longidentOpen, constructor),
              },
              optPattern,
            ),
        }
      | [@implicit_arity]
        Ppat_record(
          [({txt: lbl} as longidentLoc, firstPat), ...rest],
          flag,
        ) =>
        /* Foo.{x} -> {Foo.x: x} */
        let firstRow = (
          {...longidentLoc, txt: concatLongidents(longidentOpen, lbl)},
          firstPat,
        );
        {
          ...pat,
          ppat_desc:
            [@implicit_arity] Ppat_record([firstRow, ...rest], flag),
        };
      | [@implicit_arity] Ppat_or(pat1, pat2) => {
          ...pat,
          ppat_desc:
            [@implicit_arity]
            Ppat_or(
              rewritePpatOpen(longidentOpen, pat1),
              rewritePpatOpen(longidentOpen, pat2),
            ),
        }
      | [@implicit_arity] Ppat_constraint(pattern, typ) => {
          ...pat,
          ppat_desc:
            [@implicit_arity]
            Ppat_constraint(rewritePpatOpen(longidentOpen, pattern), typ),
        }
      | Ppat_type({txt: constructor} as longidentLoc) => {
          ...pat,
          ppat_desc:
            Ppat_type({
              ...longidentLoc,
              txt: concatLongidents(longidentOpen, constructor),
            }),
        }
      | Ppat_lazy(p) => {
          ...pat,
          ppat_desc: Ppat_lazy(rewritePpatOpen(longidentOpen, p)),
        }
      | Ppat_exception(p) => {
          ...pat,
          ppat_desc: Ppat_exception(rewritePpatOpen(longidentOpen, p)),
        }
      | _ => pat
      }
    );

  let rec rewriteReasonFastPipe = expr =>
    Parsetree.(
      switch (expr.pexp_desc) {
      | [@implicit_arity]
        Pexp_apply(
          {
            pexp_desc:
              [@implicit_arity]
              Pexp_apply(
                {pexp_desc: Pexp_ident({txt: Longident.Lident("|.")})} as op,
                [(Asttypes.Nolabel, lhs), (Nolabel, rhs)],
              ),
            pexp_attributes: subAttrs,
          },
          args,
        ) =>
        let rhsLoc = {...rhs.pexp_loc, loc_end: expr.pexp_loc.loc_end};
        let newLhs = {
          let expr = rewriteReasonFastPipe(lhs);
          {...expr, pexp_attributes: subAttrs};
        };

        let allArgs = [
          (Asttypes.Nolabel, newLhs),
          (Asttypes.Nolabel, Ast_helper.Exp.apply(~loc=rhsLoc, rhs, args)),
        ];

        Ast_helper.Exp.apply(
          ~attrs=expr.pexp_attributes,
          ~loc=expr.pexp_loc,
          op,
          allArgs,
        );
      | _ => expr
      }
    );

  let makeReasonArityMapper = (~forPrinter) =>
    Ast_mapper.{
      ...default_mapper,
      expr: (mapper, expr) =>
        switch (expr) {
        /* Don't mind this case, Reason doesn't handle this. */
        /* | {pexp_desc = Pexp_variant (lbl, args); pexp_loc; pexp_attributes} -> */
        /* let newArgs = match args with */
        /* | (Some {pexp_desc = Pexp_tuple [{pexp_desc = Pexp_tuple _ } as sp]}) as args-> */
        /* if forPrinter then args else Some sp */
        /* | Some {pexp_desc = Pexp_tuple [sp]} -> Some sp */
        /* | _ -> args */
        /* in */
        /* default_mapper.expr mapper {pexp_desc=Pexp_variant(lbl, newArgs); pexp_loc; pexp_attributes} */
        | {
            pexp_desc: [@implicit_arity] Pexp_construct(lid, args),
            pexp_loc,
            pexp_attributes,
          } =>
          let newArgs =
            switch (args) {
            | Some({
                pexp_desc: Pexp_tuple([{pexp_desc: Pexp_tuple(_)} as sp]),
              }) as args =>
              if (forPrinter) {
                args;
              } else {
                Some(sp);
              }
            | Some({pexp_desc: Pexp_tuple([sp])}) => Some(sp)
            | _ => args
            };

          default_mapper.expr(
            mapper,
            {
              pexp_desc: [@implicit_arity] Pexp_construct(lid, newArgs),
              pexp_loc,
              pexp_attributes,
            },
          );
        | expr => default_mapper.expr(mapper, rewriteReasonFastPipe(expr))
        },
      pat: (mapper, pattern) =>
        switch (pattern) {
        /* Don't mind this case, Reason doesn't handle this. */
        /* | {ppat_desc = Ppat_variant (lbl, args); ppat_loc; ppat_attributes} -> */
        /* let newArgs = match args with */
        /* | (Some {ppat_desc = Ppat_tuple [{ppat_desc = Ppat_tuple _} as sp]}) as args -> */
        /* if forPrinter then args else Some sp */
        /* | Some {ppat_desc = Ppat_tuple [sp]} -> Some sp */
        /* | _ -> args */
        /* in */
        /* default_mapper.pat mapper {ppat_desc = Ppat_variant (lbl, newArgs); ppat_loc; ppat_attributes;} */
        | {
            ppat_desc: [@implicit_arity] Ppat_construct(lid, args),
            ppat_loc,
            ppat_attributes,
          } =>
          let new_args =
            switch (args) {
            | Some({
                ppat_desc: Ppat_tuple([{ppat_desc: Ppat_tuple(_)} as sp]),
              }) as args =>
              if (forPrinter) {
                args;
              } else {
                Some(sp);
              }
            | Some({ppat_desc: Ppat_tuple([sp])}) => Some(sp)
            | _ => args
            };
          default_mapper.pat(
            mapper,
            {
              ppat_desc: [@implicit_arity] Ppat_construct(lid, new_args),
              ppat_loc,
              ppat_attributes,
            },
          );
        | x => default_mapper.pat(mapper, x)
        },
    };

  let escapeTemplateLiteral = s => {
    let len = String.length(s);
    let b = Buffer.create(len);
    let i = ref(0);
    while (i^ < len) {
      let c = s.[i^];
      if (c == '`') {
        Buffer.add_char(b, '\\');
        Buffer.add_char(b, '`');
        incr(i);
      } else if (c == '$') {
        if (i^ + 1 < len) {
          let c2 = s.[i^ + 1];
          if (c2 == '{') {
            Buffer.add_char(b, '\\');
            Buffer.add_char(b, '$');
            Buffer.add_char(b, '{');
          } else {
            Buffer.add_char(b, c);
            Buffer.add_char(b, c2);
          };
          i := i^ + 2;
        } else {
          Buffer.add_char(b, c);
          incr(i);
        };
      } else if (c == '\\') {
        Buffer.add_char(b, '\\');
        Buffer.add_char(b, '\\');
        incr(i);
      } else {
        Buffer.add_char(b, c);
        incr(i);
      };
    };
    Buffer.contents(b);
  };

  let escapeStringContents = s => {
    let len = String.length(s);
    let b = Buffer.create(len);

    let i = ref(0);

    while (i^ < len) {
      let c = String.unsafe_get(s, i^);
      if (c == '\\') {
        incr(i);
        Buffer.add_char(b, c);
        let c = String.unsafe_get(s, i^);
        if (i^ < len) {
          let () = Buffer.add_char(b, c);
          incr(i);
        } else {
          ();
        };
      } else if (c == '"') {
        Buffer.add_char(b, '\\');
        Buffer.add_char(b, c);
        incr(i);
      } else {
        Buffer.add_char(b, c);
        incr(i);
      };
    };
    Buffer.contents(b);
  };

  let looksLikeRecursiveTypeDeclaration = typeDeclaration => {
    open Parsetree;
    let name = typeDeclaration.ptype_name.txt;
    let rec checkKind = kind =>
      switch (kind) {
      | Ptype_abstract
      | Ptype_open => false
      | Ptype_variant(constructorDeclarations) =>
        List.exists(checkConstructorDeclaration, constructorDeclarations)
      | Ptype_record(labelDeclarations) =>
        List.exists(checkLabelDeclaration, labelDeclarations)
      }

    and checkConstructorDeclaration = constrDecl =>
      checkConstructorArguments(constrDecl.pcd_args)
      || (
        switch (constrDecl.pcd_res) {
        | Some(typexpr) => checkTypExpr(typexpr)
        | None => false
        }
      )

    and checkLabelDeclaration = labelDeclaration =>
      checkTypExpr(labelDeclaration.pld_type)

    and checkConstructorArguments = constrArg =>
      switch (constrArg) {
      | Pcstr_tuple(types) => List.exists(checkTypExpr, types)
      | Pcstr_record(labelDeclarations) =>
        List.exists(checkLabelDeclaration, labelDeclarations)
      }

    and checkTypExpr = typ =>
      switch (typ.ptyp_desc) {
      | Ptyp_any => false
      | Ptyp_var(_) => false
      | Ptyp_object(_) => false
      | Ptyp_class(_) => false
      | Ptyp_package(_) => false
      | Ptyp_extension(_) => false
      | [@implicit_arity] Ptyp_arrow(_lbl, typ1, typ2) =>
        checkTypExpr(typ1) || checkTypExpr(typ2)
      | Ptyp_tuple(types) => List.exists(checkTypExpr, types)
      | [@implicit_arity] Ptyp_constr({txt: longident}, types) =>
        (
          switch (longident) {
          | Lident(ident) => ident == name
          | _ => false
          }
        )
        || List.exists(checkTypExpr, types)
      | [@implicit_arity] Ptyp_alias(typ, _) => checkTypExpr(typ)
      | [@implicit_arity] Ptyp_variant(rowFields, _, _) =>
        List.exists(checkRowFields, rowFields)
      | [@implicit_arity] Ptyp_poly(_, typ) => checkTypExpr(typ)
      }

    and checkRowFields = rowField =>
      switch (rowField) {
      | [@implicit_arity] Rtag(_, _, _, types) =>
        List.exists(checkTypExpr, types)
      | Rinherit(typexpr) => checkTypExpr(typexpr)
      };

    checkKind(typeDeclaration.ptype_kind);
  };

  let filterReasonRawLiteral = attrs =>
    List.filter(
      attr =>
        switch (attr) {
        | ({Location.txt: "reason.raw_literal"}, _) => false
        | _ => true
        },
      attrs,
    );

  let stringLiteralMapper = stringData => {
    let isSameLocation = (l1, l2) =>
      Location.(l1.loc_start.pos_cnum === l2.loc_start.pos_cnum);

    let remainingStringData = stringData;
    Ast_mapper.{
      ...default_mapper,
      expr: (mapper, expr) =>
        switch (expr.pexp_desc) {
        | Pexp_constant([@implicit_arity] Pconst_string(_txt, None)) =>
          switch (
            List.find_opt(
              ((_stringData, stringLoc)) =>
                isSameLocation(stringLoc, expr.pexp_loc),
              remainingStringData,
            )
          ) {
          | Some((stringData, _)) =>
            let stringData = {
              let attr =
                List.find_opt(
                  attr =>
                    switch (attr) {
                    | ({Location.txt: "reason.raw_literal"}, _) => true
                    | _ => false
                    },
                  expr.pexp_attributes,
                );
              switch (attr) {
              | Some((
                  _,
                  PStr([
                    {
                      pstr_desc:
                        [@implicit_arity]
                        Pstr_eval(
                          {
                            pexp_desc:
                              Pexp_constant(
                                [@implicit_arity] Pconst_string(raw, _),
                              ),
                          },
                          _,
                        ),
                    },
                  ]),
                )) => raw
              | _ =>
                ([@doesNotRaise] String.sub)(
                  stringData,
                  1,
                  String.length(stringData) - 2,
                )
              };
            };

            {
              ...expr,
              pexp_attributes: filterReasonRawLiteral(expr.pexp_attributes),
              pexp_desc:
                Pexp_constant(
                  [@implicit_arity] Pconst_string(stringData, None),
                ),
            };
          | None => default_mapper.expr(mapper, expr)
          }
        | _ => default_mapper.expr(mapper, expr)
        },
    };
  };

  let normalize =
    Ast_mapper.{
      ...default_mapper,
      attributes: (mapper, attrs) =>
        attrs
        |> List.filter(attr =>
             switch (attr) {
             | (
                 {
                   Location.txt:
                     "reason.preserve_braces" | "explicit_arity" |
                     "implicity_arity",
                 },
                 _,
               ) =>
               false
             | _ => true
             }
           )
        |> default_mapper.attributes(mapper),
      pat: (mapper, p) =>
        switch (p.ppat_desc) {
        | [@implicit_arity] Ppat_open({txt: longidentOpen}, pattern) =>
          let p = rewritePpatOpen(longidentOpen, pattern);
          default_mapper.pat(mapper, p);
        | _ => default_mapper.pat(mapper, p)
        },
      expr: (mapper, expr) =>
        switch (expr.pexp_desc) {
        | Pexp_constant([@implicit_arity] Pconst_string(txt, None)) =>
          let raw = escapeStringContents(txt);
          let s = [@implicit_arity] Parsetree.Pconst_string(raw, None);
          let expr =
            Ast_helper.Exp.constant(
              ~attrs=expr.pexp_attributes,
              ~loc=expr.pexp_loc,
              s,
            );

          expr;
        | Pexp_constant([@implicit_arity] Pconst_string(txt, tag)) =>
          let s =
            [@implicit_arity]
            Parsetree.Pconst_string(escapeTemplateLiteral(txt), tag);
          Ast_helper.Exp.constant(
            ~attrs=mapper.attributes(mapper, expr.pexp_attributes),
            ~loc=expr.pexp_loc,
            s,
          );
        | Pexp_function(cases) =>
          let loc =
            switch (cases, List.rev(cases)) {
            | ([first, ..._], [last, ..._]) => {
                ...first.pc_lhs.ppat_loc,
                loc_end: last.pc_rhs.pexp_loc.loc_end,
              }
            | _ => Location.none
            };

          Ast_helper.Exp.fun_(
            ~loc,
            Asttypes.Nolabel,
            None,
            Ast_helper.Pat.var(Location.mknoloc("x")),
            Ast_helper.Exp.match(
              ~loc,
              Ast_helper.Exp.ident(Location.mknoloc(Longident.Lident("x"))),
              default_mapper.cases(mapper, cases),
            ),
          );
        | [@implicit_arity]
          Pexp_apply(
            {pexp_desc: Pexp_ident({txt: Longident.Lident("!")})},
            [(Asttypes.Nolabel, operand)],
          ) =>
          /* turn `!foo` into `foo.contents` */
          Ast_helper.Exp.field(
            ~loc=expr.pexp_loc,
            ~attrs=expr.pexp_attributes,
            operand,
            Location.mknoloc(Longident.Lident("contents")),
          )
        | [@implicit_arity]
          Pexp_apply(
            {pexp_desc: Pexp_ident({txt: Longident.Lident("##")})} as op,
            [
              (Asttypes.Nolabel, lhs),
              (
                Nolabel,
                {
                  pexp_desc:
                    Pexp_constant(
                      [@implicit_arity] Pconst_string(txt, None),
                    ),
                } as stringExpr,
              ),
            ],
          ) =>
          let ident =
            Ast_helper.Exp.ident(
              ~loc=stringExpr.pexp_loc,
              Location.mkloc(Longident.Lident(txt), stringExpr.pexp_loc),
            );

          Ast_helper.Exp.apply(
            ~loc=expr.pexp_loc,
            ~attrs=expr.pexp_attributes,
            op,
            [(Asttypes.Nolabel, lhs), (Nolabel, ident)],
          );
        | [@implicit_arity]
          Pexp_apply(
            {pexp_desc: Pexp_ident({txt: Longident.Lident("@@")})},
            [(Asttypes.Nolabel, callExpr), (Nolabel, argExpr)],
          ) =>
          Ast_helper.Exp.apply(
            mapper.expr(mapper, callExpr),
            [(Asttypes.Nolabel, mapper.expr(mapper, argExpr))],
          )
        | [@implicit_arity]
          Pexp_apply(
            {pexp_desc: Pexp_ident({txt: Longident.Lident("@")})},
            [(Nolabel, arg1), (Nolabel, arg2)],
          ) =>
          let listConcat =
            [@implicit_arity]
            Longident.Ldot(Longident.Lident("List"), "append");
          Ast_helper.Exp.apply(
            Ast_helper.Exp.ident(Location.mknoloc(listConcat)),
            [
              (Nolabel, mapper.expr(mapper, arg1)),
              (Nolabel, mapper.expr(mapper, arg2)),
            ],
          );
        | [@implicit_arity]
          Pexp_match(
            condition,
            [
              {
                pc_lhs: {
                  ppat_desc:
                    [@implicit_arity]
                    Ppat_construct({txt: Longident.Lident("true")}, None),
                },
                pc_rhs: thenExpr,
              },
              {
                pc_lhs: {
                  ppat_desc:
                    [@implicit_arity]
                    Ppat_construct({txt: Longident.Lident("false")}, None),
                },
                pc_rhs: elseExpr,
              },
            ],
          ) =>
          let ternaryMarker = (
            Location.mknoloc("ns.ternary"),
            Parsetree.PStr([]),
          );
          Ast_helper.Exp.ifthenelse(
            ~loc=expr.pexp_loc,
            ~attrs=[ternaryMarker, ...expr.pexp_attributes],
            default_mapper.expr(mapper, condition),
            default_mapper.expr(mapper, thenExpr),
            Some(default_mapper.expr(mapper, elseExpr)),
          );
        | _ => default_mapper.expr(mapper, expr)
        },
      structure_item: (mapper, structureItem) =>
        switch (structureItem.pstr_desc) {
        /* heuristic: if we have multiple type declarations, mark them recursive */
        | [@implicit_arity] Pstr_type(recFlag, typeDeclarations) =>
          let flag =
            switch (typeDeclarations) {
            | [td] =>
              if (looksLikeRecursiveTypeDeclaration(td)) {
                Asttypes.Recursive;
              } else {
                Asttypes.Nonrecursive;
              }
            | _ => recFlag
            };

          {
            ...structureItem,
            pstr_desc:
              [@implicit_arity]
              Pstr_type(
                flag,
                List.map(
                  typeDeclaration =>
                    default_mapper.type_declaration(mapper, typeDeclaration),
                  typeDeclarations,
                ),
              ),
          };
        | _ => default_mapper.structure_item(mapper, structureItem)
        },
      signature_item: (mapper, signatureItem) =>
        switch (signatureItem.psig_desc) {
        /* heuristic: if we have multiple type declarations, mark them recursive */
        | [@implicit_arity] Psig_type(recFlag, typeDeclarations) =>
          let flag =
            switch (typeDeclarations) {
            | [td] =>
              if (looksLikeRecursiveTypeDeclaration(td)) {
                Asttypes.Recursive;
              } else {
                Asttypes.Nonrecursive;
              }
            | _ => recFlag
            };

          {
            ...signatureItem,
            psig_desc:
              [@implicit_arity]
              Psig_type(
                flag,
                List.map(
                  typeDeclaration =>
                    default_mapper.type_declaration(mapper, typeDeclaration),
                  typeDeclarations,
                ),
              ),
          };
        | _ => default_mapper.signature_item(mapper, signatureItem)
        },
      value_binding: (mapper, vb) =>
        switch (vb) {
        | {
            pvb_pat: {ppat_desc: Ppat_var(_)} as pat,
            pvb_expr: {
              pexp_loc: expr_loc,
              pexp_desc: [@implicit_arity] Pexp_constraint(expr, typ),
            },
          }
            when expr_loc.loc_ghost =>
          /* let t: t = (expr : t) -> let t: t = expr */
          let typ = default_mapper.typ(mapper, typ);
          let pat = default_mapper.pat(mapper, pat);
          let expr = mapper.expr(mapper, expr);
          let newPattern =
            Ast_helper.Pat.constraint_(
              ~loc={...pat.ppat_loc, loc_end: typ.ptyp_loc.loc_end},
              pat,
              typ,
            );
          {
            ...vb,
            pvb_pat: newPattern,
            pvb_expr: expr,
            pvb_attributes:
              default_mapper.attributes(mapper, vb.pvb_attributes),
          };
        | {
            pvb_pat: {
              ppat_desc:
                [@implicit_arity]
                Ppat_constraint(
                  pat,
                  {ptyp_desc: [@implicit_arity] Ptyp_poly([], _)},
                ),
            },
            pvb_expr: {
              pexp_loc: expr_loc,
              pexp_desc: [@implicit_arity] Pexp_constraint(expr, typ),
            },
          }
            when expr_loc.loc_ghost =>
          /* let t: . t = (expr : t) -> let t: t = expr */
          let typ = default_mapper.typ(mapper, typ);
          let pat = default_mapper.pat(mapper, pat);
          let expr = mapper.expr(mapper, expr);
          let newPattern =
            Ast_helper.Pat.constraint_(
              ~loc={...pat.ppat_loc, loc_end: typ.ptyp_loc.loc_end},
              pat,
              typ,
            );
          {
            ...vb,
            pvb_pat: newPattern,
            pvb_expr: expr,
            pvb_attributes:
              default_mapper.attributes(mapper, vb.pvb_attributes),
          };
        | _ => default_mapper.value_binding(mapper, vb)
        },
    };

  let normalizeReasonArityStructure = (~forPrinter, s) => {
    let mapper = makeReasonArityMapper(~forPrinter);
    mapper.Ast_mapper.structure(mapper, s);
  };

  let normalizeReasonAritySignature = (~forPrinter, s) => {
    let mapper = makeReasonArityMapper(~forPrinter);
    mapper.Ast_mapper.signature(mapper, s);
  };

  let structure = s => normalize.Ast_mapper.structure(normalize, s);
  let signature = s => normalize.Ast_mapper.signature(normalize, s);

  let replaceStringLiteralStructure = (stringData, structure) => {
    let mapper = stringLiteralMapper(stringData);
    mapper.Ast_mapper.structure(mapper, structure);
  };

  let replaceStringLiteralSignature = (stringData, signature) => {
    let mapper = stringLiteralMapper(stringData);
    mapper.Ast_mapper.signature(mapper, signature);
  };
};

module OcamlParser = Parser;

module Parser = {
  type mode =
    | ParseForTypeChecker
    | Default;

  type regionStatus =
    | Report
    | Silent;

  type t = {
    mode,
    mutable scanner: Scanner.t,
    mutable token: Token.t,
    mutable startPos: Lexing.position,
    mutable endPos: Lexing.position,
    mutable prevEndPos: Lexing.position,
    mutable breadcrumbs: list((Grammar.t, Lexing.position)),
    mutable errors: list(Reporting.parseError),
    mutable diagnostics: list(Diagnostics.t),
    mutable comments: list(Comment.t),
    mutable regions: list(ref(regionStatus)),
  };

  let err = (~startPos=?, ~endPos=?, p, error) => {
    let d =
      Diagnostics.make(
        ~filename=p.scanner.filename,
        ~startPos=
          switch (startPos) {
          | Some(pos) => pos
          | None => p.startPos
          },
        ~endPos=
          switch (endPos) {
          | Some(pos) => pos
          | None => p.endPos
          },
        error,
      );

    try(
      if ((List.hd(p.regions))^ == Report) {
        p.diagnostics = [d, ...p.diagnostics];
        List.hd(p.regions) := Silent;
      }
    ) {
    | Failure(_) => ()
    };
  };

  let beginRegion = p => p.regions = [ref(Report), ...p.regions];
  let endRegion = p =>
    try(p.regions = List.tl(p.regions)) {
    | Failure(_) => ()
    };

  /* Advance to the next non-comment token and store any encountered comment
   * in the parser's state. Every comment contains the end position of it's
   * previous token to facilite comment interleaving */
  let rec next = (~prevEndPos=?, p) => {
    let prevEndPos =
      switch (prevEndPos) {
      | Some(pos) => pos
      | None => p.endPos
      };
    let (startPos, endPos, token) = Scanner.scan(p.scanner);
    switch (token) {
    | Comment(c) =>
      Comment.setPrevTokEndPos(c, p.endPos);
      p.comments = [c, ...p.comments];
      p.prevEndPos = p.endPos;
      p.endPos = endPos;
      next(~prevEndPos, p);
    | _ =>
      p.token = token;
      /* p.prevEndPos <- prevEndPos; */
      p.prevEndPos = prevEndPos;
      p.startPos = startPos;
      p.endPos = endPos;
    };
  };

  let checkProgress = (~prevEndPos, ~result, p) =>
    if (p.endPos === prevEndPos) {
      None;
    } else {
      Some(result);
    };

  let make = (~mode=ParseForTypeChecker, src, filename) => {
    let scanner = Scanner.make(Bytes.of_string(src), filename);
    let parserState = {
      mode,
      scanner,
      token: Token.Eof,
      startPos: Lexing.dummy_pos,
      prevEndPos: Lexing.dummy_pos,
      endPos: Lexing.dummy_pos,
      breadcrumbs: [],
      errors: [],
      diagnostics: [],
      comments: [],
      regions: [ref(Report)],
    };
    parserState.scanner.err = (
      (~startPos, ~endPos, error) => {
        let diagnostic =
          Diagnostics.make(~filename, ~startPos, ~endPos, error);

        parserState.diagnostics = [diagnostic, ...parserState.diagnostics];
      }
    );
    next(parserState);
    parserState;
  };

  let leaveBreadcrumb = (p, circumstance) => {
    let crumb = (circumstance, p.startPos);
    p.breadcrumbs = [crumb, ...p.breadcrumbs];
  };

  let eatBreadcrumb = p =>
    switch (p.breadcrumbs) {
    | [] => ()
    | [_, ...crumbs] => p.breadcrumbs = crumbs
    };

  let optional = (p, token) =>
    if (p.token == token) {
      let () = next(p);
      true;
    } else {
      false;
    };

  let expect = (~grammar=?, token, p) =>
    if (p.token == token) {
      next(p);
    } else {
      let error = Diagnostics.expected(~grammar?, p.prevEndPos, token);
      err(~startPos=p.prevEndPos, p, error);
    };

  /* Don't use immutable copies here, it trashes certain heuristics
   * in the ocaml compiler, resulting in massive slowdowns of the parser */
  let lookahead = (p, callback) => {
    let err = p.scanner.err;
    let ch = p.scanner.ch;
    let offset = p.scanner.offset;
    let rdOffset = p.scanner.rdOffset;
    let lineOffset = p.scanner.lineOffset;
    let lnum = p.scanner.lnum;
    let mode = p.scanner.mode;
    let token = p.token;
    let startPos = p.startPos;
    let endPos = p.endPos;
    let prevEndPos = p.prevEndPos;
    let breadcrumbs = p.breadcrumbs;
    let errors = p.errors;
    let diagnostics = p.diagnostics;
    let comments = p.comments;

    let res = callback(p);

    p.scanner.err = err;
    p.scanner.ch = ch;
    p.scanner.offset = offset;
    p.scanner.rdOffset = rdOffset;
    p.scanner.lineOffset = lineOffset;
    p.scanner.lnum = lnum;
    p.scanner.mode = mode;
    p.token = token;
    p.startPos = startPos;
    p.endPos = endPos;
    p.prevEndPos = prevEndPos;
    p.breadcrumbs = breadcrumbs;
    p.errors = errors;
    p.diagnostics = diagnostics;
    p.comments = comments;

    res;
  };
};

module NapkinScript = {
  let mkLoc = (startLoc, endLoc) =>
    Location.{loc_start: startLoc, loc_end: endLoc, loc_ghost: false};

  module Recover = {
    type action = option(unit); /* None is abort, Some () is retry */

    let defaultExpr = () => {
      let id = Location.mknoloc("napkinscript.exprhole");
      Ast_helper.Exp.mk([@implicit_arity] Pexp_extension(id, PStr([])));
    };

    let defaultType = () => {
      let id = Location.mknoloc("napkinscript.typehole");
      Ast_helper.Typ.extension((id, PStr([])));
    };

    let defaultPattern = () => {
      let id = Location.mknoloc("napkinscript.patternhole");
      Ast_helper.Pat.extension((id, PStr([])));
    };
    /* Ast_helper.Pat.any  () */

    let defaultModuleExpr = () => Ast_helper.Mod.structure([]);
    let defaultModuleType = () => Ast_helper.Mty.signature([]);

    let recoverEqualGreater = p => {
      Parser.expect(EqualGreater, p);
      switch (p.Parser.token) {
      | MinusGreater => Parser.next(p)
      | _ => ()
      };
    };

    let shouldAbortListParse = p => {
      let rec check = breadcrumbs =>
        switch (breadcrumbs) {
        | [] => false
        | [(grammar, _), ...rest] =>
          if (Grammar.isPartOfList(grammar, p.Parser.token)) {
            true;
          } else {
            check(rest);
          }
        };

      check(p.breadcrumbs);
    };
  };

  module ErrorMessages = {
    let listPatternSpread = "List pattern matches only supports one `...` spread, at the end.\nExplanation: a list spread at the tail is efficient, but a spread in the middle would create new list[s]; out of performance concern, our pattern matching currently guarantees to never create new intermediate data.";

    let recordPatternSpread = "Record's `...` spread is not supported in pattern matches.\nExplanation: you can't collect a subset of a record's field into its own record, since a record needs an explicit declaration and that subset wouldn't have one.\nSolution: you need to pull out each field you want explicitly.";

    [@live]
    let recordPatternUnderscore = "Record patterns only support one `_`, at the end.";

    let arrayPatternSpread = "Array's `...` spread is not supported in pattern matches.\nExplanation: such spread would create a subarray; out of performance concern, our pattern matching currently guarantees to never create new intermediate data.\nSolution: if it's to validate the first few elements, use a `when` clause + Array size check + `get` checks on the current pattern. If it's to obtain a subarray, use `Array.sub` or `Belt.Array.slice`.";

    let arrayExprSpread = "Arrays can't use the `...` spread currently. Please use `concat` or other Array helpers.";

    let recordExprSpread = "Records can only have one `...` spread, at the beginning.\nExplanation: since records have a known, fixed shape, a spread like `{a, ...b}` wouldn't make sense, as `b` would override every field of `a` anyway.";

    let listExprSpread = "Lists can only have one `...` spread, and at the end.\nExplanation: lists are singly-linked list, where a node contains a value and points to the next node. `list[a, ...bc]` efficiently creates a new item and links `bc` as its next nodes. `[...bc, a]` would be expensive, as it'd need to traverse `bc` and prepend each item to `a` one by one. We therefore disallow such syntax sugar.\nSolution: directly use `concat`.";

    let variantIdent = "A polymorphic variant (e.g. #id) must start with an alphabetical letter.";
  };

  let jsxAttr = (Location.mknoloc("JSX"), Parsetree.PStr([]));
  let uncurryAttr = (Location.mknoloc("bs"), Parsetree.PStr([]));
  let ternaryAttr = (Location.mknoloc("ns.ternary"), Parsetree.PStr([]));
  let makeBracesAttr = loc => (
    Location.mkloc("ns.braces", loc),
    Parsetree.PStr([]),
  );

  type typDefOrExt =
    | TypeDef({
        recFlag: Asttypes.rec_flag,
        types: list(Parsetree.type_declaration),
      })
    | TypeExt(Parsetree.type_extension);

  type labelledParameter =
    | TermParameter({
        uncurried: bool,
        attrs: Parsetree.attributes,
        label: Asttypes.arg_label,
        expr: option(Parsetree.expression),
        pat: Parsetree.pattern,
        pos: Lexing.position,
      })
    | TypeParameter({
        uncurried: bool,
        attrs: Parsetree.attributes,
        locs: list(Location.loc(string)),
        pos: Lexing.position,
      });

  type recordPatternItem =
    | PatUnderscore
    | PatField((Ast_helper.lid, Parsetree.pattern));

  type context =
    | OrdinaryExpr
    | TernaryTrueBranchExpr
    | WhenExpr;

  let getClosingToken =
    fun
    | Token.Lparen => Token.Rparen
    | Lbrace => Rbrace
    | Lbracket => Rbracket
    | _ => assert(false);

  let rec goToClosing = (closingToken, state) =>
    switch (state.Parser.token, closingToken) {
    | (Rparen, Token.Rparen)
    | (Rbrace, Rbrace)
    | (Rbracket, Rbracket) =>
      Parser.next(state);
      ();
    | ((Token.Lbracket | Lparen | Lbrace) as t, _) =>
      Parser.next(state);
      goToClosing(getClosingToken(t), state);
      goToClosing(closingToken, state);
    | (Rparen | Token.Rbrace | Rbracket | Eof, _) => () /* TODO: how do report errors here? */
    | _ =>
      Parser.next(state);
      goToClosing(closingToken, state);
    };

  /* Madness */
  let isEs6ArrowExpression = (~inTernary, p) =>
    Parser.lookahead(p, state =>
      switch (state.Parser.token) {
      | Lident(_)
      | List
      | Underscore =>
        Parser.next(state);
        switch (state.Parser.token) {
        /* Don't think that this valid
         * Imagine: let x = (a: int)
         * This is a parenthesized expression with a type constraint, wait for
         * the arrow */
        /* | Colon when not inTernary -> true */
        | EqualGreater => true
        | _ => false
        };
      | Lparen =>
        let prevEndPos = state.prevEndPos;
        Parser.next(state);
        switch (state.token) {
        | Rparen =>
          Parser.next(state);
          switch (state.Parser.token) {
          | Colon when !inTernary => true
          | EqualGreater => true
          | _ => false
          };
        | Dot /* uncurried */ => true
        | Tilde => true
        | Backtick => false /* (` always indicates the start of an expr, can't be es6 parameter */
        | _ =>
          goToClosing(Rparen, state);
          switch (state.Parser.token) {
          | EqualGreater => true
          /* | Lbrace TODO: detect missing =>, is this possible? */
          | Colon when !inTernary => true
          | Rparen =>
            /* imagine having something as :
             * switch colour {
             * | Red
             *    when l == l'
             *    || (&Clflags.classic && (l == Nolabel && !is_optional(l'))) => (t1, t2)
             * We'll arrive at the outer rparen just before the =>.
             * This is not an es6 arrow.
             * */
            false
          | _ =>
            Parser.next(state);
            /* error recovery, peek at the next token,
             * (elements, providerId] => {
             *  in the example above, we have an unbalanced ] here
             */
            switch (state.Parser.token) {
            | EqualGreater when state.startPos.pos_lnum === prevEndPos.pos_lnum =>
              true
            | _ => false
            };
          };
        };
      | _ => false
      }
    );

  let isEs6ArrowFunctor = p =>
    Parser.lookahead(p, state =>
      switch (state.Parser.token) {
      /* | Uident _ | Underscore -> */
      /* Parser.next state; */
      /* begin match state.Parser.token with */
      /* | EqualGreater -> true */
      /* | _ -> false */
      /* end */
      | Lparen =>
        Parser.next(state);
        switch (state.token) {
        | Rparen =>
          Parser.next(state);
          switch (state.token) {
          | Colon
          | EqualGreater => true
          | _ => false
          };
        | _ =>
          goToClosing(Rparen, state);
          switch (state.Parser.token) {
          | EqualGreater
          | Lbrace => true
          | Colon => true
          | _ => false
          };
        };
      | _ => false
      }
    );

  let isEs6ArrowType = p =>
    Parser.lookahead(p, state =>
      switch (state.Parser.token) {
      | Lparen =>
        Parser.next(state);
        switch (state.Parser.token) {
        | Rparen =>
          Parser.next(state);
          switch (state.Parser.token) {
          | EqualGreater => true
          | _ => false
          };
        | Tilde
        | Dot => true
        | _ =>
          goToClosing(Rparen, state);
          switch (state.Parser.token) {
          | EqualGreater => true
          | _ => false
          };
        };
      | Tilde => true
      | _ => false
      }
    );

  let buildLongident = words =>
    switch (List.rev(words)) {
    | [] => assert(false)
    | [hd, ...tl] =>
      List.fold_left(
        (p, s) => [@implicit_arity] Longident.Ldot(p, s),
        Lident(hd),
        tl,
      )
    };

  let makeInfixOperator = (p, token, startPos, endPos) => {
    let stringifiedToken =
      if (token == Token.MinusGreater) {
        "|.";
      } else if (token == Token.PlusPlus) {
        "^";
      } else if (token == Token.BangEqual) {
        "<>";
      } else if (token == Token.BangEqualEqual) {
        "!=";
      } else if (token == Token.Equal) {
        /* TODO: could have a totally different meaning like x->fooSet(y)*/
        Parser.err(
          ~startPos,
          ~endPos,
          p,
          Diagnostics.message("Did you mean `==` here?"),
        );
        "=";
      } else if (token == Token.EqualEqual) {
        "=";
      } else if (token == Token.EqualEqualEqual) {
        "==";
      } else {
        Token.toString(token);
      };

    let loc = mkLoc(startPos, endPos);
    let operator = Location.mkloc(Longident.Lident(stringifiedToken), loc);

    Ast_helper.Exp.ident(~loc, operator);
  };

  let negateString = s =>
    if (String.length(s) > 0 && [@doesNotRaise] s.[0] == '-') {
      ([@doesNotRaise] String.sub)(s, 1, String.length(s) - 1);
    } else {
      "-" ++ s;
    };

  let makeUnaryExpr = (startPos, tokenEnd, token, operand) =>
    switch (token, operand.Parsetree.pexp_desc) {
    | (
        Token.Plus | PlusDot,
        Pexp_constant(Pconst_integer(_) | Pconst_float(_)),
      ) => operand
    | (Minus, Pexp_constant([@implicit_arity] Pconst_integer(n, m))) => {
        ...operand,
        pexp_desc:
          Pexp_constant(
            [@implicit_arity] Pconst_integer(negateString(n), m),
          ),
      }
    | (
        Minus | MinusDot,
        Pexp_constant([@implicit_arity] Pconst_float(n, m)),
      ) => {
        ...operand,
        pexp_desc:
          Pexp_constant([@implicit_arity] Pconst_float(negateString(n), m)),
      }
    | (Token.Plus | PlusDot | Minus | MinusDot, _) =>
      let tokenLoc = mkLoc(startPos, tokenEnd);
      let operator = "~" ++ Token.toString(token);
      Ast_helper.Exp.apply(
        ~loc=mkLoc(startPos, operand.Parsetree.pexp_loc.loc_end),
        Ast_helper.Exp.ident(
          ~loc=tokenLoc,
          Location.mkloc(Longident.Lident(operator), tokenLoc),
        ),
        [(Nolabel, operand)],
      );
    | (Token.Bang, _) =>
      let tokenLoc = mkLoc(startPos, tokenEnd);
      Ast_helper.Exp.apply(
        ~loc=mkLoc(startPos, operand.Parsetree.pexp_loc.loc_end),
        Ast_helper.Exp.ident(
          ~loc=tokenLoc,
          Location.mkloc(Longident.Lident("not"), tokenLoc),
        ),
        [(Nolabel, operand)],
      );
    | _ => operand
    };

  let makeListExpression = (loc, seq, extOpt) => {
    let rec handleSeq =
      fun
      | [] =>
        switch (extOpt) {
        | Some(ext) => ext
        | None =>
          let loc = {...loc, Location.loc_ghost: true};
          let nil = Location.mkloc(Longident.Lident("[]"), loc);
          Ast_helper.Exp.construct(~loc, nil, None);
        }
      | [e1, ...el] => {
          let exp_el = handleSeq(el);
          let loc =
            mkLoc(
              e1.Parsetree.pexp_loc.Location.loc_start,
              exp_el.pexp_loc.loc_end,
            );

          let arg = Ast_helper.Exp.tuple(~loc, [e1, exp_el]);
          Ast_helper.Exp.construct(
            ~loc,
            Location.mkloc(Longident.Lident("::"), loc),
            Some(arg),
          );
        };

    let expr = handleSeq(seq);
    {...expr, pexp_loc: loc};
  };

  let makeListPattern = (loc, seq, ext_opt) => {
    let rec handle_seq =
      fun
      | [] => {
          let base_case =
            switch (ext_opt) {
            | Some(ext) => ext
            | None =>
              let loc = {...loc, Location.loc_ghost: true};
              let nil = {Location.txt: Longident.Lident("[]"), loc};
              Ast_helper.Pat.construct(~loc, nil, None);
            };

          base_case;
        }
      | [p1, ...pl] => {
          let pat_pl = handle_seq(pl);
          let loc =
            mkLoc(p1.Parsetree.ppat_loc.loc_start, pat_pl.ppat_loc.loc_end);
          let arg = Ast_helper.Pat.mk(~loc, Ppat_tuple([p1, pat_pl]));
          Ast_helper.Pat.mk(
            ~loc,
            [@implicit_arity]
            Ppat_construct(
              Location.mkloc(Longident.Lident("::"), loc),
              Some(arg),
            ),
          );
        };

    handle_seq(seq);
  };

  /* {"foo": bar} -> Js.t({. foo: bar})
   * {.. "foo": bar} -> Js.t({.. foo: bar})
   * {..} -> Js.t({..}) */
  let makeBsObjType = (~attrs, ~loc, ~closed, rows) => {
    let obj = Ast_helper.Typ.object_(~loc, rows, closed);
    let jsDotTCtor =
      Location.mkloc(
        [@implicit_arity] Longident.Ldot(Longident.Lident("Js"), "t"),
        loc,
      );

    Ast_helper.Typ.constr(~loc, ~attrs, jsDotTCtor, [obj]);
  };

  /* TODO: diagnostic reporting */
  let lidentOfPath = longident =>
    switch (Longident.flatten(longident) |> List.rev) {
    | [] => ""
    | [ident, ..._] => ident
    };

  let makeNewtypes = (~attrs, ~loc, newtypes, exp) => {
    let expr =
      List.fold_right(
        (newtype, exp) =>
          Ast_helper.Exp.mk(
            ~loc,
            [@implicit_arity] Pexp_newtype(newtype, exp),
          ),
        newtypes,
        exp,
      );
    {...expr, pexp_attributes: attrs};
  };

  /* locally abstract types syntax sugar
   * Transforms
   *  let f: type t u v. = (foo : list</t, u, v/>) => ...
   * into
   *  let f = (type t u v. foo : list</t, u, v/>) => ...
   */
  let wrapTypeAnnotation = (~loc, newtypes, core_type, body) => {
    let exp =
      makeNewtypes(
        ~attrs=[],
        ~loc,
        newtypes,
        Ast_helper.Exp.constraint_(~loc, body, core_type),
      );

    let typ =
      Ast_helper.Typ.poly(
        ~loc,
        newtypes,
        Ast_helper.Typ.varify_constructors(newtypes, core_type),
      );

    (exp, typ);
  };

  /**
    * process the occurrence of _ in the arguments of a function application
    * replace _ with a new variable, currently __x, in the arguments
    * return a wrapping function that wraps ((__x) => ...) around an expression
    * e.g. foo(_, 3) becomes (__x) => foo(__x, 3)
    */

  let processUnderscoreApplication = args => {
    open Parsetree;
    let exp_question = ref(None);
    let hidden_var = "__x";
    let check_arg = ((lab, exp) as arg) =>
      switch (exp.pexp_desc) {
      | Pexp_ident({txt: Lident("_")} as id) =>
        let new_id = Location.mkloc(Longident.Lident(hidden_var), id.loc);
        let new_exp =
          Ast_helper.Exp.mk(Pexp_ident(new_id), ~loc=exp.pexp_loc);
        exp_question := Some(new_exp);
        (lab, new_exp);
      | _ => arg
      };

    let args = List.map(check_arg, args);
    let wrap = exp_apply =>
      switch (exp_question^) {
      | Some({pexp_loc: loc}) =>
        let pattern =
          Ast_helper.Pat.mk(
            Ppat_var(Location.mkloc(hidden_var, loc)),
            ~loc,
          );
        Ast_helper.Exp.mk(
          [@implicit_arity] Pexp_fun(Nolabel, None, pattern, exp_apply),
          ~loc,
        );
      | None => exp_apply
      };

    (args, wrap);
  };

  let rec parseLident = p => {
    let recoverLident = p =>
      if (Token.isKeyword(p.Parser.token)
          && p.Parser.prevEndPos.pos_lnum === p.startPos.pos_lnum) {
        Parser.err(p, Diagnostics.lident(p.Parser.token));
        Parser.next(p);
        None;
      } else {
        let rec loop = p =>
          if (!Recover.shouldAbortListParse(p)) {
            Parser.next(p);
            loop(p);
          };

        Parser.next(p);
        loop(p);
        switch (p.Parser.token) {
        | Lident(_) => Some()
        | _ => None
        };
      };

    let startPos = p.Parser.startPos;
    switch (p.Parser.token) {
    | Lident(ident) =>
      Parser.next(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      (ident, loc);
    | List =>
      Parser.next(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      ("list", loc);
    | _ =>
      switch (recoverLident(p)) {
      | Some () => parseLident(p)
      | None => ("_", mkLoc(startPos, p.prevEndPos))
      }
    };
  };

  let parseIdent = (~msg, ~startPos, p) =>
    switch (p.Parser.token) {
    | Lident(ident)
    | Uident(ident) =>
      Parser.next(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      (ident, loc);
    | List =>
      Parser.next(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      ("list", loc);
    | _token =>
      Parser.err(p, Diagnostics.message(msg));
      Parser.next(p);
      ("_", mkLoc(startPos, p.prevEndPos));
    };

  let parseHashIdent = (~startPos, p) => {
    Parser.expect(Hash, p);
    parseIdent(~startPos, ~msg=ErrorMessages.variantIdent, p);
  };

  /* Ldot (Ldot (Lident "Foo", "Bar"), "baz") */
  let parseValuePath = p => {
    let startPos = p.Parser.startPos;
    let rec aux = (p, path) =>
      switch (p.Parser.token) {
      | List => [@implicit_arity] Longident.Ldot(path, "list")
      | Lident(ident) => [@implicit_arity] Longident.Ldot(path, ident)
      | Uident(uident) =>
        Parser.next(p);
        Parser.expect(Dot, p);
        aux(p, [@implicit_arity] Ldot(path, uident));
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        Longident.Lident("_");
      };

    let ident =
      switch (p.Parser.token) {
      | List => Longident.Lident("list")
      | Lident(ident) => Longident.Lident(ident)
      | Uident(ident) =>
        Parser.next(p);
        Parser.expect(Dot, p);
        aux(p, Lident(ident));
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        Longident.Lident("_");
      };

    Parser.next(p);
    Location.mkloc(ident, mkLoc(startPos, p.prevEndPos));
  };

  let parseValuePathTail = (p, startPos, ident) => {
    let rec loop = (p, path) =>
      switch (p.Parser.token) {
      | Lident(ident) =>
        Parser.next(p);
        Location.mkloc(
          [@implicit_arity] Longident.Ldot(path, ident),
          mkLoc(startPos, p.prevEndPos),
        );
      | List =>
        Parser.next(p);
        Location.mkloc(
          [@implicit_arity] Longident.Ldot(path, "list"),
          mkLoc(startPos, p.prevEndPos),
        );
      | Uident(ident) =>
        Parser.next(p);
        Parser.expect(Dot, p);
        loop(p, [@implicit_arity] Longident.Ldot(path, ident));
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        Location.mknoloc(path);
      };

    loop(p, ident);
  };

  let parseModuleLongIdentTail = (~lowercase, p, startPos, ident) => {
    let rec loop = (p, acc) =>
      switch (p.Parser.token) {
      | List when lowercase =>
        Parser.next(p);
        let lident = [@implicit_arity] Longident.Ldot(acc, "list");
        Location.mkloc(lident, mkLoc(startPos, p.prevEndPos));
      | Lident(ident) when lowercase =>
        Parser.next(p);
        let lident = [@implicit_arity] Longident.Ldot(acc, ident);
        Location.mkloc(lident, mkLoc(startPos, p.prevEndPos));
      | Uident(ident) =>
        Parser.next(p);
        let endPos = p.prevEndPos;
        let lident = [@implicit_arity] Longident.Ldot(acc, ident);
        switch (p.Parser.token) {
        | Dot =>
          Parser.next(p);
          loop(p, lident);
        | _ => Location.mkloc(lident, mkLoc(startPos, endPos))
        };
      | t =>
        Parser.err(p, Diagnostics.uident(t));
        Location.mkloc(acc, mkLoc(startPos, p.prevEndPos));
      };

    loop(p, ident);
  };

  /* Parses module identifiers:
     Foo
     Foo.Bar */
  let parseModuleLongIdent = (~lowercase, p) => {
    /* Parser.leaveBreadcrumb p Reporting.ModuleLongIdent; */
    let startPos = p.Parser.startPos;
    let moduleIdent =
      switch (p.Parser.token) {
      | List when lowercase =>
        let loc = mkLoc(startPos, p.endPos);
        Parser.next(p);
        Location.mkloc(Longident.Lident("list"), loc);
      | Lident(ident) when lowercase =>
        let loc = mkLoc(startPos, p.endPos);
        let lident = Longident.Lident(ident);
        Parser.next(p);
        Location.mkloc(lident, loc);
      | Uident(ident) =>
        let lident = Longident.Lident(ident);
        let endPos = p.endPos;
        Parser.next(p);
        switch (p.Parser.token) {
        | Dot =>
          Parser.next(p);
          parseModuleLongIdentTail(~lowercase, p, startPos, lident);
        | _ => Location.mkloc(lident, mkLoc(startPos, endPos))
        };
      | t =>
        Parser.err(p, Diagnostics.uident(t));
        Location.mkloc(
          Longident.Lident("_"),
          mkLoc(startPos, p.prevEndPos),
        );
      };

    /* Parser.eatBreadcrumb p; */
    moduleIdent;
  };

  /* `window.location` or `Math` or `Foo.Bar` */
  let parseIdentPath = p => {
    let rec loop = (p, acc) =>
      switch (p.Parser.token) {
      | Uident(ident)
      | Lident(ident) =>
        Parser.next(p);
        let lident = [@implicit_arity] Longident.Ldot(acc, ident);
        switch (p.Parser.token) {
        | Dot =>
          Parser.next(p);
          loop(p, lident);
        | _ => lident
        };
      | _t => acc
      };

    switch (p.Parser.token) {
    | Lident(ident)
    | Uident(ident) =>
      Parser.next(p);
      switch (p.Parser.token) {
      | Dot =>
        Parser.next(p);
        loop(p, Longident.Lident(ident));
      | _ => Longident.Lident(ident)
      };
    | _ => Longident.Lident("_")
    };
  };

  let verifyJsxOpeningClosingName = (p, nameExpr) => {
    let closing =
      switch (p.Parser.token) {
      | Lident(lident) =>
        Parser.next(p);
        Longident.Lident(lident);
      | Uident(_) => parseModuleLongIdent(~lowercase=false, p).txt
      | _ => Longident.Lident("")
      };

    switch (nameExpr.Parsetree.pexp_desc) {
    | Pexp_ident(openingIdent) =>
      let opening = {
        let withoutCreateElement =
          Longident.flatten(openingIdent.txt)
          |> List.filter(s => s != "createElement");

        switch (Longident.unflatten(withoutCreateElement)) {
        | Some(li) => li
        | None => Longident.Lident("")
        };
      };

      opening == closing;
    | _ => assert(false)
    };
  };

  let string_of_pexp_ident = nameExpr =>
    switch (nameExpr.Parsetree.pexp_desc) {
    | Pexp_ident(openingIdent) =>
      Longident.flatten(openingIdent.txt)
      |> List.filter(s => s != "createElement")
      |> String.concat(".")
    | _ => ""
    };

  /* open-def ::=
   *   | open module-path
   *   | open! module-path */
  let parseOpenDescription = (~attrs, p) => {
    Parser.leaveBreadcrumb(p, Grammar.OpenDescription);
    let startPos = p.Parser.startPos;
    Parser.expect(Open, p);
    let override =
      if (Parser.optional(p, Token.Bang)) {
        Asttypes.Override;
      } else {
        Asttypes.Fresh;
      };

    let modident = parseModuleLongIdent(~lowercase=false, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Parser.eatBreadcrumb(p);
    Ast_helper.Opn.mk(~loc, ~attrs, ~override, modident);
  };

  let hexValue = x =>
    switch (x) {
    | '0'..'9' => Char.code(x) - 48
    | 'A'..'Z' => Char.code(x) - 55
    | 'a'..'z' => Char.code(x) - 97
    | _ => 16
    };

  let parseStringLiteral = s => {
    let len = String.length(s);
    let b = Buffer.create(String.length(s));

    let rec loop = i =>
      if (i == len) {
        ();
      } else {
        let c = String.unsafe_get(s, i);
        switch (c) {
        | '\\' as c =>
          let nextIx = i + 1;
          if (nextIx < len) {
            let nextChar = String.unsafe_get(s, nextIx);
            switch (nextChar) {
            | 'n' =>
              Buffer.add_char(b, '\n');
              loop(nextIx + 1);
            | 'r' =>
              Buffer.add_char(b, '\r');
              loop(nextIx + 1);
            | 'b' =>
              Buffer.add_char(b, '\b');
              loop(nextIx + 1);
            | 't' =>
              Buffer.add_char(b, '\t');
              loop(nextIx + 1);
            | '\\' as c =>
              Buffer.add_char(b, c);
              loop(nextIx + 1);
            | ' ' as c =>
              Buffer.add_char(b, c);
              loop(nextIx + 1);
            | '\'' as c =>
              Buffer.add_char(b, c);
              loop(nextIx + 1);
            | '"' as c =>
              Buffer.add_char(b, c);
              loop(nextIx + 1);
            | '0'..'9' =>
              if (nextIx + 2 < len) {
                let c0 = nextChar;
                let c1 = String.unsafe_get(s, nextIx + 1);
                let c2 = String.unsafe_get(s, nextIx + 2);
                let c =
                  100
                  * (Char.code(c0) - 48)
                  + 10
                  * (Char.code(c1) - 48)
                  + (Char.code(c2) - 48);

                if (c < 0 || c > 255) {
                  Buffer.add_char(b, '\\');
                  Buffer.add_char(b, c0);
                  Buffer.add_char(b, c1);
                  Buffer.add_char(b, c2);
                  loop(nextIx + 3);
                } else {
                  Buffer.add_char(b, Char.unsafe_chr(c));
                  loop(nextIx + 3);
                };
              } else {
                Buffer.add_char(b, '\\');
                Buffer.add_char(b, nextChar);
                loop(nextIx + 1);
              }
            | 'o' =>
              if (nextIx + 3 < len) {
                let c0 = String.unsafe_get(s, nextIx + 1);
                let c1 = String.unsafe_get(s, nextIx + 2);
                let c2 = String.unsafe_get(s, nextIx + 3);
                let c =
                  64
                  * (Char.code(c0) - 48)
                  + 8
                  * (Char.code(c1) - 48)
                  + (Char.code(c2) - 48);

                if (c < 0 || c > 255) {
                  Buffer.add_char(b, '\\');
                  Buffer.add_char(b, '0');
                  Buffer.add_char(b, c0);
                  Buffer.add_char(b, c1);
                  Buffer.add_char(b, c2);
                  loop(nextIx + 4);
                } else {
                  Buffer.add_char(b, Char.unsafe_chr(c));
                  loop(nextIx + 4);
                };
              } else {
                Buffer.add_char(b, '\\');
                Buffer.add_char(b, nextChar);
                loop(nextIx + 1);
              }
            | 'x' as c =>
              if (nextIx + 2 < len) {
                let c0 = String.unsafe_get(s, nextIx + 1);
                let c1 = String.unsafe_get(s, nextIx + 2);
                let c = 16 * hexValue(c0) + hexValue(c1);
                if (c < 0 || c > 255) {
                  Buffer.add_char(b, '\\');
                  Buffer.add_char(b, 'x');
                  Buffer.add_char(b, c0);
                  Buffer.add_char(b, c1);
                  loop(nextIx + 3);
                } else {
                  Buffer.add_char(b, Char.unsafe_chr(c));
                  loop(nextIx + 3);
                };
              } else {
                Buffer.add_char(b, '\\');
                Buffer.add_char(b, c);
                loop(nextIx + 2);
              }
            | _ =>
              Buffer.add_char(b, c);
              Buffer.add_char(b, nextChar);
              loop(nextIx + 1);
            };
          } else {
            Buffer.add_char(b, c);
            ();
          };
        | c =>
          Buffer.add_char(b, c);
          loop(i + 1);
        };
      };

    loop(0);
    Buffer.contents(b);
  };

  let parseTemplateStringLiteral = s => {
    let len = String.length(s);
    let b = Buffer.create(len);

    let rec loop = i =>
      if (i < len) {
        let c = String.unsafe_get(s, i);
        switch (c) {
        | '\\' as c =>
          if (i + 1 < len) {
            let nextChar = String.unsafe_get(s, i + 1);
            switch (nextChar) {
            | '\\' as c =>
              Buffer.add_char(b, c);
              loop(i + 2);
            | '$' as c =>
              Buffer.add_char(b, c);
              loop(i + 2);
            | '`' as c =>
              Buffer.add_char(b, c);
              loop(i + 2);
            | c =>
              Buffer.add_char(b, '\\');
              Buffer.add_char(b, c);
              loop(i + 2);
            };
          } else {
            Buffer.add_char(b, c);
          }

        | c =>
          Buffer.add_char(b, c);
          loop(i + 1);
        };
      } else {
        ();
      };

    loop(0);
    Buffer.contents(b);
  };

  /* constant	::=	integer-literal   */
  /* ∣	 float-literal   */
  /* ∣	 string-literal   */
  let parseConstant = p => {
    let isNegative =
      switch (p.Parser.token) {
      | Token.Minus =>
        Parser.next(p);
        true;
      | Plus =>
        Parser.next(p);
        false;
      | _ => false
      };

    let constant =
      switch (p.Parser.token) {
      | Int({i, suffix}) =>
        let intTxt =
          if (isNegative) {
            "-" ++ i;
          } else {
            i;
          };
        [@implicit_arity] Parsetree.Pconst_integer(intTxt, suffix);
      | Float({f, suffix}) =>
        let floatTxt =
          if (isNegative) {
            "-" ++ f;
          } else {
            f;
          };
        [@implicit_arity] Parsetree.Pconst_float(floatTxt, suffix);
      | String(s) =>
        let txt =
          if (p.mode == ParseForTypeChecker) {
            parseStringLiteral(s);
          } else {
            s;
          };

        [@implicit_arity] Pconst_string(txt, None);
      | Character(c) => Pconst_char(c)
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        [@implicit_arity] Pconst_string("", None);
      };

    Parser.next(p);
    constant;
  };

  let parseCommaDelimitedRegion = (p, ~grammar, ~closing, ~f) => {
    Parser.leaveBreadcrumb(p, grammar);
    let rec loop = nodes =>
      switch (f(p)) {
      | Some(node) =>
        switch (p.Parser.token) {
        | Comma =>
          Parser.next(p);
          loop([node, ...nodes]);
        | token when token == closing || token == Eof =>
          List.rev([node, ...nodes])
        | _ =>
          if (!(
                p.token == Eof
                || p.token == closing
                || Recover.shouldAbortListParse(p)
              )) {
            Parser.expect(Comma, p);
          };
          if (p.token == Semicolon) {
            Parser.next(p);
          };
          loop([node, ...nodes]);
        }
      | None =>
        if (p.token == Eof
            || p.token == closing
            || Recover.shouldAbortListParse(p)) {
          List.rev(nodes);
        } else {
          Parser.err(p, Diagnostics.unexpected(p.token, p.breadcrumbs));
          Parser.next(p);
          loop(nodes);
        }
      };

    let nodes = loop([]);
    Parser.eatBreadcrumb(p);
    nodes;
  };

  let parseCommaDelimitedReversedList = (p, ~grammar, ~closing, ~f) => {
    Parser.leaveBreadcrumb(p, grammar);
    let rec loop = nodes =>
      switch (f(p)) {
      | Some(node) =>
        switch (p.Parser.token) {
        | Comma =>
          Parser.next(p);
          loop([node, ...nodes]);
        | token when token == closing || token == Eof => [node, ...nodes]
        | _ =>
          if (!(
                p.token == Eof
                || p.token == closing
                || Recover.shouldAbortListParse(p)
              )) {
            Parser.expect(Comma, p);
          };
          if (p.token == Semicolon) {
            Parser.next(p);
          };
          loop([node, ...nodes]);
        }
      | None =>
        if (p.token == Eof
            || p.token == closing
            || Recover.shouldAbortListParse(p)) {
          nodes;
        } else {
          Parser.err(p, Diagnostics.unexpected(p.token, p.breadcrumbs));
          Parser.next(p);
          loop(nodes);
        }
      };

    let nodes = loop([]);
    Parser.eatBreadcrumb(p);
    nodes;
  };

  let parseDelimitedRegion = (p, ~grammar, ~closing, ~f) => {
    Parser.leaveBreadcrumb(p, grammar);
    let rec loop = nodes =>
      switch (f(p)) {
      | Some(node) => loop([node, ...nodes])
      | None =>
        if (p.Parser.token == Token.Eof
            || p.token == closing
            || Recover.shouldAbortListParse(p)) {
          List.rev(nodes);
        } else {
          Parser.err(p, Diagnostics.unexpected(p.token, p.breadcrumbs));
          Parser.next(p);
          loop(nodes);
        }
      };

    let nodes = loop([]);
    Parser.eatBreadcrumb(p);
    nodes;
  };

  let parseRegion = (p, ~grammar, ~f) => {
    Parser.leaveBreadcrumb(p, grammar);
    let rec loop = nodes =>
      switch (f(p)) {
      | Some(node) => loop([node, ...nodes])
      | None =>
        if (p.Parser.token == Token.Eof || Recover.shouldAbortListParse(p)) {
          List.rev(nodes);
        } else {
          Parser.err(p, Diagnostics.unexpected(p.token, p.breadcrumbs));
          Parser.next(p);
          loop(nodes);
        }
      };

    let nodes = loop([]);
    Parser.eatBreadcrumb(p);
    nodes;
  };

  /* let-binding	::=	pattern =  expr   */
  /* ∣	 value-name  { parameter }  [: typexpr]  [:> typexpr] =  expr   */
  /* ∣	 value-name :  poly-typexpr =  expr   */

  /* pattern	::=	value-name   */
  /* ∣	 _   */
  /* ∣	 constant   */
  /* ∣	 pattern as  value-name   */
  /* ∣	 ( pattern )   */
  /* ∣	 ( pattern :  typexpr )   */
  /* ∣	 pattern |  pattern   */
  /* ∣	 constr  pattern   */
  /* ∣	 #variant variant-pattern */
  /* ∣	 ##type  */
  /* ∣	 / pattern  { , pattern }+  /   */
  /* ∣	 { field  [: typexpr]  [= pattern] { ; field  [: typexpr]  [= pattern] }  [; _ ] [ ; ] }   */
  /* ∣	 [ pattern  { ; pattern }  [ ; ] ]   */
  /* ∣	 pattern ::  pattern   */
  /* ∣	 [| pattern  { ; pattern }  [ ; ] |]   */
  /* ∣	 char-literal ..  char-literal */
  /*	∣	 exception pattern  */
  let rec parsePattern = (~alias=true, ~or_=true, p) => {
    let startPos = p.Parser.startPos;
    let attrs = parseAttributes(p);
    let pat =
      switch (p.Parser.token) {
      | (True | False) as token =>
        let endPos = p.endPos;
        Parser.next(p);
        let loc = mkLoc(startPos, endPos);
        Ast_helper.Pat.construct(
          ~loc,
          Location.mkloc(Longident.Lident(Token.toString(token)), loc),
          None,
        );
      | Int(_)
      | String(_)
      | Float(_)
      | Character(_)
      | Minus
      | Plus =>
        let c = parseConstant(p);
        switch (p.token) {
        | DotDot =>
          Parser.next(p);
          let c2 = parseConstant(p);
          Ast_helper.Pat.interval(~loc=mkLoc(startPos, p.prevEndPos), c, c2);
        | _ => Ast_helper.Pat.constant(~loc=mkLoc(startPos, p.prevEndPos), c)
        };
      | Lparen =>
        Parser.next(p);
        switch (p.token) {
        | Rparen =>
          Parser.next(p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let lid = Location.mkloc(Longident.Lident("()"), loc);
          Ast_helper.Pat.construct(~loc, lid, None);
        | _ =>
          let pat = parseConstrainedPattern(p);
          switch (p.token) {
          | Comma =>
            Parser.next(p);
            parseTuplePattern(~attrs, ~first=pat, ~startPos, p);
          | _ =>
            Parser.expect(Rparen, p);
            let loc = mkLoc(startPos, p.prevEndPos);
            {...pat, ppat_loc: loc};
          };
        };
      | Lbracket => parseArrayPattern(~attrs, p)
      | Lbrace => parseRecordPattern(~attrs, p)
      | Underscore =>
        let endPos = p.endPos;
        let loc = mkLoc(startPos, endPos);
        Parser.next(p);
        Ast_helper.Pat.any(~loc, ~attrs, ());
      | Lident(ident) =>
        let endPos = p.endPos;
        let loc = mkLoc(startPos, endPos);
        Parser.next(p);
        Ast_helper.Pat.var(~loc, ~attrs, Location.mkloc(ident, loc));
      | Uident(_) =>
        let constr = parseModuleLongIdent(~lowercase=false, p);
        switch (p.Parser.token) {
        | Lparen => parseConstructorPatternArgs(p, constr, startPos, attrs)
        | _ => Ast_helper.Pat.construct(~loc=constr.loc, ~attrs, constr, None)
        };
      | Hash =>
        let (ident, loc) = parseHashIdent(~startPos, p);
        switch (p.Parser.token) {
        | Lparen => parseVariantPatternArgs(p, ident, startPos, attrs)
        | _ => Ast_helper.Pat.variant(~loc, ~attrs, ident, None)
        };
      | HashHash =>
        Parser.next(p);
        let ident = parseValuePath(p);
        let loc = mkLoc(startPos, ident.loc.loc_end);
        Ast_helper.Pat.type_(~loc, ~attrs, ident);
      | Exception =>
        Parser.next(p);
        let pat = parsePattern(~alias=false, ~or_=false, p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Pat.exception_(~loc, ~attrs, pat);
      | Lazy =>
        Parser.next(p);
        let pat = parsePattern(~alias=false, ~or_=false, p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Pat.lazy_(~loc, ~attrs, pat);
      | List =>
        Parser.next(p);
        switch (p.token) {
        | Lbracket => parseListPattern(~startPos, ~attrs, p)
        | _ =>
          let loc = mkLoc(startPos, p.prevEndPos);
          Ast_helper.Pat.var(~loc, ~attrs, Location.mkloc("list", loc));
        };
      | Module => parseModulePattern(~attrs, p)
      | Percent =>
        let extension = parseExtension(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Pat.extension(~loc, ~attrs, extension);
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        switch (
          skipTokensAndMaybeRetry(
            p,
            ~isStartOfGrammar=Grammar.isAtomicPatternStart,
          )
        ) {
        | None => Recover.defaultPattern()
        | Some () => parsePattern(p)
        };
      };

    let pat =
      if (alias) {
        parseAliasPattern(~attrs, pat, p);
      } else {
        pat;
      };
    if (or_) {
      parseOrPattern(pat, p);
    } else {
      pat;
    };
  }

  and skipTokensAndMaybeRetry = (p, ~isStartOfGrammar) =>
    if (Token.isKeyword(p.Parser.token)
        && p.Parser.prevEndPos.pos_lnum === p.startPos.pos_lnum) {
      Parser.next(p);
      None;
    } else if (Recover.shouldAbortListParse(p)) {
      if (isStartOfGrammar(p.Parser.token)) {
        Parser.next(p);
        Some();
      } else {
        None;
      };
    } else {
      Parser.next(p);
      let rec loop = p =>
        if (!Recover.shouldAbortListParse(p)) {
          Parser.next(p);
          loop(p);
        };
      loop(p);
      if (isStartOfGrammar(p.Parser.token)) {
        Some();
      } else {
        None;
      };
    }

  /* alias ::= pattern as lident */
  and parseAliasPattern = (~attrs, pattern, p) =>
    switch (p.Parser.token) {
    | As =>
      Parser.next(p);
      let (name, loc) = parseLident(p);
      let name = Location.mkloc(name, loc);
      Ast_helper.Pat.alias(
        ~loc={...pattern.ppat_loc, loc_end: p.prevEndPos},
        ~attrs,
        pattern,
        name,
      );
    | _ => pattern
    }

  /* or ::= pattern | pattern
   * precedence: Red | Blue | Green is interpreted as (Red | Blue) | Green */
  and parseOrPattern = (pattern1, p) => {
    let rec loop = pattern1 =>
      switch (p.Parser.token) {
      | Bar =>
        Parser.next(p);
        let pattern2 = parsePattern(~or_=false, p);
        let loc = {
          ...pattern1.Parsetree.ppat_loc,
          loc_end: pattern2.ppat_loc.loc_end,
        };
        loop(Ast_helper.Pat.or_(~loc, pattern1, pattern2));
      | _ => pattern1
      };

    loop(pattern1);
  }

  and parseNonSpreadPattern = (~msg, p) => {
    let () =
      switch (p.Parser.token) {
      | DotDotDot =>
        Parser.err(p, Diagnostics.message(msg));
        Parser.next(p);
      | _ => ()
      };

    switch (p.Parser.token) {
    | token when Grammar.isPatternStart(token) =>
      let pat = parsePattern(p);
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        let typ = parseTypExpr(p);
        let loc =
          mkLoc(pat.ppat_loc.loc_start, typ.Parsetree.ptyp_loc.loc_end);
        Some(Ast_helper.Pat.constraint_(~loc, pat, typ));
      | _ => Some(pat)
      };
    | _ => None
    };
  }

  and parseConstrainedPattern = p => {
    let pat = parsePattern(p);
    switch (p.Parser.token) {
    | Colon =>
      Parser.next(p);
      let typ = parseTypExpr(p);
      let loc = mkLoc(pat.ppat_loc.loc_start, typ.Parsetree.ptyp_loc.loc_end);
      Ast_helper.Pat.constraint_(~loc, pat, typ);
    | _ => pat
    };
  }

  and parseConstrainedPatternRegion = p =>
    switch (p.Parser.token) {
    | token when Grammar.isPatternStart(token) =>
      Some(parseConstrainedPattern(p))
    | _ => None
    }

  /* field ::=
   *   | longident
   *   | longident : pattern
   *   | longident as lident
    *
   *  row ::=
   *	 | field ,
   *	 | field , _
   *	 | field , _,
   */
  and parseRecordPatternField = p => {
    let startPos = p.Parser.startPos;
    let label = parseValuePath(p);
    let pattern =
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        parsePattern(p);
      | _ =>
        Ast_helper.Pat.var(
          ~loc=label.loc,
          Location.mkloc(Longident.last(label.txt), label.loc),
        )
      };

    switch (p.token) {
    | As =>
      Parser.next(p);
      let (name, loc) = parseLident(p);
      let name = Location.mkloc(name, loc);
      let aliasPattern =
        Ast_helper.Pat.alias(
          ~loc=mkLoc(startPos, p.prevEndPos),
          pattern,
          name,
        );

      (
        Location.mkloc(
          label.txt,
          mkLoc(startPos, aliasPattern.ppat_loc.loc_end),
        ),
        aliasPattern,
      );
    | _ => (label, pattern)
    };
  }

  /* TODO: there are better representations than PatField|Underscore ? */
  and parseRecordPatternItem = p =>
    switch (p.Parser.token) {
    | DotDotDot =>
      Parser.next(p);
      Some((true, PatField(parseRecordPatternField(p))));
    | Uident(_)
    | Lident(_) => Some((false, PatField(parseRecordPatternField(p))))
    | Underscore =>
      Parser.next(p);
      Some((false, PatUnderscore));
    | _ => None
    }

  and parseRecordPattern = (~attrs, p) => {
    let startPos = p.startPos;
    Parser.expect(Lbrace, p);
    let rawFields =
      parseCommaDelimitedReversedList(
        p,
        ~grammar=PatternRecord,
        ~closing=Rbrace,
        ~f=parseRecordPatternItem,
      );

    Parser.expect(Rbrace, p);
    let (fields, closedFlag) = {
      let (rawFields, flag) =
        switch (rawFields) {
        | [(_hasSpread, PatUnderscore), ...rest] => (rest, Asttypes.Open)
        | rawFields => (rawFields, Asttypes.Closed)
        };

      List.fold_left(
        ((fields, flag), curr) => {
          let (hasSpread, field) = curr;
          switch (field) {
          | PatField(field) =>
            if (hasSpread) {
              let (_, pattern) = field;
              Parser.err(
                ~startPos=pattern.Parsetree.ppat_loc.loc_start,
                p,
                Diagnostics.message(ErrorMessages.recordPatternSpread),
              );
            };
            ([field, ...fields], flag);
          | PatUnderscore => (fields, flag)
          };
        },
        ([], flag),
        rawFields,
      );
    };

    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Pat.record(~loc, ~attrs, fields, closedFlag);
  }

  and parseTuplePattern = (~attrs, ~first, ~startPos, p) => {
    let patterns =
      parseCommaDelimitedRegion(
        p,
        ~grammar=Grammar.PatternList,
        ~closing=Rparen,
        ~f=parseConstrainedPatternRegion,
      );

    Parser.expect(Rparen, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Pat.tuple(~loc, ~attrs, [first, ...patterns]);
  }

  and parsePatternRegion = p =>
    switch (p.Parser.token) {
    | DotDotDot =>
      Parser.next(p);
      Some((true, parseConstrainedPattern(p)));
    | token when Grammar.isPatternStart(token) =>
      Some((false, parseConstrainedPattern(p)))
    | _ => None
    }

  and parseModulePattern = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.expect(Module, p);
    Parser.expect(Lparen, p);
    let uident =
      switch (p.token) {
      | Uident(uident) =>
        let loc = mkLoc(p.startPos, p.endPos);
        Parser.next(p);
        Location.mkloc(uident, loc);
      | _ =>
        /* TODO: error recovery */
        Location.mknoloc("_")
      };

    switch (p.token) {
    | Colon =>
      let colonStart = p.Parser.startPos;
      Parser.next(p);
      let packageTypAttrs = parseAttributes(p);
      let packageType =
        parsePackageType(~startPos=colonStart, ~attrs=packageTypAttrs, p);
      Parser.expect(Rparen, p);
      let loc = mkLoc(startPos, p.prevEndPos);
      let unpack = Ast_helper.Pat.unpack(~loc=uident.loc, uident);
      Ast_helper.Pat.constraint_(~loc, ~attrs, unpack, packageType);
    | _ =>
      Parser.expect(Rparen, p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Pat.unpack(~loc, ~attrs, uident);
    };
  }

  and parseListPattern = (~startPos, ~attrs, p) => {
    Parser.expect(Lbracket, p);
    let listPatterns =
      parseCommaDelimitedReversedList(
        p,
        ~grammar=Grammar.PatternOcamlList,
        ~closing=Rbracket,
        ~f=parsePatternRegion,
      );

    Parser.expect(Rbracket, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    let filterSpread = ((hasSpread, pattern)) =>
      if (hasSpread) {
        Parser.err(
          ~startPos=pattern.Parsetree.ppat_loc.loc_start,
          p,
          Diagnostics.message(ErrorMessages.listPatternSpread),
        );
        pattern;
      } else {
        pattern;
      };

    switch (listPatterns) {
    | [(true, pattern), ...patterns] =>
      let patterns = patterns |> List.map(filterSpread) |> List.rev;
      let pat = makeListPattern(loc, patterns, Some(pattern));
      {...pat, ppat_loc: loc, ppat_attributes: attrs};
    | patterns =>
      let patterns = patterns |> List.map(filterSpread) |> List.rev;
      let pat = makeListPattern(loc, patterns, None);
      {...pat, ppat_loc: loc, ppat_attributes: attrs};
    };
  }

  and parseArrayPattern = (~attrs, p) => {
    let startPos = p.startPos;
    Parser.expect(Lbracket, p);
    let patterns =
      parseCommaDelimitedRegion(
        p,
        ~grammar=Grammar.PatternList,
        ~closing=Rbracket,
        ~f=parseNonSpreadPattern(~msg=ErrorMessages.arrayPatternSpread),
      );

    Parser.expect(Rbracket, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Pat.array(~loc, ~attrs, patterns);
  }

  and parseConstructorPatternArgs = (p, constr, startPos, attrs) => {
    let lparen = p.startPos;
    Parser.expect(Lparen, p);
    let args =
      parseCommaDelimitedRegion(
        p,
        ~grammar=Grammar.PatternList,
        ~closing=Rparen,
        ~f=parseConstrainedPatternRegion,
      );

    Parser.expect(Rparen, p);
    let args =
      switch (args) {
      | [] =>
        let loc = mkLoc(lparen, p.prevEndPos);
        Some(
          Ast_helper.Pat.construct(
            ~loc,
            Location.mkloc(Longident.Lident("()"), loc),
            None,
          ),
        );
      | [{ppat_desc: Ppat_tuple(_)} as pat] as patterns =>
        if (p.mode == ParseForTypeChecker) {
          /* Some(1, 2) for type-checker */
          Some(pat);
        } else {
          /* Some((1, 2)) for printer */
          Some(
            Ast_helper.Pat.tuple(~loc=mkLoc(lparen, p.endPos), patterns),
          );
        }
      | [pattern] => Some(pattern)
      | patterns =>
        Some(Ast_helper.Pat.tuple(~loc=mkLoc(lparen, p.endPos), patterns))
      };

    Ast_helper.Pat.construct(
      ~loc=mkLoc(startPos, p.prevEndPos),
      ~attrs,
      constr,
      args,
    );
  }

  and parseVariantPatternArgs = (p, ident, startPos, attrs) => {
    let lparen = p.startPos;
    Parser.expect(Lparen, p);
    let patterns =
      parseCommaDelimitedRegion(
        p,
        ~grammar=Grammar.PatternList,
        ~closing=Rparen,
        ~f=parseConstrainedPatternRegion,
      );
    let args =
      switch (patterns) {
      | [{ppat_desc: Ppat_tuple(_)} as pat] as patterns =>
        if (p.mode == ParseForTypeChecker) {
          /* #ident(1, 2) for type-checker */
          Some(pat);
        } else {
          /* #ident((1, 2)) for printer */
          Some(
            Ast_helper.Pat.tuple(~loc=mkLoc(lparen, p.endPos), patterns),
          );
        }
      | [pattern] => Some(pattern)
      | patterns =>
        Some(Ast_helper.Pat.tuple(~loc=mkLoc(lparen, p.endPos), patterns))
      };

    Parser.expect(Rparen, p);
    Ast_helper.Pat.variant(
      ~loc=mkLoc(startPos, p.prevEndPos),
      ~attrs,
      ident,
      args,
    );
  }

  and parseExpr = (~context=OrdinaryExpr, p) => {
    let expr = parseOperandExpr(~context, p);
    let expr = parseBinaryExpr(~context, ~a=expr, p, 1);
    parseTernaryExpr(expr, p);
  }

  /* expr ? expr : expr */
  and parseTernaryExpr = (leftOperand, p) =>
    switch (p.Parser.token) {
    | Question =>
      Parser.leaveBreadcrumb(p, Grammar.Ternary);
      Parser.next(p);
      let trueBranch = parseExpr(~context=TernaryTrueBranchExpr, p);
      Parser.expect(Colon, p);
      let falseBranch = parseExpr(p);
      Parser.eatBreadcrumb(p);
      let loc = {
        ...leftOperand.Parsetree.pexp_loc,
        loc_start: leftOperand.pexp_loc.loc_start,
        loc_end: falseBranch.Parsetree.pexp_loc.loc_end,
      };
      Ast_helper.Exp.ifthenelse(
        ~attrs=[ternaryAttr],
        ~loc,
        leftOperand,
        trueBranch,
        Some(falseBranch),
      );
    | _ => leftOperand
    }

  and parseEs6ArrowExpression = (~parameters=?, p) => {
    let startPos = p.Parser.startPos;
    Parser.leaveBreadcrumb(p, Grammar.Es6ArrowExpr);
    let parameters =
      switch (parameters) {
      | Some(params) => params
      | None => parseParameters(p)
      };

    let returnType =
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        Some(parseTypExpr(~es6Arrow=false, p));
      | _ => None
      };

    Parser.expect(EqualGreater, p);
    let body = {
      let expr = parseExpr(p);
      switch (returnType) {
      | Some(typ) =>
        Ast_helper.Exp.constraint_(
          ~loc=mkLoc(expr.pexp_loc.loc_start, typ.Parsetree.ptyp_loc.loc_end),
          expr,
          typ,
        )
      | None => expr
      };
    };

    Parser.eatBreadcrumb(p);
    let endPos = p.prevEndPos;
    let arrowExpr =
      List.fold_right(
        (parameter, expr) =>
          switch (parameter) {
          | TermParameter({
              uncurried,
              attrs,
              label: lbl,
              expr: defaultExpr,
              pat,
              pos: startPos,
            }) =>
            let attrs =
              if (uncurried) {
                [uncurryAttr, ...attrs];
              } else {
                attrs;
              };
            Ast_helper.Exp.fun_(
              ~loc=mkLoc(startPos, endPos),
              ~attrs,
              lbl,
              defaultExpr,
              pat,
              expr,
            );
          | TypeParameter({uncurried, attrs, locs: newtypes, pos: startPos}) =>
            let attrs =
              if (uncurried) {
                [uncurryAttr, ...attrs];
              } else {
                attrs;
              };
            makeNewtypes(
              ~attrs,
              ~loc=mkLoc(startPos, endPos),
              newtypes,
              expr,
            );
          },
        parameters,
        body,
      );

    {
      ...arrowExpr,
      pexp_loc: {
        ...arrowExpr.pexp_loc,
        loc_start: startPos,
      },
    };
  }

  /*
    * uncurried_parameter ::=
    *   | . parameter
    *
   * parameter ::=
   *   | pattern
    *   | pattern : type
   *   | ~ labelName
   *   | ~ labelName as pattern
   *   | ~ labelName as pattern : type
   *   | ~ labelName = expr
   *   | ~ labelName as pattern = expr
   *   | ~ labelName as pattern : type = expr
   *   | ~ labelName = ?
   *   | ~ labelName as pattern = ?
   *   | ~ labelName as pattern : type = ?
    *
   * labelName ::= lident
    */
  and parseParameter = p =>
    if (p.Parser.token == Token.Typ
        || p.token == Tilde
        || p.token == Dot
        || Grammar.isPatternStart(p.token)) {
      let startPos = p.Parser.startPos;
      let uncurried = Parser.optional(p, Token.Dot);
      /* two scenarios:
       *   attrs ~lbl ...
       *   attrs pattern
       * Attributes before a labelled arg, indicate that it's on the whole arrow expr
       * Otherwise it's part of the pattern
       *  */
      let attrs = parseAttributes(p);
      if (p.Parser.token == Typ) {
        Parser.next(p);
        let lidents = parseLidentList(p);
        Some(
          TypeParameter({uncurried, attrs, locs: lidents, pos: startPos}),
        );
      } else {
        let (attrs, lbl, pat) =
          switch (p.Parser.token) {
          | Tilde =>
            Parser.next(p);
            let (lblName, loc) = parseLident(p);
            let propLocAttr = (
              Location.mkloc("ns.namedArgLoc", loc),
              Parsetree.PStr([]),
            );
            switch (p.Parser.token) {
            | Comma
            | Equal
            | Rparen =>
              let loc = mkLoc(startPos, p.prevEndPos);
              (
                attrs,
                Asttypes.Labelled(lblName),
                Ast_helper.Pat.var(
                  ~attrs=[propLocAttr],
                  ~loc,
                  Location.mkloc(lblName, loc),
                ),
              );
            | Colon =>
              let lblEnd = p.prevEndPos;
              Parser.next(p);
              let typ = parseTypExpr(p);
              let loc = mkLoc(startPos, lblEnd);
              let pat = {
                let pat =
                  Ast_helper.Pat.var(~loc, Location.mkloc(lblName, loc));
                let loc = mkLoc(startPos, p.prevEndPos);
                Ast_helper.Pat.constraint_(
                  ~attrs=[propLocAttr],
                  ~loc,
                  pat,
                  typ,
                );
              };
              (attrs, Asttypes.Labelled(lblName), pat);
            | As =>
              Parser.next(p);
              let pat = {
                let pat = parseConstrainedPattern(p);
                {
                  ...pat,
                  ppat_attributes: [propLocAttr, ...pat.ppat_attributes],
                };
              };

              (attrs, Asttypes.Labelled(lblName), pat);
            | t =>
              Parser.err(p, Diagnostics.unexpected(t, p.breadcrumbs));
              let loc = mkLoc(startPos, p.prevEndPos);
              (
                attrs,
                Asttypes.Labelled(lblName),
                Ast_helper.Pat.var(~loc, Location.mkloc(lblName, loc)),
              );
            };
          | _ =>
            let pattern = parseConstrainedPattern(p);
            let attrs = List.concat([attrs, pattern.ppat_attributes]);
            ([], Asttypes.Nolabel, {...pattern, ppat_attributes: attrs});
          };

        switch (p.Parser.token) {
        | Equal =>
          Parser.next(p);
          let lbl =
            switch (lbl) {
            | Asttypes.Labelled(lblName) => Asttypes.Optional(lblName)
            | Asttypes.Optional(_) as lbl => lbl
            | Asttypes.Nolabel => Asttypes.Nolabel
            };

          switch (p.Parser.token) {
          | Question =>
            Parser.next(p);
            Some(
              TermParameter({
                uncurried,
                attrs,
                label: lbl,
                expr: None,
                pat,
                pos: startPos,
              }),
            );
          | _ =>
            let expr = parseConstrainedOrCoercedExpr(p);
            Some(
              TermParameter({
                uncurried,
                attrs,
                label: lbl,
                expr: Some(expr),
                pat,
                pos: startPos,
              }),
            );
          };
        | _ =>
          Some(
            TermParameter({
              uncurried,
              attrs,
              label: lbl,
              expr: None,
              pat,
              pos: startPos,
            }),
          )
        };
      };
    } else {
      None;
    }

  and parseParameterList = p => {
    let parameters =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.ParameterList,
        ~f=parseParameter,
        ~closing=Rparen,
        p,
      );

    Parser.expect(Rparen, p);
    parameters;
  }

  /* parameters ::=
   *   | _
   *   | lident
   *   | ()
   *   | (.)
   *   | ( parameter {, parameter} [,] )
   */
  and parseParameters = p => {
    let startPos = p.Parser.startPos;
    switch (p.Parser.token) {
    | Lident(ident) =>
      Parser.next(p);
      let loc = mkLoc(startPos, p.Parser.prevEndPos);
      [
        TermParameter({
          uncurried: false,
          attrs: [],
          label: Asttypes.Nolabel,
          expr: None,
          pat: Ast_helper.Pat.var(~loc, Location.mkloc(ident, loc)),
          pos: startPos,
        }),
      ];
    | List =>
      Parser.next(p);
      let loc = mkLoc(startPos, p.Parser.prevEndPos);
      [
        TermParameter({
          uncurried: false,
          attrs: [],
          label: Asttypes.Nolabel,
          expr: None,
          pat: Ast_helper.Pat.var(~loc, Location.mkloc("list", loc)),
          pos: startPos,
        }),
      ];
    | Underscore =>
      Parser.next(p);
      let loc = mkLoc(startPos, p.Parser.prevEndPos);
      [
        TermParameter({
          uncurried: false,
          attrs: [],
          label: Asttypes.Nolabel,
          expr: None,
          pat: Ast_helper.Pat.any(~loc, ()),
          pos: startPos,
        }),
      ];
    | Lparen =>
      Parser.next(p);
      switch (p.Parser.token) {
      | Rparen =>
        Parser.next(p);
        let loc = mkLoc(startPos, p.Parser.prevEndPos);
        let unitPattern =
          Ast_helper.Pat.construct(
            ~loc,
            Location.mkloc(Longident.Lident("()"), loc),
            None,
          );

        [
          TermParameter({
            uncurried: false,
            attrs: [],
            label: Asttypes.Nolabel,
            expr: None,
            pat: unitPattern,
            pos: startPos,
          }),
        ];
      | Dot =>
        Parser.next(p);
        switch (p.token) {
        | Rparen =>
          Parser.next(p);
          let loc = mkLoc(startPos, p.Parser.prevEndPos);
          let unitPattern =
            Ast_helper.Pat.construct(
              ~loc,
              Location.mkloc(Longident.Lident("()"), loc),
              None,
            );

          [
            TermParameter({
              uncurried: true,
              attrs: [],
              label: Asttypes.Nolabel,
              expr: None,
              pat: unitPattern,
              pos: startPos,
            }),
          ];
        | _ =>
          switch (parseParameterList(p)) {
          | [
              TermParameter({
                attrs,
                label: lbl,
                expr: defaultExpr,
                pat: pattern,
                pos: startPos,
              }),
              ...rest,
            ] => [
              TermParameter({
                uncurried: true,
                attrs,
                label: lbl,
                expr: defaultExpr,
                pat: pattern,
                pos: startPos,
              }),
              ...rest,
            ]
          | parameters => parameters
          }
        };
      | _ => parseParameterList(p)
      };
    | token =>
      Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
      [];
    };
  }

  and parseCoercedExpr = (~expr: Parsetree.expression, p) => {
    Parser.expect(ColonGreaterThan, p);
    let typ = parseTypExpr(p);
    let loc = mkLoc(expr.pexp_loc.loc_start, p.prevEndPos);
    Ast_helper.Exp.coerce(~loc, expr, None, typ);
  }

  and parseConstrainedOrCoercedExpr = p => {
    let expr = parseExpr(p);
    switch (p.Parser.token) {
    | ColonGreaterThan => parseCoercedExpr(~expr, p)
    | Colon =>
      Parser.next(p);
      switch (p.token) {
      | _ =>
        let typ = parseTypExpr(p);
        let loc = mkLoc(expr.pexp_loc.loc_start, typ.ptyp_loc.loc_end);
        let expr = Ast_helper.Exp.constraint_(~loc, expr, typ);
        switch (p.token) {
        | ColonGreaterThan => parseCoercedExpr(~expr, p)
        | _ => expr
        };
      };
    | _ => expr
    };
  }

  and parseConstrainedExprRegion = p =>
    switch (p.Parser.token) {
    | token when Grammar.isExprStart(token) =>
      let expr = parseExpr(p);
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        let typ = parseTypExpr(p);
        let loc = mkLoc(expr.pexp_loc.loc_start, typ.ptyp_loc.loc_end);
        Some(Ast_helper.Exp.constraint_(~loc, expr, typ));
      | _ => Some(expr)
      };
    | _ => None
    }

  /* Atomic expressions represent unambiguous expressions.
   * This means that regardless of the context, these expressions
   * are always interpreted correctly. */
  and parseAtomicExpr = p => {
    Parser.leaveBreadcrumb(p, Grammar.ExprOperand);
    let startPos = p.Parser.startPos;
    let expr =
      switch (p.Parser.token) {
      | (True | False) as token =>
        Parser.next(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Exp.construct(
          ~loc,
          Location.mkloc(Longident.Lident(Token.toString(token)), loc),
          None,
        );
      | Int(_)
      | String(_)
      | Float(_)
      | Character(_) =>
        let c = parseConstant(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Exp.constant(~loc, c);
      | Backtick =>
        let expr = parseTemplateExpr(p);
        {...expr, pexp_loc: mkLoc(startPos, p.prevEndPos)};
      | Uident(_)
      | Lident(_) => parseValueOrConstructor(p)
      | Hash => parsePolyVariantExpr(p)
      | Lparen =>
        Parser.next(p);
        switch (p.Parser.token) {
        | Rparen =>
          Parser.next(p);
          let loc = mkLoc(startPos, p.prevEndPos);
          Ast_helper.Exp.construct(
            ~loc,
            Location.mkloc(Longident.Lident("()"), loc),
            None,
          );
        | _t =>
          let expr = parseConstrainedOrCoercedExpr(p);
          switch (p.token) {
          | Comma =>
            Parser.next(p);
            parseTupleExpr(~startPos, ~first=expr, p);
          | _ =>
            Parser.expect(Rparen, p);
            expr;
          /* {expr with pexp_loc = mkLoc startPos p.prevEndPos}
           * What does this location mean here? It means that when there's
           * a parenthesized we keep the location here for whitespace interleaving.
           * Without the closing paren in the location there will always be an extra
           * line. For now we don't include it, because it does weird things
           * with for comments. */
          };
        };
      | List =>
        Parser.next(p);
        switch (p.token) {
        | Lbracket => parseListExpr(~startPos, p)
        | _ =>
          let loc = mkLoc(startPos, p.prevEndPos);
          Ast_helper.Exp.ident(
            ~loc,
            Location.mkloc(Longident.Lident("list"), loc),
          );
        };
      | Module =>
        Parser.next(p);
        parseFirstClassModuleExpr(~startPos, p);
      | Lbracket => parseArrayExp(p)
      | Lbrace => parseBracedOrRecordExpr(p)
      | LessThan => parseJsx(p)
      | Percent =>
        let extension = parseExtension(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Exp.extension(~loc, extension);
      | Underscore as token =>
        /* This case is for error recovery. Not sure if it's the correct place */
        Parser.err(p, Diagnostics.lident(token));
        Parser.next(p);
        Recover.defaultExpr();
      | token =>
        let errPos = p.prevEndPos;
        switch (
          skipTokensAndMaybeRetry(
            p,
            ~isStartOfGrammar=Grammar.isAtomicExprStart,
          )
        ) {
        | None =>
          Parser.err(
            ~startPos=errPos,
            p,
            Diagnostics.unexpected(token, p.breadcrumbs),
          );
          Recover.defaultExpr();
        | Some () => parseAtomicExpr(p)
        };
      };

    Parser.eatBreadcrumb(p);
    expr;
  }

  /* module(module-expr)
   * module(module-expr : package-type) */
  and parseFirstClassModuleExpr = (~startPos, p) => {
    Parser.expect(Lparen, p);

    let modExpr = parseModuleExpr(p);
    let modEndLoc = p.prevEndPos;
    switch (p.Parser.token) {
    | Colon =>
      let colonStart = p.Parser.startPos;
      Parser.next(p);
      let attrs = parseAttributes(p);
      let packageType = parsePackageType(~startPos=colonStart, ~attrs, p);
      Parser.expect(Rparen, p);
      let loc = mkLoc(startPos, modEndLoc);
      let firstClassModule = Ast_helper.Exp.pack(~loc, modExpr);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Exp.constraint_(~loc, firstClassModule, packageType);
    | _ =>
      Parser.expect(Rparen, p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Exp.pack(~loc, modExpr);
    };
  }

  and parseBracketAccess = (p, expr, startPos) => {
    Parser.leaveBreadcrumb(p, Grammar.ExprArrayAccess);
    let lbracket = p.startPos;
    Parser.next(p);
    let stringStart = p.startPos;
    switch (p.Parser.token) {
    | String(s) =>
      Parser.next(p);
      let stringEnd = p.prevEndPos;
      Parser.expect(Rbracket, p);
      let rbracket = p.prevEndPos;
      let e = {
        let identLoc = mkLoc(stringStart, stringEnd);
        let loc = mkLoc(lbracket, rbracket);
        Ast_helper.Exp.apply(
          ~loc,
          Ast_helper.Exp.ident(
            ~loc,
            Location.mkloc(Longident.Lident("##"), loc),
          ),
          [
            (Nolabel, expr),
            (
              Nolabel,
              Ast_helper.Exp.ident(
                ~loc=identLoc,
                Location.mkloc(Longident.Lident(s), identLoc),
              ),
            ),
          ],
        );
      };

      let e = parsePrimaryExpr(~operand=e, p);
      let equalStart = p.startPos;
      switch (p.token) {
      | Equal =>
        Parser.next(p);
        let equalEnd = p.prevEndPos;
        let rhsExpr = parseExpr(p);
        let loc = mkLoc(startPos, rhsExpr.pexp_loc.loc_end);
        let operatorLoc = mkLoc(equalStart, equalEnd);
        Ast_helper.Exp.apply(
          ~loc,
          Ast_helper.Exp.ident(
            ~loc=operatorLoc,
            Location.mkloc(Longident.Lident("#="), operatorLoc),
          ),
          [(Nolabel, e), (Nolabel, rhsExpr)],
        );
      | _ => e
      };
    | _ =>
      let accessExpr = parseConstrainedOrCoercedExpr(p);
      Parser.expect(Rbracket, p);
      let rbracket = p.prevEndPos;
      let arrayLoc = mkLoc(lbracket, rbracket);
      switch (p.token) {
      | Equal =>
        Parser.leaveBreadcrumb(p, ExprArrayMutation);
        Parser.next(p);
        let rhsExpr = parseExpr(p);
        let arraySet =
          Location.mkloc(
            [@implicit_arity] Longident.Ldot(Lident("Array"), "set"),
            arrayLoc,
          );

        let endPos = p.prevEndPos;
        let arraySet =
          Ast_helper.Exp.apply(
            ~loc=mkLoc(startPos, endPos),
            Ast_helper.Exp.ident(~loc=arrayLoc, arraySet),
            [(Nolabel, expr), (Nolabel, accessExpr), (Nolabel, rhsExpr)],
          );

        Parser.eatBreadcrumb(p);
        arraySet;
      | _ =>
        let endPos = p.prevEndPos;
        let e =
          Ast_helper.Exp.apply(
            ~loc=mkLoc(startPos, endPos),
            Ast_helper.Exp.ident(
              ~loc=arrayLoc,
              Location.mkloc(
                [@implicit_arity] Longident.Ldot(Lident("Array"), "get"),
                arrayLoc,
              ),
            ),
            [(Nolabel, expr), (Nolabel, accessExpr)],
          );

        Parser.eatBreadcrumb(p);
        parsePrimaryExpr(~operand=e, p);
      };
    };
  }

  /* * A primary expression represents
   *  - atomic-expr
   *  - john.age
   *  - array[0]
   *  - applyFunctionTo(arg1, arg2)
   *
   *  The "operand" represents the expression that is operated on
   */
  and parsePrimaryExpr = (~operand, ~noCall=false, p) => {
    let startPos = operand.pexp_loc.loc_start;
    let rec loop = (p, expr) =>
      switch (p.Parser.token) {
      | Dot =>
        Parser.next(p);
        let lident = parseValuePath(p);
        switch (p.Parser.token) {
        | Equal when noCall == false =>
          Parser.leaveBreadcrumb(p, Grammar.ExprSetField);
          Parser.next(p);
          let targetExpr = parseExpr(p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let setfield =
            Ast_helper.Exp.setfield(~loc, expr, lident, targetExpr);
          Parser.eatBreadcrumb(p);
          setfield;
        | _ =>
          let endPos = p.prevEndPos;
          let loc = mkLoc(startPos, endPos);
          loop(p, Ast_helper.Exp.field(~loc, expr, lident));
        };
      | Lbracket
          when noCall == false && p.prevEndPos.pos_lnum === p.startPos.pos_lnum =>
        parseBracketAccess(p, expr, startPos)
      | Lparen
          when noCall == false && p.prevEndPos.pos_lnum === p.startPos.pos_lnum =>
        loop(p, parseCallExpr(p, expr))
      | Backtick
          when noCall == false && p.prevEndPos.pos_lnum === p.startPos.pos_lnum =>
        switch (expr.pexp_desc) {
        | Pexp_ident({txt: Longident.Lident(ident)}) =>
          parseTemplateExpr(~prefix=ident, p)
        | _ =>
          Parser.err(
            ~startPos=expr.pexp_loc.loc_start,
            ~endPos=expr.pexp_loc.loc_end,
            p,
            Diagnostics.message(
              "Tagged template literals are currently restricted to identifiers like: json`null`.",
            ),
          );
          parseTemplateExpr(p);
        }
      | _ => expr
      };

    loop(p, operand);
  }

  /* a unary expression is an expression with only one operand and
   * unary operator. Examples:
   *   -1
   *   !condition
   *   -. 1.6
   */
  and parseUnaryExpr = p => {
    let startPos = p.Parser.startPos;
    switch (p.Parser.token) {
    | (Minus | MinusDot | Plus | PlusDot | Bang) as token =>
      Parser.leaveBreadcrumb(p, Grammar.ExprUnary);
      let tokenEnd = p.endPos;
      Parser.next(p);
      let operand = parseUnaryExpr(p);
      let unaryExpr = makeUnaryExpr(startPos, tokenEnd, token, operand);
      Parser.eatBreadcrumb(p);
      unaryExpr;
    | _ => parsePrimaryExpr(~operand=parseAtomicExpr(p), p)
    };
  }

  /* Represents an "operand" in a binary expression.
   * If you have `a + b`, `a` and `b` both represent
   * the operands of the binary expression with opeartor `+` */
  and parseOperandExpr = (~context, p) => {
    let startPos = p.Parser.startPos;
    let attrs = parseAttributes(p);
    let expr =
      switch (p.Parser.token) {
      | Assert =>
        Parser.next(p);
        let expr = parseUnaryExpr(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Exp.assert_(~loc, expr);
      | Lazy =>
        Parser.next(p);
        let expr = parseUnaryExpr(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Exp.lazy_(~loc, expr);
      | Try => parseTryExpression(p)
      | If => parseIfExpression(p)
      | For => parseForExpression(p)
      | While => parseWhileExpression(p)
      | Switch => parseSwitchExpression(p)
      | _ =>
        if (context !== WhenExpr
            && isEs6ArrowExpression(
                 ~inTernary=context == TernaryTrueBranchExpr,
                 p,
               )) {
          parseEs6ArrowExpression(p);
        } else {
          parseUnaryExpr(p);
        }
      };

    /* let endPos = p.Parser.prevEndPos in */
    {
      ...expr,
      pexp_attributes: List.concat([expr.Parsetree.pexp_attributes, attrs]),
      /* pexp_loc = mkLoc startPos endPos */
    };
  }

  /* a binary expression is an expression that combines two expressions with an
   * operator. Examples:
   *    a + b
   *    f(x) |> g(y)
   */
  and parseBinaryExpr = (~context=OrdinaryExpr, ~a=?, p, prec) => {
    let a =
      switch (a) {
      | Some(e) => e
      | None => parseOperandExpr(~context, p)
      };

    let rec loop = a => {
      let token = p.Parser.token;
      let tokenPrec =
        switch (token) {
        /* Can the minus be interpreted as a binary operator? Or is it a unary?
         * let w = {
         *   x
         *   -10
         * }
         * vs
         * let w = {
         *   width
         *   - gap
         * }
         *
         * First case is unary, second is a binary operator.
         * See Scanner.isBinaryOp */
        | Minus
        | MinusDot
        | LessThan
            when
              !
                Scanner.isBinaryOp(
                  p.scanner.src,
                  p.startPos.pos_cnum,
                  p.endPos.pos_cnum,
                )
              && p.startPos.pos_lnum > p.prevEndPos.pos_lnum => (-1)
        | token => Token.precedence(token)
        };

      if (tokenPrec < prec) {
        a;
      } else {
        Parser.leaveBreadcrumb(p, Grammar.ExprBinaryAfterOp(token));
        let startPos = p.startPos;
        Parser.next(p);
        let endPos = p.prevEndPos;
        let b = parseBinaryExpr(~context, p, tokenPrec + 1);
        let loc = mkLoc(a.Parsetree.pexp_loc.loc_start, b.pexp_loc.loc_end);
        let expr =
          Ast_helper.Exp.apply(
            ~loc,
            makeInfixOperator(p, token, startPos, endPos),
            [(Nolabel, a), (Nolabel, b)],
          );

        loop(expr);
      };
    };

    loop(a);
  }

  /* If we even need this, determines if < might be the start of jsx. Not 100% complete */
  /* and isStartOfJsx p = */
  /* Parser.lookahead p (fun p -> */
  /* match p.Parser.token with */
  /* | LessThan -> */
  /* Parser.next p; */
  /* begin match p.token with */
  /* | GreaterThan (* <> *) -> true */
  /* | Lident _ | Uident _ | List -> */
  /* ignore (parseJsxName p); */
  /* begin match p.token with */
  /* | GreaterThan (* <div> *) -> true */
  /* | Question (*<Component ? *) -> true */
  /* | Lident _ | List -> */
  /* Parser.next p; */
  /* begin match p.token with */
  /* | Equal (* <Component handleClick= *) -> true */
  /* | _ -> false (* TODO *) */
  /* end */
  /* | Forwardslash (* <Component / *)-> */
  /* Parser.next p; */
  /* begin match p.token with */
  /* | GreaterThan (* <Component /> *) -> true */
  /* | _ -> false */
  /* end */
  /* | _ -> */
  /* false */
  /* end */
  /* | _ -> false */
  /* end */
  /* | _ -> false */
  /* ) */

  and parseTemplateExpr = (~prefix="", p) => {
    let hiddenOperator = {
      let op = Location.mknoloc(Longident.Lident("^"));
      Ast_helper.Exp.ident(op);
    };

    let rec loop = (acc, p) => {
      let startPos = p.Parser.startPos;
      switch (p.Parser.token) {
      | TemplateTail(txt) =>
        Parser.next(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        if (String.length(txt) > 0) {
          let txt =
            if (p.mode == ParseForTypeChecker) {
              parseTemplateStringLiteral(txt);
            } else {
              txt;
            };
          let str =
            Ast_helper.Exp.constant(
              ~loc,
              [@implicit_arity] Pconst_string(txt, Some(prefix)),
            );
          Ast_helper.Exp.apply(
            ~loc,
            hiddenOperator,
            [(Nolabel, acc), (Nolabel, str)],
          );
        } else {
          acc;
        };
      | TemplatePart(txt) =>
        Parser.next(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        let expr = parseExprBlock(p);
        let fullLoc = mkLoc(startPos, p.prevEndPos);
        Scanner.setTemplateMode(p.scanner);
        Parser.expect(Rbrace, p);
        let txt =
          if (p.mode == ParseForTypeChecker) {
            parseTemplateStringLiteral(txt);
          } else {
            txt;
          };
        let str =
          Ast_helper.Exp.constant(
            ~loc,
            [@implicit_arity] Pconst_string(txt, Some(prefix)),
          );
        let next = {
          let a =
            if (String.length(txt) > 0) {
              Ast_helper.Exp.apply(
                ~loc=fullLoc,
                hiddenOperator,
                [(Nolabel, acc), (Nolabel, str)],
              );
            } else {
              acc;
            };

          Ast_helper.Exp.apply(
            ~loc=fullLoc,
            hiddenOperator,
            [(Nolabel, a), (Nolabel, expr)],
          );
        };

        loop(next, p);
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        acc;
      };
    };

    Scanner.setTemplateMode(p.scanner);
    Parser.expect(Backtick, p);
    let startPos = p.Parser.startPos;
    switch (p.Parser.token) {
    | TemplateTail(txt) =>
      let loc = mkLoc(startPos, p.endPos);
      Parser.next(p);
      let txt =
        if (p.mode == ParseForTypeChecker) {
          parseTemplateStringLiteral(txt);
        } else {
          txt;
        };
      Ast_helper.Exp.constant(
        ~loc,
        [@implicit_arity] Pconst_string(txt, Some(prefix)),
      );
    | TemplatePart(txt) =>
      let constantLoc = mkLoc(startPos, p.endPos);
      Parser.next(p);
      let expr = parseExprBlock(p);
      let fullLoc = mkLoc(startPos, p.prevEndPos);
      Scanner.setTemplateMode(p.scanner);
      Parser.expect(Rbrace, p);
      let txt =
        if (p.mode == ParseForTypeChecker) {
          parseTemplateStringLiteral(txt);
        } else {
          txt;
        };
      let str =
        Ast_helper.Exp.constant(
          ~loc=constantLoc,
          [@implicit_arity] Pconst_string(txt, Some(prefix)),
        );
      let next =
        if (String.length(txt) > 0) {
          Ast_helper.Exp.apply(
            ~loc=fullLoc,
            hiddenOperator,
            [(Nolabel, str), (Nolabel, expr)],
          );
        } else {
          expr;
        };

      loop(next, p);
    | token =>
      Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
      Ast_helper.Exp.constant([@implicit_arity] Pconst_string("", None));
    };
  }

  /* Overparse: let f = a : int => a + 1, is it (a : int) => or (a): int =>
   * Also overparse constraints:
   *  let x = {
   *    let a = 1
   *    a + pi: int
   *  }
   *
   *  We want to give a nice error message in these cases
   *  */
  and overParseConstrainedOrCoercedOrArrowExpression = (p, expr) =>
    switch (p.Parser.token) {
    | ColonGreaterThan => parseCoercedExpr(~expr, p)
    | Colon =>
      Parser.next(p);
      let typ = parseTypExpr(~es6Arrow=false, p);
      switch (p.Parser.token) {
      | EqualGreater =>
        Parser.next(p);
        let body = parseExpr(p);
        let pat =
          switch (expr.pexp_desc) {
          | Pexp_ident(longident) =>
            Ast_helper.Pat.var(
              ~loc=expr.pexp_loc,
              Location.mkloc(
                Longident.flatten(longident.txt) |> String.concat("."),
                longident.loc,
              ),
            )
          /* TODO: can we convert more expressions to patterns?*/
          | _ =>
            Ast_helper.Pat.var(
              ~loc=expr.pexp_loc,
              Location.mkloc("pattern", expr.pexp_loc),
            )
          };

        let arrow1 =
          Ast_helper.Exp.fun_(
            ~loc=mkLoc(expr.pexp_loc.loc_start, body.pexp_loc.loc_end),
            Asttypes.Nolabel,
            None,
            pat,
            Ast_helper.Exp.constraint_(body, typ),
          );

        let arrow2 =
          Ast_helper.Exp.fun_(
            ~loc=mkLoc(expr.pexp_loc.loc_start, body.pexp_loc.loc_end),
            Asttypes.Nolabel,
            None,
            Ast_helper.Pat.constraint_(pat, typ),
            body,
          );

        let msg =
          Doc.breakableGroup(
            ~forceBreak=true,
            Doc.concat([
              Doc.text(
                "Did you mean to annotate the parameter type or the return type?",
              ),
              Doc.indent(
                Doc.concat([
                  Doc.line,
                  Doc.text("1) "),
                  Printer.printExpression(arrow1, CommentTable.empty),
                  Doc.line,
                  Doc.text("2) "),
                  Printer.printExpression(arrow2, CommentTable.empty),
                ]),
              ),
            ]),
          )
          |> Doc.toString(~width=80);

        Parser.err(
          ~startPos=expr.pexp_loc.loc_start,
          ~endPos=body.pexp_loc.loc_end,
          p,
          Diagnostics.message(msg),
        );
        arrow1;
      | _ =>
        open Parsetree;
        let loc = mkLoc(expr.pexp_loc.loc_start, typ.ptyp_loc.loc_end);
        let expr = Ast_helper.Exp.constraint_(~loc, expr, typ);
        let () =
          Parser.err(
            ~startPos=expr.pexp_loc.loc_start,
            ~endPos=typ.ptyp_loc.loc_end,
            p,
            Diagnostics.message(
              Doc.breakableGroup(
                ~forceBreak=true,
                Doc.concat([
                  Doc.text(
                    "Expressions with type constraints need to be wrapped in parens:",
                  ),
                  Doc.indent(
                    Doc.concat([
                      Doc.line,
                      Printer.addParens(
                        Printer.printExpression(expr, CommentTable.empty),
                      ),
                    ]),
                  ),
                ]),
              )
              |> Doc.toString(~width=80),
            ),
          );

        expr;
      };
    | _ => expr
    }

  and parseLetBindingBody = (~startPos, ~attrs, p) => {
    Parser.beginRegion(p);
    Parser.leaveBreadcrumb(p, Grammar.LetBinding);
    let (pat, exp) = {
      let pat = parsePattern(p);
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        switch (p.token) {
        | Typ =>
          /* locally abstract types */
          Parser.next(p);
          let newtypes = parseLidentList(p);
          Parser.expect(Dot, p);
          let typ = parseTypExpr(p);
          Parser.expect(Equal, p);
          let expr = parseExpr(p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let (exp, poly) = wrapTypeAnnotation(~loc, newtypes, typ, expr);
          let pat = Ast_helper.Pat.constraint_(~loc, pat, poly);
          (pat, exp);
        | _ =>
          let polyType = parsePolyTypeExpr(p);
          let loc = {
            ...pat.ppat_loc,
            loc_end: polyType.Parsetree.ptyp_loc.loc_end,
          };
          let pat = Ast_helper.Pat.constraint_(~loc, pat, polyType);
          Parser.expect(Token.Equal, p);
          let exp = parseExpr(p);
          let exp = overParseConstrainedOrCoercedOrArrowExpression(p, exp);
          (pat, exp);
        };
      | _ =>
        Parser.expect(Token.Equal, p);
        let exp =
          overParseConstrainedOrCoercedOrArrowExpression(p, parseExpr(p));
        (pat, exp);
      };
    };

    let loc = mkLoc(startPos, p.prevEndPos);
    let vb = Ast_helper.Vb.mk(~loc, ~attrs, pat, exp);
    Parser.eatBreadcrumb(p);
    Parser.endRegion(p);
    vb;
  }

  /* TODO: find a better way? Is it possible?
   * let a = 1
   * @attr
   * and b = 2
   *
   * The problem is that without semi we need a lookahead to determine
   * if the attr is on the letbinding or the start of a new thing
   *
   * let a = 1
   * @attr
   * let b = 1
   *
   * Here @attr should attach to something "new": `let b = 1`
   * The parser state is forked, which is quite expensive…
   */
  and parseAttributesAndBinding = (p: Parser.t) => {
    let err = p.scanner.err;
    let ch = p.scanner.ch;
    let offset = p.scanner.offset;
    let rdOffset = p.scanner.rdOffset;
    let lineOffset = p.scanner.lineOffset;
    let lnum = p.scanner.lnum;
    let mode = p.scanner.mode;
    let token = p.token;
    let startPos = p.startPos;
    let endPos = p.endPos;
    let prevEndPos = p.prevEndPos;
    let breadcrumbs = p.breadcrumbs;
    let errors = p.errors;
    let diagnostics = p.diagnostics;
    let comments = p.comments;

    switch (p.Parser.token) {
    | At =>
      let attrs = parseAttributes(p);
      switch (p.Parser.token) {
      | And => attrs
      | _ =>
        p.scanner.err = err;
        p.scanner.ch = ch;
        p.scanner.offset = offset;
        p.scanner.rdOffset = rdOffset;
        p.scanner.lineOffset = lineOffset;
        p.scanner.lnum = lnum;
        p.scanner.mode = mode;
        p.token = token;
        p.startPos = startPos;
        p.endPos = endPos;
        p.prevEndPos = prevEndPos;
        p.breadcrumbs = breadcrumbs;
        p.errors = errors;
        p.diagnostics = diagnostics;
        p.comments = comments;
        [];
      };
    | _ => []
    };
  }

  /* definition	::=	let [rec] let-binding  { and let-binding }   */
  and parseLetBindings = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.optional(p, Let) |> ignore;
    let recFlag =
      if (Parser.optional(p, Token.Rec)) {
        Asttypes.Recursive;
      } else {
        Asttypes.Nonrecursive;
      };

    let first = parseLetBindingBody(~startPos, ~attrs, p);

    let rec loop = (p, bindings) => {
      let startPos = p.Parser.startPos;
      let attrs = parseAttributesAndBinding(p);
      switch (p.Parser.token) {
      | And =>
        Parser.next(p);
        let attrs =
          switch (p.token) {
          | Export =>
            let exportLoc = mkLoc(p.startPos, p.endPos);
            Parser.next(p);
            let genTypeAttr = (
              Location.mkloc("genType", exportLoc),
              Parsetree.PStr([]),
            );
            [genTypeAttr, ...attrs];
          | _ => attrs
          };

        ignore(Parser.optional(p, Let)); /* overparse for fault tolerance */
        let letBinding = parseLetBindingBody(~startPos, ~attrs, p);
        loop(p, [letBinding, ...bindings]);
      | _ => List.rev(bindings)
      };
    };

    (recFlag, loop(p, [first]));
  }

  /*
   * div -> div
   * Foo -> Foo.createElement
   * Foo.Bar -> Foo.Bar.createElement
   */
  and parseJsxName = p => {
    let longident =
      switch (p.Parser.token) {
      | Lident(ident) =>
        let identStart = p.startPos;
        let identEnd = p.endPos;
        Parser.next(p);
        let loc = mkLoc(identStart, identEnd);
        Location.mkloc(Longident.Lident(ident), loc);
      | Uident(_) =>
        let longident = parseModuleLongIdent(~lowercase=false, p);
        Location.mkloc(
          [@implicit_arity] Longident.Ldot(longident.txt, "createElement"),
          longident.loc,
        );
      | _ =>
        let msg = "A jsx name should start with a lowercase or uppercase identifier, like: div in <div /> or Navbar in <Navbar />";

        Parser.err(p, Diagnostics.message(msg));
        Location.mknoloc(Longident.Lident("_"));
      };

    Ast_helper.Exp.ident(~loc=longident.loc, longident);
  }

  and parseJsxOpeningOrSelfClosingElement = (~startPos, p) => {
    let jsxStartPos = p.Parser.startPos;
    let name = parseJsxName(p);
    let jsxProps = parseJsxProps(p);
    let children =
      switch (p.Parser.token) {
      | Forwardslash =>
        /* <foo a=b /> */
        let childrenStartPos = p.Parser.startPos;
        Parser.next(p);
        let childrenEndPos = p.Parser.startPos;
        Parser.expect(GreaterThan, p);
        let loc = mkLoc(childrenStartPos, childrenEndPos);
        makeListExpression(loc, [], None); /* no children */
      | GreaterThan =>
        /* <foo a=b> bar </foo> */
        let childrenStartPos = p.Parser.startPos;
        Scanner.setJsxMode(p.scanner);
        Parser.next(p);
        let (spread, children) = parseJsxChildren(p);
        let childrenEndPos = p.Parser.startPos;
        let () =
          switch (p.token) {
          | LessThanSlash => Parser.next(p)
          | LessThan =>
            Parser.next(p);
            Parser.expect(Forwardslash, p);
          | token when Grammar.isStructureItemStart(token) => ()
          | _ => Parser.expect(LessThanSlash, p)
          };

        switch (p.Parser.token) {
        | Lident(_)
        | Uident(_) when verifyJsxOpeningClosingName(p, name) =>
          Parser.expect(GreaterThan, p);
          let loc = mkLoc(childrenStartPos, childrenEndPos);
          switch (spread, children) {
          | (true, [child, ..._]) => child
          | _ => makeListExpression(loc, children, None)
          };
        | token =>
          let () =
            if (Grammar.isStructureItemStart(token)) {
              let closing = "</" ++ string_of_pexp_ident(name) ++ ">";
              let msg = Diagnostics.message("Missing " ++ closing);
              Parser.err(~startPos, ~endPos=p.prevEndPos, p, msg);
            } else {
              let opening = "</" ++ string_of_pexp_ident(name) ++ ">";
              let msg =
                "Closing jsx name should be the same as the opening name. Did you mean "
                ++ opening
                ++ " ?";
              Parser.err(
                ~startPos,
                ~endPos=p.prevEndPos,
                p,
                Diagnostics.message(msg),
              );
              Parser.expect(GreaterThan, p);
            };

          let loc = mkLoc(childrenStartPos, childrenEndPos);
          switch (spread, children) {
          | (true, [child, ..._]) => child
          | _ => makeListExpression(loc, children, None)
          };
        };
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        makeListExpression(Location.none, [], None);
      };

    let jsxEndPos = p.prevEndPos;
    let loc = mkLoc(jsxStartPos, jsxEndPos);
    Ast_helper.Exp.apply(
      ~loc,
      name,
      List.concat([
        jsxProps,
        [
          (Asttypes.Labelled("children"), children),
          (
            Asttypes.Nolabel,
            Ast_helper.Exp.construct(
              Location.mknoloc(Longident.Lident("()")),
              None,
            ),
          ),
        ],
      ]),
    );
  }

  /*
   *  jsx ::=
   *    | <> jsx-children </>
   *    | <element-name {jsx-prop} />
   *    | <element-name {jsx-prop}> jsx-children </element-name>
   *
   *  jsx-children ::= primary-expr*          * => 0 or more
   */
  and parseJsx = p => {
    Parser.leaveBreadcrumb(p, Grammar.Jsx);
    let startPos = p.Parser.startPos;
    Parser.expect(LessThan, p);
    let jsxExpr =
      switch (p.Parser.token) {
      | Lident(_)
      | Uident(_) => parseJsxOpeningOrSelfClosingElement(~startPos, p)
      | GreaterThan =>
        /* fragment: <> foo </> */
        parseJsxFragment(p)
      | _ => parseJsxName(p)
      };

    {...jsxExpr, pexp_attributes: [jsxAttr]};
  }

  /*
   * jsx-fragment ::=
   *  | <> </>
   *  | <> jsx-children </>
   */
  and parseJsxFragment = p => {
    let childrenStartPos = p.Parser.startPos;
    Scanner.setJsxMode(p.scanner);
    Parser.expect(GreaterThan, p);
    let (_spread, children) = parseJsxChildren(p);
    let childrenEndPos = p.Parser.startPos;
    Parser.expect(LessThanSlash, p);
    Parser.expect(GreaterThan, p);
    let loc = mkLoc(childrenStartPos, childrenEndPos);
    makeListExpression(loc, children, None);
  }

  /*
   * jsx-prop ::=
   *   |  lident
   *   | ?lident
   *   |  lident =  jsx_expr
   *   |  lident = ?jsx_expr
   */
  and parseJsxProp = p => {
    Parser.leaveBreadcrumb(p, Grammar.JsxAttribute);
    switch (p.Parser.token) {
    | Question
    | Lident(_) =>
      let optional = Parser.optional(p, Question);
      let (name, loc) = parseLident(p);
      let propLocAttr = (
        Location.mkloc("ns.namedArgLoc", loc),
        Parsetree.PStr([]),
      );
      /* optional punning: <foo ?a /> */
      if (optional) {
        Some((
          Asttypes.Optional(name),
          Ast_helper.Exp.ident(
            ~attrs=[propLocAttr],
            ~loc,
            Location.mkloc(Longident.Lident(name), loc),
          ),
        ));
      } else {
        switch (p.Parser.token) {
        | Equal =>
          Parser.next(p);
          /* no punning */
          let optional = Parser.optional(p, Question);
          let attrExpr = {
            let e = parsePrimaryExpr(~operand=parseAtomicExpr(p), p);
            {...e, pexp_attributes: [propLocAttr, ...e.pexp_attributes]};
          };

          let label =
            if (optional) {Asttypes.Optional(name)} else {
              Asttypes.Labelled(name)
            };

          Some((label, attrExpr));
        | _ =>
          let attrExpr =
            Ast_helper.Exp.ident(
              ~loc,
              ~attrs=[propLocAttr],
              Location.mknoloc(Longident.Lident(name)),
            );
          let label =
            if (optional) {Asttypes.Optional(name)} else {
              Asttypes.Labelled(name)
            };

          Some((label, attrExpr));
        };
      };
    | _ => None
    };
  }

  and parseJsxProps = p =>
    parseRegion(~grammar=Grammar.JsxAttribute, ~f=parseJsxProp, p)

  and parseJsxChildren = p => {
    let rec loop = (p, children) =>
      switch (p.Parser.token) {
      | Token.Eof
      | LessThanSlash =>
        Scanner.popMode(p.scanner, Jsx);
        List.rev(children);
      | LessThan =>
        /* Imagine: <div> <Navbar /> <
         * is `<` the start of a jsx-child? <div …
         * or is it the start of a closing tag?  </div>
         * reconsiderLessThan peeks at the next token and
         * determines the correct token to disambiguate */
        let token = Scanner.reconsiderLessThan(p.scanner);
        if (token == LessThan) {
          let child =
            parsePrimaryExpr(~operand=parseAtomicExpr(p), ~noCall=true, p);
          loop(p, [child, ...children]);
        } else {
          /* LessThanSlash */
          let () = p.token = token;
          let () = Scanner.popMode(p.scanner, Jsx);
          List.rev(children);
        };
      | token when Grammar.isJsxChildStart(token) =>
        let () = Scanner.popMode(p.scanner, Jsx);
        let child =
          parsePrimaryExpr(~operand=parseAtomicExpr(p), ~noCall=true, p);
        loop(p, [child, ...children]);
      | _ =>
        Scanner.popMode(p.scanner, Jsx);
        List.rev(children);
      };

    switch (p.Parser.token) {
    | DotDotDot =>
      Parser.next(p);
      (
        true,
        [parsePrimaryExpr(~operand=parseAtomicExpr(p), ~noCall=true, p)],
      );
    | _ => (false, loop(p, []))
    };
  }

  and parseBracedOrRecordExpr = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(Lbrace, p);
    switch (p.Parser.token) {
    | Rbrace =>
      Parser.err(p, Diagnostics.unexpected(Rbrace, p.breadcrumbs));
      Parser.next(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      let braces = makeBracesAttr(loc);
      Ast_helper.Exp.construct(
        ~attrs=[braces],
        ~loc,
        Location.mkloc(Longident.Lident("()"), loc),
        None,
      );
    | DotDotDot =>
      /* beginning of record spread, parse record */
      Parser.next(p);
      let spreadExpr = parseConstrainedOrCoercedExpr(p);
      Parser.expect(Comma, p);
      let expr = parseRecordExpr(~startPos, ~spread=Some(spreadExpr), [], p);
      Parser.expect(Rbrace, p);
      expr;
    | String(s) =>
      let field = {
        let loc = mkLoc(p.startPos, p.endPos);
        Parser.next(p);
        Location.mkloc(Longident.Lident(s), loc);
      };

      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        let fieldExpr = parseExpr(p);
        Parser.optional(p, Comma) |> ignore;
        let expr =
          parseRecordExprWithStringKeys(~startPos, (field, fieldExpr), p);
        Parser.expect(Rbrace, p);
        expr;
      | _ =>
        let constant =
          Ast_helper.Exp.constant(
            ~loc=field.loc,
            [@implicit_arity] Parsetree.Pconst_string(s, None),
          );
        let a = parsePrimaryExpr(~operand=constant, p);
        let e = parseBinaryExpr(~a, p, 1);
        let e = parseTernaryExpr(e, p);
        switch (p.Parser.token) {
        | Semicolon =>
          Parser.next(p);
          let expr = parseExprBlock(~first=e, p);
          Parser.expect(Rbrace, p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let braces = makeBracesAttr(loc);
          {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
        | Rbrace =>
          Parser.next(p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let braces = makeBracesAttr(loc);
          {...e, pexp_attributes: [braces, ...e.pexp_attributes]};
        | _ =>
          let expr = parseExprBlock(~first=e, p);
          Parser.expect(Rbrace, p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let braces = makeBracesAttr(loc);
          {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
        };
      };
    | Uident(_)
    | Lident(_) =>
      let valueOrConstructor = parseValueOrConstructor(p);
      switch (valueOrConstructor.pexp_desc) {
      | Pexp_ident(pathIdent) =>
        let identEndPos = p.prevEndPos;
        switch (p.Parser.token) {
        | Comma =>
          Parser.next(p);
          let expr =
            parseRecordExpr(
              ~startPos,
              [(pathIdent, valueOrConstructor)],
              p,
            );
          Parser.expect(Rbrace, p);
          expr;
        | Colon =>
          Parser.next(p);
          let fieldExpr = parseExpr(p);
          switch (p.token) {
          | Rbrace =>
            Parser.next(p);
            let loc = mkLoc(startPos, p.prevEndPos);
            Ast_helper.Exp.record(~loc, [(pathIdent, fieldExpr)], None);
          | _ =>
            Parser.expect(Comma, p);
            let expr =
              parseRecordExpr(~startPos, [(pathIdent, fieldExpr)], p);
            Parser.expect(Rbrace, p);
            expr;
          };
        /* error case */
        | Lident(_) =>
          if (p.prevEndPos.pos_lnum < p.startPos.pos_lnum) {
            Parser.expect(Comma, p);
            let expr =
              parseRecordExpr(
                ~startPos,
                [(pathIdent, valueOrConstructor)],
                p,
              );
            Parser.expect(Rbrace, p);
            expr;
          } else {
            Parser.expect(Colon, p);
            let expr =
              parseRecordExpr(
                ~startPos,
                [(pathIdent, valueOrConstructor)],
                p,
              );
            Parser.expect(Rbrace, p);
            expr;
          }
        | Semicolon =>
          Parser.next(p);
          let expr =
            parseExprBlock(~first=Ast_helper.Exp.ident(pathIdent), p);
          Parser.expect(Rbrace, p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let braces = makeBracesAttr(loc);
          {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
        | Rbrace =>
          Parser.next(p);
          let expr = Ast_helper.Exp.ident(~loc=pathIdent.loc, pathIdent);
          let loc = mkLoc(startPos, p.prevEndPos);
          let braces = makeBracesAttr(loc);
          {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
        | EqualGreater =>
          let loc = mkLoc(startPos, identEndPos);
          let ident = Location.mkloc(Longident.last(pathIdent.txt), loc);
          let a =
            parseEs6ArrowExpression(
              ~parameters=[
                TermParameter({
                  uncurried: false,
                  attrs: [],
                  label: Asttypes.Nolabel,
                  expr: None,
                  pat: Ast_helper.Pat.var(ident),
                  pos: startPos,
                }),
              ],
              p,
            );

          let e = parseBinaryExpr(~a, p, 1);
          let e = parseTernaryExpr(e, p);
          switch (p.Parser.token) {
          | Semicolon =>
            Parser.next(p);
            let expr = parseExprBlock(~first=e, p);
            Parser.expect(Rbrace, p);
            let loc = mkLoc(startPos, p.prevEndPos);
            let braces = makeBracesAttr(loc);
            {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
          | Rbrace =>
            Parser.next(p);
            let loc = mkLoc(startPos, p.prevEndPos);
            let braces = makeBracesAttr(loc);
            {...e, pexp_attributes: [braces, ...e.pexp_attributes]};
          | _ =>
            let expr = parseExprBlock(~first=e, p);
            Parser.expect(Rbrace, p);
            let loc = mkLoc(startPos, p.prevEndPos);
            let braces = makeBracesAttr(loc);
            {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
          };
        | _ =>
          Parser.leaveBreadcrumb(p, Grammar.ExprBlock);
          let a =
            parsePrimaryExpr(
              ~operand=Ast_helper.Exp.ident(~loc=pathIdent.loc, pathIdent),
              p,
            );
          let e = parseBinaryExpr(~a, p, 1);
          let e = parseTernaryExpr(e, p);
          Parser.eatBreadcrumb(p);
          switch (p.Parser.token) {
          | Semicolon =>
            Parser.next(p);
            let expr = parseExprBlock(~first=e, p);
            Parser.expect(Rbrace, p);
            let loc = mkLoc(startPos, p.prevEndPos);
            let braces = makeBracesAttr(loc);
            {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
          | Rbrace =>
            Parser.next(p);
            let loc = mkLoc(startPos, p.prevEndPos);
            let braces = makeBracesAttr(loc);
            {...e, pexp_attributes: [braces, ...e.pexp_attributes]};
          | _ =>
            let expr = parseExprBlock(~first=e, p);
            Parser.expect(Rbrace, p);
            let loc = mkLoc(startPos, p.prevEndPos);
            let braces = makeBracesAttr(loc);
            {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
          };
        };
      | _ =>
        Parser.leaveBreadcrumb(p, Grammar.ExprBlock);
        let a = parsePrimaryExpr(~operand=valueOrConstructor, p);
        let e = parseBinaryExpr(~a, p, 1);
        let e = parseTernaryExpr(e, p);
        Parser.eatBreadcrumb(p);
        switch (p.Parser.token) {
        | Semicolon =>
          Parser.next(p);
          let expr = parseExprBlock(~first=e, p);
          Parser.expect(Rbrace, p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let braces = makeBracesAttr(loc);
          {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
        | Rbrace =>
          Parser.next(p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let braces = makeBracesAttr(loc);
          {...e, pexp_attributes: [braces, ...e.pexp_attributes]};
        | _ =>
          let expr = parseExprBlock(~first=e, p);
          Parser.expect(Rbrace, p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let braces = makeBracesAttr(loc);
          {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
        };
      };
    | _ =>
      let expr = parseExprBlock(p);
      Parser.expect(Rbrace, p);
      let loc = mkLoc(startPos, p.prevEndPos);
      let braces = makeBracesAttr(loc);
      {...expr, pexp_attributes: [braces, ...expr.pexp_attributes]};
    };
  }

  and parseRecordRowWithStringKey = p =>
    switch (p.Parser.token) {
    | String(s) =>
      let loc = mkLoc(p.startPos, p.endPos);
      Parser.next(p);
      let field = Location.mkloc(Longident.Lident(s), loc);
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        let fieldExpr = parseExpr(p);
        Some((field, fieldExpr));
      | _ => Some((field, Ast_helper.Exp.ident(~loc=field.loc, field)))
      };
    | _ => None
    }

  and parseRecordRow = p => {
    let () =
      switch (p.Parser.token) {
      | Token.DotDotDot =>
        Parser.err(p, Diagnostics.message(ErrorMessages.recordExprSpread));
        Parser.next(p);
      | _ => ()
      };

    switch (p.Parser.token) {
    | Lident(_)
    | Uident(_)
    | List =>
      let field = parseValuePath(p);
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        let fieldExpr = parseExpr(p);
        Some((field, fieldExpr));
      | _ => Some((field, Ast_helper.Exp.ident(~loc=field.loc, field)))
      };
    | _ => None
    };
  }

  and parseRecordExprWithStringKeys = (~startPos, firstRow, p) => {
    let rows = [
      firstRow,
      ...parseCommaDelimitedRegion(
           ~grammar=Grammar.RecordRowsStringKey,
           ~closing=Rbrace,
           ~f=parseRecordRowWithStringKey,
           p,
         ),
    ];
    let loc = mkLoc(startPos, p.endPos);
    let recordStrExpr =
      Ast_helper.Str.eval(~loc, Ast_helper.Exp.record(~loc, rows, None));
    Ast_helper.Exp.extension(
      ~loc,
      (Location.mkloc("bs.obj", loc), Parsetree.PStr([recordStrExpr])),
    );
  }

  and parseRecordExpr = (~startPos, ~spread=None, rows, p) => {
    let exprs =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.RecordRows,
        ~closing=Rbrace,
        ~f=parseRecordRow,
        p,
      );

    let rows = List.concat([rows, exprs]);
    let () =
      switch (rows) {
      | [] =>
        let msg = "Record spread needs at least one field that's updated";
        Parser.err(p, Diagnostics.message(msg));
      | _rows => ()
      };

    let loc = mkLoc(startPos, p.endPos);
    Ast_helper.Exp.record(~loc, rows, spread);
  }

  and parseExprBlockItem = p => {
    let startPos = p.Parser.startPos;
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | Module =>
      Parser.next(p);
      switch (p.token) {
      | Lparen => parseFirstClassModuleExpr(~startPos, p)
      | _ =>
        let name =
          switch (p.Parser.token) {
          | Uident(ident) =>
            let loc = mkLoc(p.startPos, p.endPos);
            Parser.next(p);
            Location.mkloc(ident, loc);
          | t =>
            Parser.err(p, Diagnostics.uident(t));
            Location.mknoloc("_");
          };

        let body = parseModuleBindingBody(p);
        Parser.optional(p, Semicolon) |> ignore;
        let expr = parseExprBlock(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Exp.letmodule(~loc, name, body, expr);
      };
    | Exception =>
      let extensionConstructor = parseExceptionDef(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let blockExpr = parseExprBlock(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Exp.letexception(~loc, extensionConstructor, blockExpr);
    | Open =>
      let od = parseOpenDescription(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let blockExpr = parseExprBlock(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Exp.open_(~loc, od.popen_override, od.popen_lid, blockExpr);
    | Let =>
      let (recFlag, letBindings) = parseLetBindings(~attrs, p);
      let next =
        switch (p.Parser.token) {
        | Semicolon =>
          Parser.next(p);
          if (Grammar.isBlockExprStart(p.Parser.token)) {
            parseExprBlock(p);
          } else {
            let loc = mkLoc(p.startPos, p.endPos);
            Ast_helper.Exp.construct(
              ~loc,
              Location.mkloc(Longident.Lident("()"), loc),
              None,
            );
          };
        | token when Grammar.isBlockExprStart(token) => parseExprBlock(p)
        | _ =>
          let loc = mkLoc(p.startPos, p.endPos);
          Ast_helper.Exp.construct(
            ~loc,
            Location.mkloc(Longident.Lident("()"), loc),
            None,
          );
        };

      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Exp.let_(~loc, recFlag, letBindings, next);
    | _ =>
      let e1 = {
        let expr = parseExpr(p);
        {
          ...expr,
          pexp_attributes: List.concat([attrs, expr.pexp_attributes]),
        };
      };

      ignore(Parser.optional(p, Semicolon));
      if (Grammar.isBlockExprStart(p.Parser.token)) {
        let e2 = parseExprBlock(p);
        let loc = {...e1.pexp_loc, loc_end: e2.pexp_loc.loc_end};
        Ast_helper.Exp.sequence(~loc, e1, e2);
      } else {
        e1;
      };
    };
  }

  /* blockExpr ::= expr
   *            |  expr          ;
   *            |  expr          ; blockExpr
   *            |  module    ... ; blockExpr
   *            |  open      ... ; blockExpr
   *            |  exception ... ; blockExpr
   *            |  let       ...
   *            |  let       ... ;
   *            |  let       ... ; blockExpr
   *
   *  note: semi should be made optional
   *  a block of expression is always
   */
  and parseExprBlock = (~first=?, p) => {
    Parser.leaveBreadcrumb(p, Grammar.ExprBlock);
    let item =
      switch (first) {
      | Some(e) => e
      | None => parseExprBlockItem(p)
      };

    let blockExpr =
      switch (p.Parser.token) {
      | Semicolon =>
        Parser.next(p);
        if (Grammar.isBlockExprStart(p.Parser.token)) {
          let next = parseExprBlockItem(p);
          ignore(Parser.optional(p, Semicolon));
          let loc = {...item.pexp_loc, loc_end: next.pexp_loc.loc_end};
          Ast_helper.Exp.sequence(~loc, item, next);
        } else {
          item;
        };
      | token when Grammar.isBlockExprStart(token) =>
        let next = parseExprBlockItem(p);
        ignore(Parser.optional(p, Semicolon));
        let loc = {...item.pexp_loc, loc_end: next.pexp_loc.loc_end};
        Ast_helper.Exp.sequence(~loc, item, next);
      | _ => item
      };

    Parser.eatBreadcrumb(p);
    overParseConstrainedOrCoercedOrArrowExpression(p, blockExpr);
  }

  and parseTryExpression = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(Try, p);
    let expr = parseExpr(~context=WhenExpr, p);
    Parser.expect(Catch, p);
    Parser.expect(Lbrace, p);
    let cases = parsePatternMatching(p);
    Parser.expect(Rbrace, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Exp.try_(~loc, expr, cases);
  }

  and parseIfExpression = p => {
    Parser.beginRegion(p);
    Parser.leaveBreadcrumb(p, Grammar.ExprIf);
    let startPos = p.Parser.startPos;
    Parser.expect(If, p);
    Parser.leaveBreadcrumb(p, Grammar.IfCondition);
    /* doesn't make sense to try es6 arrow here? */
    let conditionExpr = parseExpr(~context=WhenExpr, p);
    Parser.eatBreadcrumb(p);
    Parser.leaveBreadcrumb(p, IfBranch);
    Parser.expect(Lbrace, p);
    let thenExpr = parseExprBlock(p);
    Parser.expect(Rbrace, p);
    Parser.eatBreadcrumb(p);
    let elseExpr =
      switch (p.Parser.token) {
      | Else =>
        Parser.endRegion(p);
        Parser.leaveBreadcrumb(p, Grammar.ElseBranch);
        Parser.next(p);
        Parser.beginRegion(p);
        let elseExpr =
          switch (p.token) {
          | If => parseIfExpression(p)
          | _ =>
            Parser.expect(Lbrace, p);
            let blockExpr = parseExprBlock(p);
            Parser.expect(Rbrace, p);
            blockExpr;
          };

        Parser.eatBreadcrumb(p);
        Parser.endRegion(p);
        Some(elseExpr);
      | _ =>
        Parser.endRegion(p);
        None;
      };

    let loc = mkLoc(startPos, p.prevEndPos);
    Parser.eatBreadcrumb(p);
    Ast_helper.Exp.ifthenelse(~loc, conditionExpr, thenExpr, elseExpr);
  }

  and parseForRest = (hasOpeningParen, pattern, startPos, p) => {
    Parser.expect(In, p);
    let e1 = parseExpr(p);
    let direction =
      switch (p.Parser.token) {
      | To => Asttypes.Upto
      | Downto => Asttypes.Downto
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        Asttypes.Upto;
      };

    Parser.next(p);
    let e2 = parseExpr(~context=WhenExpr, p);
    if (hasOpeningParen) {
      Parser.expect(Rparen, p);
    };
    Parser.expect(Lbrace, p);
    let bodyExpr = parseExprBlock(p);
    Parser.expect(Rbrace, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Exp.for_(~loc, pattern, e1, e2, direction, bodyExpr);
  }

  and parseForExpression = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(For, p);
    switch (p.token) {
    | Lparen =>
      let lparen = p.startPos;
      Parser.next(p);
      switch (p.token) {
      | Rparen =>
        Parser.next(p);
        let unitPattern = {
          let loc = mkLoc(lparen, p.prevEndPos);
          let lid = Location.mkloc(Longident.Lident("()"), loc);
          Ast_helper.Pat.construct(lid, None);
        };

        parseForRest(
          false,
          parseAliasPattern(~attrs=[], unitPattern, p),
          startPos,
          p,
        );
      | _ =>
        let pat = parsePattern(p);
        switch (p.token) {
        | Comma =>
          Parser.next(p);
          let tuplePattern =
            parseTuplePattern(~attrs=[], ~startPos=lparen, ~first=pat, p);

          let pattern = parseAliasPattern(~attrs=[], tuplePattern, p);
          parseForRest(false, pattern, startPos, p);
        | _ => parseForRest(true, pat, startPos, p)
        };
      };
    | _ => parseForRest(false, parsePattern(p), startPos, p)
    };
  }

  and parseWhileExpression = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(While, p);
    let expr1 = parseExpr(~context=WhenExpr, p);
    Parser.expect(Lbrace, p);
    let expr2 = parseExprBlock(p);
    Parser.expect(Rbrace, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Exp.while_(~loc, expr1, expr2);
  }

  and parsePatternMatchCase = p => {
    Parser.beginRegion(p);
    Parser.leaveBreadcrumb(p, Grammar.PatternMatchCase);
    switch (p.Parser.token) {
    | Token.Bar =>
      Parser.next(p);
      let lhs = parsePattern(p);
      let guard =
        switch (p.Parser.token) {
        | When =>
          Parser.next(p);
          Some(parseExpr(~context=WhenExpr, p));
        | _ => None
        };

      let () =
        switch (p.token) {
        | EqualGreater => Parser.next(p)
        | _ => Recover.recoverEqualGreater(p)
        };

      let rhs = parseExprBlock(p);
      Parser.endRegion(p);
      Parser.eatBreadcrumb(p);
      Some(Ast_helper.Exp.case(lhs, ~guard?, rhs));
    | _ =>
      Parser.endRegion(p);
      None;
    };
  }

  and parsePatternMatching = p => {
    Parser.leaveBreadcrumb(p, Grammar.PatternMatching);
    let cases =
      parseDelimitedRegion(
        ~grammar=Grammar.PatternMatching,
        ~closing=Rbrace,
        ~f=parsePatternMatchCase,
        p,
      );

    let () =
      switch (cases) {
      | [] =>
        Parser.err(
          ~startPos=p.prevEndPos,
          p,
          Diagnostics.message("Pattern matching needs at least one case"),
        )
      | _ => ()
      };

    cases;
  }

  and parseSwitchExpression = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(Switch, p);
    let switchExpr = parseExpr(~context=WhenExpr, p);
    Parser.expect(Lbrace, p);
    let cases = parsePatternMatching(p);
    Parser.expect(Rbrace, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Exp.match(~loc, switchExpr, cases);
  }

  /*
   * 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
   *
   *  uncurried_argument ::=
   *   | . argument
   */
  and parseArgument = p =>
    if (p.Parser.token == Token.Tilde
        || p.token == Dot
        || p.token == Underscore
        || Grammar.isExprStart(p.token)) {
      switch (p.Parser.token) {
      | Dot =>
        let uncurried = true;
        let startPos = p.Parser.startPos;
        Parser.next(p);
        switch (p.token) {
        /* apply(.) */
        | Rparen =>
          let loc = mkLoc(startPos, p.prevEndPos);
          let unitExpr =
            Ast_helper.Exp.construct(
              ~loc,
              Location.mkloc(Longident.Lident("()"), loc),
              None,
            );

          Some((uncurried, Asttypes.Nolabel, unitExpr));
        | _ => parseArgument2(p, ~uncurried)
        };
      | _ => parseArgument2(p, ~uncurried=false)
      };
    } else {
      None;
    }

  and parseArgument2 = (p, ~uncurried) =>
    switch (p.Parser.token) {
    /* foo(_), do not confuse with foo(_ => x), TODO: performance */
    | Underscore when !isEs6ArrowExpression(~inTernary=false, p) =>
      let loc = mkLoc(p.startPos, p.endPos);
      Parser.next(p);
      let exp =
        Ast_helper.Exp.ident(
          ~loc,
          Location.mkloc(Longident.Lident("_"), loc),
        );
      Some((uncurried, Asttypes.Nolabel, exp));
    | Tilde =>
      Parser.next(p);
      /* TODO: nesting of pattern matches not intuitive for error recovery */
      switch (p.Parser.token) {
      | Lident(ident) =>
        let startPos = p.startPos;
        Parser.next(p);
        let endPos = p.prevEndPos;
        let loc = mkLoc(startPos, endPos);
        let propLocAttr = (
          Location.mkloc("ns.namedArgLoc", loc),
          Parsetree.PStr([]),
        );
        let identExpr =
          Ast_helper.Exp.ident(
            ~attrs=[propLocAttr],
            ~loc,
            Location.mkloc(Longident.Lident(ident), loc),
          );
        switch (p.Parser.token) {
        | Question =>
          Parser.next(p);
          Some((uncurried, Asttypes.Optional(ident), identExpr));
        | Equal =>
          Parser.next(p);
          let label =
            switch (p.Parser.token) {
            | Question =>
              Parser.next(p);
              Asttypes.Optional(ident);
            | _ => Labelled(ident)
            };

          let expr =
            switch (p.Parser.token) {
            | Underscore when !isEs6ArrowExpression(~inTernary=false, p) =>
              let loc = mkLoc(p.startPos, p.endPos);
              Parser.next(p);
              Ast_helper.Exp.ident(
                ~loc,
                Location.mkloc(Longident.Lident("_"), loc),
              );
            | _ =>
              let expr = parseConstrainedOrCoercedExpr(p);
              {
                ...expr,
                pexp_attributes: [propLocAttr, ...expr.pexp_attributes],
              };
            };

          Some((uncurried, label, expr));
        | Colon =>
          Parser.next(p);
          let typ = parseTypExpr(p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let expr =
            Ast_helper.Exp.constraint_(
              ~attrs=[propLocAttr],
              ~loc,
              identExpr,
              typ,
            );
          Some((uncurried, Labelled(ident), expr));
        | _ => Some((uncurried, Labelled(ident), identExpr))
        };
      | t =>
        Parser.err(p, Diagnostics.lident(t));
        Some((uncurried, Nolabel, Recover.defaultExpr()));
      };
    | _ => Some((uncurried, Nolabel, parseConstrainedOrCoercedExpr(p)))
    }

  and parseCallExpr = (p, funExpr) => {
    Parser.expect(Lparen, p);
    let startPos = p.Parser.startPos;
    Parser.leaveBreadcrumb(p, Grammar.ExprCall);
    let args =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.ArgumentList,
        ~closing=Rparen,
        ~f=parseArgument,
        p,
      );

    Parser.expect(Rparen, p);
    let args =
      switch (args) {
      | [] =>
        let loc = mkLoc(startPos, p.prevEndPos);
        /* No args -> unit sugar: `foo()` */
        [
          (
            false,
            Asttypes.Nolabel,
            Ast_helper.Exp.construct(
              ~loc,
              Location.mkloc(Longident.Lident("()"), loc),
              None,
            ),
          ),
        ];
      | args => args
      };

    let loc = {...funExpr.pexp_loc, loc_end: p.prevEndPos};
    let args =
      switch (args) {
      | [(u, lbl, expr), ...args] =>
        let group = ((grp, acc), (uncurried, lbl, expr)) => {
          let (_u, grp) = grp;
          if (uncurried === true) {
            ((true, [(lbl, expr)]), [(_u, List.rev(grp)), ...acc]);
          } else {
            ((_u, [(lbl, expr), ...grp]), acc);
          };
        };

        let ((_u, grp), acc) =
          List.fold_left(group, ((u, [(lbl, expr)]), []), args);
        List.rev([(_u, List.rev(grp)), ...acc]);
      | [] => []
      };

    let apply =
      List.fold_left(
        (callBody, group) => {
          let (uncurried, args) = group;
          let (args, wrap) = processUnderscoreApplication(args);
          let exp =
            if (uncurried) {
              let attrs = [uncurryAttr];
              Ast_helper.Exp.apply(~loc, ~attrs, callBody, args);
            } else {
              Ast_helper.Exp.apply(~loc, callBody, args);
            };

          wrap(exp);
        },
        funExpr,
        args,
      );

    Parser.eatBreadcrumb(p);
    apply;
  }

  and parseValueOrConstructor = p => {
    let startPos = p.Parser.startPos;
    let rec aux = (p, acc) =>
      switch (p.Parser.token) {
      | Uident(ident) =>
        let endPosLident = p.endPos;
        Parser.next(p);
        switch (p.Parser.token) {
        | Dot =>
          Parser.next(p);
          aux(p, [ident, ...acc]);
        | Lparen when p.prevEndPos.pos_lnum === p.startPos.pos_lnum =>
          let lparen = p.startPos;
          let args = parseConstructorArgs(p);
          let rparen = p.prevEndPos;
          let lident = buildLongident([ident, ...acc]);
          let tail =
            switch (args) {
            | [] => None
            | [{Parsetree.pexp_desc: Pexp_tuple(_)} as arg] as args =>
              let loc = mkLoc(lparen, rparen);
              if (p.mode == ParseForTypeChecker) {
                /* Some(1, 2) for type-checker */
                Some(arg);
              } else {
                /* Some((1, 2)) for printer */
                Some(Ast_helper.Exp.tuple(~loc, args));
              };
            | [arg] => Some(arg)
            | args =>
              let loc = mkLoc(lparen, rparen);
              Some(Ast_helper.Exp.tuple(~loc, args));
            };

          let loc = mkLoc(startPos, p.prevEndPos);
          let identLoc = mkLoc(startPos, endPosLident);
          Ast_helper.Exp.construct(
            ~loc,
            Location.mkloc(lident, identLoc),
            tail,
          );
        | _ =>
          let loc = mkLoc(startPos, p.prevEndPos);
          let lident = buildLongident([ident, ...acc]);
          Ast_helper.Exp.construct(~loc, Location.mkloc(lident, loc), None);
        };
      | Lident(ident) =>
        Parser.next(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        let lident = buildLongident([ident, ...acc]);
        Ast_helper.Exp.ident(~loc, Location.mkloc(lident, loc));
      | List =>
        Parser.next(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        let lident = buildLongident(["list", ...acc]);
        Ast_helper.Exp.ident(~loc, Location.mkloc(lident, loc));
      | token =>
        Parser.next(p);
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        Recover.defaultExpr();
      };

    aux(p, []);
  }

  and parsePolyVariantExpr = p => {
    let startPos = p.startPos;
    let (ident, _loc) = parseHashIdent(~startPos, p);
    switch (p.Parser.token) {
    | Lparen when p.prevEndPos.pos_lnum === p.startPos.pos_lnum =>
      let lparen = p.startPos;
      let args = parseConstructorArgs(p);
      let rparen = p.prevEndPos;
      let loc_paren = mkLoc(lparen, rparen);
      let tail =
        switch (args) {
        | [] => None
        | [{Parsetree.pexp_desc: Pexp_tuple(_)} as expr] as args =>
          if (p.mode == ParseForTypeChecker) {
            /* #a(1, 2) for type-checker */
            Some(expr);
          } else {
            /* #a((1, 2)) for type-checker */
            Some(Ast_helper.Exp.tuple(~loc=loc_paren, args));
          }
        | [arg] => Some(arg)
        | args =>
          /* #a((1, 2)) for printer */
          Some(Ast_helper.Exp.tuple(~loc=loc_paren, args))
        };

      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Exp.variant(~loc, ident, tail);
    | _ =>
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Exp.variant(~loc, ident, None);
    };
  }

  and parseConstructorArgs = p => {
    let lparen = p.Parser.startPos;
    Parser.expect(Lparen, p);
    let args =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.ExprList,
        ~f=parseConstrainedExprRegion,
        ~closing=Rparen,
        p,
      );

    Parser.expect(Rparen, p);
    switch (args) {
    | [] =>
      let loc = mkLoc(lparen, p.prevEndPos);
      [
        Ast_helper.Exp.construct(
          ~loc,
          Location.mkloc(Longident.Lident("()"), loc),
          None,
        ),
      ];
    | args => args
    };
  }

  and parseTupleExpr = (~first, ~startPos, p) => {
    let exprs =
      parseCommaDelimitedRegion(
        p,
        ~grammar=Grammar.ExprList,
        ~closing=Rparen,
        ~f=parseConstrainedExprRegion,
      );

    Parser.expect(Rparen, p);
    Ast_helper.Exp.tuple(
      ~loc=mkLoc(startPos, p.prevEndPos),
      [first, ...exprs],
    );
  }

  and parseSpreadExprRegion = p =>
    switch (p.Parser.token) {
    | DotDotDot =>
      Parser.next(p);
      let expr = parseConstrainedOrCoercedExpr(p);
      Some((true, expr));
    | token when Grammar.isExprStart(token) =>
      Some((false, parseConstrainedOrCoercedExpr(p)))
    | _ => None
    }

  and parseListExpr = (~startPos, p) => {
    Parser.expect(Lbracket, p);
    let listExprs =
      parseCommaDelimitedReversedList(
        p,
        ~grammar=Grammar.ListExpr,
        ~closing=Rbracket,
        ~f=parseSpreadExprRegion,
      );

    Parser.expect(Rbracket, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    switch (listExprs) {
    | [(true, expr), ...exprs] =>
      let exprs = exprs |> List.map(snd) |> List.rev;
      makeListExpression(loc, exprs, Some(expr));
    | exprs =>
      let exprs =
        exprs
        |> List.map(((spread, expr)) => {
             if (spread) {
               Parser.err(
                 p,
                 Diagnostics.message(ErrorMessages.listExprSpread),
               );
             };
             expr;
           })
        |> List.rev;

      makeListExpression(loc, exprs, None);
    };
  }

  /* Overparse ... and give a nice error message */
  and parseNonSpreadExp = (~msg, p) => {
    let () =
      switch (p.Parser.token) {
      | DotDotDot =>
        Parser.err(p, Diagnostics.message(msg));
        Parser.next(p);
      | _ => ()
      };

    switch (p.Parser.token) {
    | token when Grammar.isExprStart(token) =>
      let expr = parseExpr(p);
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        let typ = parseTypExpr(p);
        let loc = mkLoc(expr.pexp_loc.loc_start, typ.ptyp_loc.loc_end);
        Some(Ast_helper.Exp.constraint_(~loc, expr, typ));
      | _ => Some(expr)
      };
    | _ => None
    };
  }

  and parseArrayExp = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(Lbracket, p);
    let exprs =
      parseCommaDelimitedRegion(
        p,
        ~grammar=Grammar.ExprList,
        ~closing=Rbracket,
        ~f=parseNonSpreadExp(~msg=ErrorMessages.arrayExprSpread),
      );

    Parser.expect(Rbracket, p);
    Ast_helper.Exp.array(~loc=mkLoc(startPos, p.prevEndPos), exprs);
  }

  /* TODO: check attributes in the case of poly type vars,
   * might be context dependend: parseFieldDeclaration (see ocaml) */
  and parsePolyTypeExpr = p => {
    let startPos = p.Parser.startPos;
    switch (p.Parser.token) {
    | SingleQuote =>
      let vars = parseTypeVarList(p);
      switch (vars) {
      | [_v1, _v2, ..._] =>
        Parser.expect(Dot, p);
        let typ = parseTypExpr(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Typ.poly(~loc, vars, typ);
      | [var] =>
        switch (p.Parser.token) {
        | Dot =>
          Parser.next(p);
          let typ = parseTypExpr(p);
          let loc = mkLoc(startPos, p.prevEndPos);
          Ast_helper.Typ.poly(~loc, vars, typ);
        | EqualGreater =>
          Parser.next(p);
          let typ = Ast_helper.Typ.var(~loc=var.loc, var.txt);
          let returnType = parseTypExpr(~alias=false, p);
          let loc = mkLoc(typ.Parsetree.ptyp_loc.loc_start, p.prevEndPos);
          Ast_helper.Typ.arrow(~loc, Asttypes.Nolabel, typ, returnType);
        | _ => Ast_helper.Typ.var(~loc=var.loc, var.txt)
        }
      | _ => assert(false)
      };
    | _ => parseTypExpr(p)
    };
  }

  /* 'a 'b 'c */
  and parseTypeVarList = p => {
    let rec loop = (p, vars) =>
      switch (p.Parser.token) {
      | SingleQuote =>
        Parser.next(p);
        let (lident, loc) = parseLident(p);
        let var = Location.mkloc(lident, loc);
        loop(p, [var, ...vars]);
      | _ => List.rev(vars)
      };

    loop(p, []);
  }

  and parseLidentList = p => {
    let rec loop = (p, ls) =>
      switch (p.Parser.token) {
      | Lident(lident) =>
        let loc = mkLoc(p.startPos, p.endPos);
        Parser.next(p);
        loop(p, [Location.mkloc(lident, loc), ...ls]);
      | _ => List.rev(ls)
      };

    loop(p, []);
  }

  and parseAtomicTypExpr = (~attrs, p) => {
    Parser.leaveBreadcrumb(p, Grammar.AtomicTypExpr);
    let startPos = p.Parser.startPos;
    let typ =
      switch (p.Parser.token) {
      | SingleQuote =>
        Parser.next(p);
        let (ident, loc) = parseLident(p);
        Ast_helper.Typ.var(~loc, ~attrs, ident);
      | Underscore =>
        let endPos = p.endPos;
        Parser.next(p);
        Ast_helper.Typ.any(~loc=mkLoc(startPos, endPos), ~attrs, ());
      | Lparen =>
        Parser.next(p);
        switch (p.Parser.token) {
        | Rparen =>
          Parser.next(p);
          let loc = mkLoc(startPos, p.prevEndPos);
          let unitConstr = Location.mkloc(Longident.Lident("unit"), loc);
          Ast_helper.Typ.constr(~attrs, unitConstr, []);
        | _ =>
          let t = parseTypExpr(p);
          switch (p.token) {
          | Comma =>
            Parser.next(p);
            parseTupleType(~attrs, ~first=t, ~startPos, p);
          | _ =>
            Parser.expect(Rparen, p);
            {
              ...t,
              ptyp_loc: mkLoc(startPos, p.prevEndPos),
              ptyp_attributes: List.concat([attrs, t.ptyp_attributes]),
            };
          };
        };
      | Lbracket => parsePolymorphicVariantType(~attrs, p)
      | Uident(_)
      | Lident(_)
      | List =>
        let constr = parseValuePath(p);
        let args = parseTypeConstructorArgs(~constrName=constr, p);
        Ast_helper.Typ.constr(
          ~loc=mkLoc(startPos, p.prevEndPos),
          ~attrs,
          constr,
          args,
        );
      | Module =>
        Parser.next(p);
        Parser.expect(Lparen, p);
        let packageType = parsePackageType(~startPos, ~attrs, p);
        Parser.expect(Rparen, p);
        {...packageType, ptyp_loc: mkLoc(startPos, p.prevEndPos)};
      | Percent =>
        let extension = parseExtension(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Typ.extension(~attrs, ~loc, extension);
      | Lbrace => parseBsObjectType(~attrs, p)
      | token =>
        switch (
          skipTokensAndMaybeRetry(
            p,
            ~isStartOfGrammar=Grammar.isAtomicTypExprStart,
          )
        ) {
        | Some () => parseAtomicTypExpr(~attrs, p)
        | None =>
          Parser.err(
            ~startPos=p.prevEndPos,
            p,
            Diagnostics.unexpected(token, p.breadcrumbs),
          );
          Recover.defaultType();
        }
      };

    Parser.eatBreadcrumb(p);
    typ;
  }

  /* package-type	::=
        | modtype-path
        ∣ modtype-path with package-constraint  { and package-constraint }
     */
  and parsePackageType = (~startPos, ~attrs, p) => {
    let modTypePath = parseModuleLongIdent(~lowercase=true, p);
    switch (p.Parser.token) {
    | With =>
      Parser.next(p);
      let constraints = parsePackageConstraints(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Typ.package(~loc, ~attrs, modTypePath, constraints);
    | _ =>
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Typ.package(~loc, ~attrs, modTypePath, []);
    };
  }

  /* package-constraint  { and package-constraint } */
  and parsePackageConstraints = p => {
    let first = {
      Parser.expect(Typ, p);
      let typeConstr = parseValuePath(p);
      Parser.expect(Equal, p);
      let typ = parseTypExpr(p);
      (typeConstr, typ);
    };

    let rest =
      parseRegion(
        ~grammar=Grammar.PackageConstraint,
        ~f=parsePackageConstraint,
        p,
      );

    [first, ...rest];
  }

  /* and type typeconstr = typexpr */
  and parsePackageConstraint = p =>
    switch (p.Parser.token) {
    | And =>
      Parser.next(p);
      Parser.expect(Typ, p);
      let typeConstr = parseValuePath(p);
      Parser.expect(Equal, p);
      let typ = parseTypExpr(p);
      Some((typeConstr, typ));
    | _ => None
    }

  and parseBsObjectType = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.expect(Lbrace, p);
    let closedFlag =
      switch (p.token) {
      | DotDot =>
        Parser.next(p);
        Asttypes.Open;
      | Dot =>
        Parser.next(p);
        Asttypes.Closed;
      | _ => Asttypes.Closed
      };

    let fields =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.StringFieldDeclarations,
        ~closing=Rbrace,
        ~f=parseStringFieldDeclaration,
        p,
      );

    Parser.expect(Rbrace, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    makeBsObjType(~attrs, ~loc, ~closed=closedFlag, fields);
  }

  /* TODO: check associativity in combination with attributes */
  and parseTypeAlias = (p, typ) =>
    switch (p.Parser.token) {
    | As =>
      Parser.next(p);
      Parser.expect(SingleQuote, p);
      let (ident, _loc) = parseLident(p);
      /* TODO: how do we parse attributes here? */
      Ast_helper.Typ.alias(
        ~loc=mkLoc(typ.Parsetree.ptyp_loc.loc_start, p.prevEndPos),
        typ,
        ident,
      );
    | _ => typ
    }

  /* type_parameter ::=
   *  | type_expr
   *  | ~ident: type_expr
   *  | ~ident: type_expr=?
   *
   * note:
   *  | attrs ~ident: type_expr    -> attrs are on the arrow
   *  | attrs type_expr            -> attrs are here part of the type_expr
   *
   * uncurried_type_parameter ::=
   *  | . type_parameter
   */
  and parseTypeParameter = p =>
    if (p.Parser.token == Token.Tilde
        || p.token == Dot
        || Grammar.isTypExprStart(p.token)) {
      let startPos = p.Parser.startPos;
      let uncurried = Parser.optional(p, Dot);
      let attrs = parseAttributes(p);
      switch (p.Parser.token) {
      | Tilde =>
        Parser.next(p);
        let (name, _loc) = parseLident(p);
        Parser.expect(~grammar=Grammar.TypeExpression, Colon, p);
        let typ = parseTypExpr(p);
        switch (p.Parser.token) {
        | Equal =>
          Parser.next(p);
          Parser.expect(Question, p);
          Some((uncurried, attrs, Asttypes.Optional(name), typ, startPos));
        | _ =>
          Some((uncurried, attrs, Asttypes.Labelled(name), typ, startPos))
        };
      | Lident(_)
      | List =>
        let (name, loc) = parseLident(p);
        switch (p.token) {
        | Colon =>
          let () = {
            let error =
              Diagnostics.message(
                "Parameter names start with a `~`, like: ~" ++ name,
              );

            Parser.err(
              ~startPos=loc.loc_start,
              ~endPos=loc.loc_end,
              p,
              error,
            );
          };

          Parser.next(p);
          let typ = parseTypExpr(p);
          switch (p.Parser.token) {
          | Equal =>
            Parser.next(p);
            Parser.expect(Question, p);
            Some((uncurried, attrs, Asttypes.Optional(name), typ, startPos));
          | _ =>
            Some((uncurried, attrs, Asttypes.Labelled(name), typ, startPos))
          };
        | _ =>
          let constr = Location.mkloc(Longident.Lident(name), loc);
          let args = parseTypeConstructorArgs(~constrName=constr, p);
          let typ =
            Ast_helper.Typ.constr(
              ~loc=mkLoc(startPos, p.prevEndPos),
              ~attrs,
              constr,
              args,
            );

          let typ = parseArrowTypeRest(~es6Arrow=true, ~startPos, typ, p);
          let typ = parseTypeAlias(p, typ);
          Some((uncurried, [], Asttypes.Nolabel, typ, startPos));
        };
      | _ =>
        let typ = parseTypExpr(p);
        let typWithAttributes = {
          ...typ,
          ptyp_attributes: List.concat([attrs, typ.ptyp_attributes]),
        };
        Some((uncurried, [], Asttypes.Nolabel, typWithAttributes, startPos));
      };
    } else {
      None;
    }

  /* (int, ~x:string, float) */
  and parseTypeParameters = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(Lparen, p);
    switch (p.Parser.token) {
    | Rparen =>
      Parser.next(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      let unitConstr = Location.mkloc(Longident.Lident("unit"), loc);
      let typ = Ast_helper.Typ.constr(unitConstr, []);
      [(false, [], Asttypes.Nolabel, typ, startPos)];
    | _ =>
      let params =
        parseCommaDelimitedRegion(
          ~grammar=Grammar.TypeParameters,
          ~closing=Rparen,
          ~f=parseTypeParameter,
          p,
        );

      Parser.expect(Rparen, p);
      params;
    };
  }

  and parseEs6ArrowType = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    switch (p.Parser.token) {
    | Tilde =>
      Parser.next(p);
      let (name, _loc) = parseLident(p);
      Parser.expect(~grammar=Grammar.TypeExpression, Colon, p);
      let typ = parseTypExpr(~alias=false, ~es6Arrow=false, p);
      let arg =
        switch (p.Parser.token) {
        | Equal =>
          Parser.next(p);
          Parser.expect(Question, p);
          Asttypes.Optional(name);
        | _ => Asttypes.Labelled(name)
        };

      Parser.expect(EqualGreater, p);
      let returnType = parseTypExpr(~alias=false, p);
      Ast_helper.Typ.arrow(~attrs, arg, typ, returnType);
    | _ =>
      let parameters = parseTypeParameters(p);
      Parser.expect(EqualGreater, p);
      let returnType = parseTypExpr(~alias=false, p);
      let endPos = p.prevEndPos;
      let typ =
        List.fold_right(
          ((uncurried, attrs, argLbl, typ, startPos), t) => {
            let attrs =
              if (uncurried) {
                [uncurryAttr, ...attrs];
              } else {
                attrs;
              };
            Ast_helper.Typ.arrow(
              ~loc=mkLoc(startPos, endPos),
              ~attrs,
              argLbl,
              typ,
              t,
            );
          },
          parameters,
          returnType,
        );

      {
        ...typ,
        ptyp_attributes: List.concat([typ.ptyp_attributes, attrs]),
        ptyp_loc: mkLoc(startPos, p.prevEndPos),
      };
    };
  }

  /*
   * typexpr ::=
   *  | 'ident
   *  | _
   *  | (typexpr)
   *  | typexpr => typexpr            --> es6 arrow
   *  | (typexpr, typexpr) => typexpr --> es6 arrow
   *  | /typexpr, typexpr, typexpr/  --> tuple
   *  | typeconstr
   *  | typeconstr<typexpr>
   *  | typeconstr<typexpr, typexpr,>
   *  | typexpr as 'ident
   *  | %attr-id                      --> extension
   *  | %attr-id(payload)             --> extension
   *
   * typeconstr ::=
   *  | lident
   *  | uident.lident
   *  | uident.uident.lident     --> long module path
   */
  and parseTypExpr = (~attrs=?, ~es6Arrow=true, ~alias=true, p) => {
    /* Parser.leaveBreadcrumb p Grammar.TypeExpression; */
    let startPos = p.Parser.startPos;
    let attrs =
      switch (attrs) {
      | Some(attrs) => attrs
      | None => parseAttributes(p)
      };
    let typ =
      if (es6Arrow && isEs6ArrowType(p)) {
        parseEs6ArrowType(~attrs, p);
      } else {
        let typ = parseAtomicTypExpr(~attrs, p);
        parseArrowTypeRest(~es6Arrow, ~startPos, typ, p);
      };

    let typ =
      if (alias) {
        parseTypeAlias(p, typ);
      } else {
        typ;
      };
    /* Parser.eatBreadcrumb p; */
    typ;
  }

  and parseArrowTypeRest = (~es6Arrow, ~startPos, typ, p) =>
    switch (p.Parser.token) {
    | (EqualGreater | MinusGreater) as token when es6Arrow === true =>
      /* error recovery */
      if (token == MinusGreater) {
        Parser.expect(EqualGreater, p);
      };
      Parser.next(p);
      let returnType = parseTypExpr(~alias=false, p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Typ.arrow(~loc, Asttypes.Nolabel, typ, returnType);
    | _ => typ
    }

  and parseTypExprRegion = p =>
    if (Grammar.isTypExprStart(p.Parser.token)) {
      Some(parseTypExpr(p));
    } else {
      None;
    }

  and parseTupleType = (~attrs, ~first, ~startPos, p) => {
    let typexprs =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.TypExprList,
        ~closing=Rparen,
        ~f=parseTypExprRegion,
        p,
      );

    Parser.expect(Rparen, p);
    let tupleLoc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Typ.tuple(~attrs, ~loc=tupleLoc, [first, ...typexprs]);
  }

  and parseTypeConstructorArgRegion = p =>
    if (Grammar.isTypExprStart(p.Parser.token)) {
      Some(parseTypExpr(p));
    } else if (p.token == LessThan) {
      Parser.next(p);
      parseTypeConstructorArgRegion(p);
    } else {
      None;
    }

  /* Js.Nullable.value<'a> */
  and parseTypeConstructorArgs = (~constrName, p) => {
    let opening = p.Parser.token;
    let openingStartPos = p.startPos;
    switch (opening) {
    | LessThan
    | Lparen =>
      Scanner.setDiamondMode(p.scanner);
      Parser.next(p);
      let typeArgs =
        /* TODO: change Grammar.TypExprList to TypArgList!!! Why did I wrote this? */
        parseCommaDelimitedRegion(
          ~grammar=Grammar.TypExprList,
          ~closing=GreaterThan,
          ~f=parseTypeConstructorArgRegion,
          p,
        );

      let () =
        switch (p.token) {
        | Rparen when opening == Token.Lparen =>
          let typ = Ast_helper.Typ.constr(constrName, typeArgs);
          let msg =
            Doc.breakableGroup(
              ~forceBreak=true,
              Doc.concat([
                Doc.text("Type parameters require angle brackets:"),
                Doc.indent(
                  Doc.concat([
                    Doc.line,
                    Printer.printTypExpr(typ, CommentTable.empty),
                  ]),
                ),
              ]),
            )
            |> Doc.toString(~width=80);

          Parser.err(~startPos=openingStartPos, p, Diagnostics.message(msg));
          Parser.next(p);
        | _ => Parser.expect(GreaterThan, p)
        };

      Scanner.popMode(p.scanner, Diamond);
      typeArgs;
    | _ => []
    };
  }

  /* string-field-decl ::=
   *  | string: poly-typexpr
   *  | attributes string-field-decl */
  and parseStringFieldDeclaration = p => {
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | String(name) =>
      let nameStartPos = p.startPos;
      let nameEndPos = p.endPos;
      Parser.next(p);
      let fieldName = Location.mkloc(name, mkLoc(nameStartPos, nameEndPos));
      Parser.expect(~grammar=Grammar.TypeExpression, Colon, p);
      let typ = parsePolyTypeExpr(p);
      Some([@implicit_arity] Parsetree.Otag(fieldName, attrs, typ));
    | _token => None
    };
  }

  /* field-decl	::=
   *  | [mutable] field-name : poly-typexpr
   *  | attributes field-decl */
  and parseFieldDeclaration = p => {
    let startPos = p.Parser.startPos;
    let attrs = parseAttributes(p);
    let mut =
      if (Parser.optional(p, Token.Mutable)) {
        Asttypes.Mutable;
      } else {
        Asttypes.Immutable;
      };

    let (lident, loc) =
      switch (p.token) {
      | List =>
        let loc = mkLoc(p.startPos, p.endPos);
        Parser.next(p);
        ("list", loc);
      | _ => parseLident(p)
      };

    let name = Location.mkloc(lident, loc);
    let typ =
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        parsePolyTypeExpr(p);
      | _ =>
        Ast_helper.Typ.constr(
          ~loc=name.loc,
          {...name, txt: Lident(name.txt)},
          [],
        )
      };

    let loc = mkLoc(startPos, typ.ptyp_loc.loc_end);
    Ast_helper.Type.field(~attrs, ~loc, ~mut, name, typ);
  }

  and parseFieldDeclarationRegion = p => {
    let startPos = p.Parser.startPos;
    let attrs = parseAttributes(p);
    let mut =
      if (Parser.optional(p, Token.Mutable)) {
        Asttypes.Mutable;
      } else {
        Asttypes.Immutable;
      };

    switch (p.token) {
    | Lident(_)
    | List =>
      let (lident, loc) =
        switch (p.token) {
        | List =>
          let loc = mkLoc(p.startPos, p.endPos);
          Parser.next(p);
          ("list", loc);
        | _ => parseLident(p)
        };

      let name = Location.mkloc(lident, loc);
      let typ =
        switch (p.Parser.token) {
        | Colon =>
          Parser.next(p);
          parsePolyTypeExpr(p);
        | _ =>
          Ast_helper.Typ.constr(
            ~loc=name.loc,
            {...name, txt: Lident(name.txt)},
            [],
          )
        };

      let loc = mkLoc(startPos, typ.ptyp_loc.loc_end);
      Some(Ast_helper.Type.field(~attrs, ~loc, ~mut, name, typ));
    | _ => None
    };
  }

  /* record-decl ::=
   *  | { field-decl }
   *  | { field-decl, field-decl }
   *  | { field-decl, field-decl, field-decl, }
   */
  and parseRecordDeclaration = p => {
    Parser.leaveBreadcrumb(p, Grammar.RecordDecl);
    Parser.expect(Lbrace, p);
    let rows =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.RecordDecl,
        ~closing=Rbrace,
        ~f=parseFieldDeclarationRegion,
        p,
      );

    Parser.expect(Rbrace, p);
    Parser.eatBreadcrumb(p);
    rows;
  }

  /* constr-args ::=
   *  | (typexpr)
   *  | (typexpr, typexpr)
   *  | (typexpr, typexpr, typexpr,)
   *  | (record-decl)
   *
   * TODO: should we overparse inline-records in every position?
   * Give a good error message afterwards?
   */
  and parseConstrDeclArgs = p => {
    let constrArgs =
      switch (p.Parser.token) {
      | Lparen =>
        Parser.next(p);
        /* TODO: this could use some cleanup/stratification */
        switch (p.Parser.token) {
        | Lbrace =>
          let lbrace = p.startPos;
          Parser.next(p);
          let startPos = p.Parser.startPos;
          switch (p.Parser.token) {
          | DotDot
          | Dot =>
            let closedFlag =
              switch (p.token) {
              | DotDot =>
                Parser.next(p);
                Asttypes.Open;
              | Dot =>
                Parser.next(p);
                Asttypes.Closed;
              | _ => Asttypes.Closed
              };

            let fields =
              parseCommaDelimitedRegion(
                ~grammar=Grammar.StringFieldDeclarations,
                ~closing=Rbrace,
                ~f=parseStringFieldDeclaration,
                p,
              );

            Parser.expect(Rbrace, p);
            let loc = mkLoc(startPos, p.prevEndPos);
            let typ =
              makeBsObjType(~attrs=[], ~loc, ~closed=closedFlag, fields);
            Parser.optional(p, Comma) |> ignore;
            let moreArgs =
              parseCommaDelimitedRegion(
                ~grammar=Grammar.TypExprList,
                ~closing=Rparen,
                ~f=parseTypExprRegion,
                p,
              );

            Parser.expect(Rparen, p);
            Parsetree.Pcstr_tuple([typ, ...moreArgs]);
          | _ =>
            let attrs = parseAttributes(p);
            switch (p.Parser.token) {
            | String(_) =>
              let closedFlag = Asttypes.Closed;
              let fields =
                switch (attrs) {
                | [] =>
                  parseCommaDelimitedRegion(
                    ~grammar=Grammar.StringFieldDeclarations,
                    ~closing=Rbrace,
                    ~f=parseStringFieldDeclaration,
                    p,
                  )
                | attrs =>
                  let first = {
                    Parser.leaveBreadcrumb(
                      p,
                      Grammar.StringFieldDeclarations,
                    );
                    let field =
                      switch (parseStringFieldDeclaration(p)) {
                      | Some(field) => field
                      | None => assert(false)
                      };

                    /* parse comma after first */
                    let () =
                      switch (p.Parser.token) {
                      | Rbrace
                      | Eof => ()
                      | Comma => Parser.next(p)
                      | _ => Parser.expect(Comma, p)
                      };

                    Parser.eatBreadcrumb(p);
                    switch (field) {
                    | [@implicit_arity] Parsetree.Otag(label, _, ct) =>
                      [@implicit_arity] Parsetree.Otag(label, attrs, ct)
                    | Oinherit(ct) => Oinherit(ct)
                    };
                  };

                  [
                    first,
                    ...parseCommaDelimitedRegion(
                         ~grammar=Grammar.StringFieldDeclarations,
                         ~closing=Rbrace,
                         ~f=parseStringFieldDeclaration,
                         p,
                       ),
                  ];
                };
              Parser.expect(Rbrace, p);
              let loc = mkLoc(startPos, p.prevEndPos);
              let typ =
                makeBsObjType(~attrs=[], ~loc, ~closed=closedFlag, fields);
              Parser.optional(p, Comma) |> ignore;
              let moreArgs =
                parseCommaDelimitedRegion(
                  ~grammar=Grammar.TypExprList,
                  ~closing=Rparen,
                  ~f=parseTypExprRegion,
                  p,
                );

              Parser.expect(Rparen, p);
              Parsetree.Pcstr_tuple([typ, ...moreArgs]);
            | _ =>
              let fields =
                switch (attrs) {
                | [] =>
                  parseCommaDelimitedRegion(
                    ~grammar=Grammar.FieldDeclarations,
                    ~closing=Rbrace,
                    ~f=parseFieldDeclarationRegion,
                    p,
                  )
                | attrs =>
                  let first = {
                    let field = parseFieldDeclaration(p);
                    Parser.expect(Comma, p);
                    {...field, Parsetree.pld_attributes: attrs};
                  };

                  [
                    first,
                    ...parseCommaDelimitedRegion(
                         ~grammar=Grammar.FieldDeclarations,
                         ~closing=Rbrace,
                         ~f=parseFieldDeclarationRegion,
                         p,
                       ),
                  ];
                };

              let () =
                switch (fields) {
                | [] =>
                  Parser.err(
                    ~startPos=lbrace,
                    p,
                    Diagnostics.message(
                      "An inline record declaration needs at least one field",
                    ),
                  )
                | _ => ()
                };

              Parser.expect(Rbrace, p);
              Parser.optional(p, Comma) |> ignore;
              Parser.expect(Rparen, p);
              Parsetree.Pcstr_record(fields);
            };
          };
        | _ =>
          let args =
            parseCommaDelimitedRegion(
              ~grammar=Grammar.TypExprList,
              ~closing=Rparen,
              ~f=parseTypExprRegion,
              p,
            );

          Parser.expect(Rparen, p);
          Parsetree.Pcstr_tuple(args);
        };
      | _ => Pcstr_tuple([])
      };

    let res =
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        Some(parseTypExpr(p));
      | _ => None
      };

    (constrArgs, res);
  }

  /* constr-decl ::=
   *  | constr-name
   *  | attrs constr-name
   *  | constr-name const-args
   *  | attrs constr-name const-args */
  and parseTypeConstructorDeclarationWithBar = p =>
    switch (p.Parser.token) {
    | Bar =>
      let startPos = p.Parser.startPos;
      Parser.next(p);
      Some(parseTypeConstructorDeclaration(~startPos, p));
    | _ => None
    }

  and parseTypeConstructorDeclaration = (~startPos, p) => {
    Parser.leaveBreadcrumb(p, Grammar.ConstructorDeclaration);
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | Uident(uident) =>
      let uidentLoc = mkLoc(p.startPos, p.endPos);
      Parser.next(p);
      let (args, res) = parseConstrDeclArgs(p);
      Parser.eatBreadcrumb(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Type.constructor(
        ~loc,
        ~attrs,
        ~res?,
        ~args,
        Location.mkloc(uident, uidentLoc),
      );
    | t =>
      Parser.err(p, Diagnostics.uident(t));
      Ast_helper.Type.constructor(Location.mknoloc("_"));
    };
  }

  /* [|] constr-decl  { | constr-decl }   */
  and parseTypeConstructorDeclarations = (~first=?, p) => {
    let firstConstrDecl =
      switch (first) {
      | None =>
        let startPos = p.Parser.startPos;
        ignore(Parser.optional(p, Token.Bar));
        parseTypeConstructorDeclaration(~startPos, p);
      | Some(firstConstrDecl) => firstConstrDecl
      };

    [
      firstConstrDecl,
      ...parseRegion(
           ~grammar=Grammar.ConstructorDeclaration,
           ~f=parseTypeConstructorDeclarationWithBar,
           p,
         ),
    ];
  }

  /*
   * type-representation ::=
   *  ∣	 = [ | ] constr-decl  { | constr-decl }
   *  ∣	 = private [ | ] constr-decl  { | constr-decl }
   *  |  = |
   *  ∣	 = private |
   *  ∣	 = record-decl
   *  ∣	 = private record-decl
   *  |  = ..
   */
  and parseTypeRepresentation = p => {
    Parser.leaveBreadcrumb(p, Grammar.TypeRepresentation);
    /* = consumed */
    let privateFlag =
      if (Parser.optional(p, Token.Private)) {
        Asttypes.Private;
      } else {
        Asttypes.Public;
      };

    let kind =
      switch (p.Parser.token) {
      | Bar
      | Uident(_) =>
        Parsetree.Ptype_variant(parseTypeConstructorDeclarations(p))
      | Lbrace => Parsetree.Ptype_record(parseRecordDeclaration(p))
      | DotDot =>
        Parser.next(p);
        Ptype_open;
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        /* TODO: I have no idea if this is even remotely a good idea */
        Parsetree.Ptype_variant([]);
      };

    Parser.eatBreadcrumb(p);
    (privateFlag, kind);
  }

  /* type-param	::=
   *  | variance 'lident
   *  | variance _
   *
   * variance ::=
   *   | +
   *   | -
   *   | (* empty *)
   */
  and parseTypeParam = p => {
    let variance =
      switch (p.Parser.token) {
      | Plus =>
        Parser.next(p);
        Asttypes.Covariant;
      | Minus =>
        Parser.next(p);
        Contravariant;
      | _ => Invariant
      };

    switch (p.Parser.token) {
    | SingleQuote =>
      Parser.next(p);
      let (ident, loc) = parseLident(p);
      Some((Ast_helper.Typ.var(~loc, ident), variance));
    | Underscore =>
      let loc = mkLoc(p.startPos, p.endPos);
      Parser.next(p);
      Some((Ast_helper.Typ.any(~loc, ()), variance));
    /* TODO: should we try parsing lident as 'ident ? */
    | _token => None
    };
  }

  /* type-params	::=
   *  | <type-param>
   *  ∣	<type-param, type-param>
   *  ∣	<type-param, type-param, type-param>
   *  ∣	<type-param, type-param, type-param,>
   *
   *  TODO: when we have pretty-printer show an error
   *  with the actual code corrected. */
  and parseTypeParams = (~parent, p) => {
    let opening = p.Parser.token;
    switch (opening) {
    | LessThan
    | Lparen when p.startPos.pos_lnum === p.prevEndPos.pos_lnum =>
      Scanner.setDiamondMode(p.scanner);
      let openingStartPos = p.startPos;
      Parser.leaveBreadcrumb(p, Grammar.TypeParams);
      Parser.next(p);
      let params =
        parseCommaDelimitedRegion(
          ~grammar=Grammar.TypeParams,
          ~closing=GreaterThan,
          ~f=parseTypeParam,
          p,
        );

      let () =
        switch (p.token) {
        | Rparen when opening == Token.Lparen =>
          let msg =
            Doc.breakableGroup(
              ~forceBreak=true,
              Doc.concat([
                Doc.text("Type parameters require angle brackets:"),
                Doc.indent(
                  Doc.concat([
                    Doc.line,
                    Doc.concat([
                      Printer.printLongident(parent.Location.txt),
                      Printer.printTypeParams(params, CommentTable.empty),
                    ]),
                  ]),
                ),
              ]),
            )
            |> Doc.toString(~width=80);

          Parser.err(~startPos=openingStartPos, p, Diagnostics.message(msg));
          Parser.next(p);
        | _ => Parser.expect(GreaterThan, p)
        };

      Scanner.popMode(p.scanner, Diamond);
      Parser.eatBreadcrumb(p);
      params;
    | _ => []
    };
  }

  /* type-constraint	::=	constraint ' ident =  typexpr */
  and parseTypeConstraint = p => {
    let startPos = p.Parser.startPos;
    switch (p.Parser.token) {
    | Token.Constraint =>
      Parser.next(p);
      Parser.expect(SingleQuote, p);
      switch (p.Parser.token) {
      | Lident(ident) =>
        let identLoc = mkLoc(startPos, p.endPos);
        Parser.next(p);
        Parser.expect(Equal, p);
        let typ = parseTypExpr(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Some((Ast_helper.Typ.var(~loc=identLoc, ident), typ, loc));
      | t =>
        Parser.err(p, Diagnostics.lident(t));
        let loc = mkLoc(startPos, p.prevEndPos);
        Some((Ast_helper.Typ.any(), parseTypExpr(p), loc));
      };
    | _ => None
    };
  }

  /* type-constraints ::=
   *  | (* empty *)
   *  | type-constraint
   *  | type-constraint type-constraint
   *  | type-constraint type-constraint type-constraint (* 0 or more *)
   */
  and parseTypeConstraints = p =>
    parseRegion(~grammar=Grammar.TypeConstraint, ~f=parseTypeConstraint, p)

  and parseTypeEquationOrConstrDecl = p => {
    let uidentStartPos = p.Parser.startPos;
    switch (p.Parser.token) {
    | Uident(uident) =>
      Parser.next(p);
      switch (p.Parser.token) {
      | Dot =>
        Parser.next(p);
        let typeConstr =
          parseValuePathTail(p, uidentStartPos, Longident.Lident(uident));

        let loc = mkLoc(uidentStartPos, p.prevEndPos);
        let typ =
          parseTypeAlias(
            p,
            Ast_helper.Typ.constr(
              ~loc,
              typeConstr,
              parseTypeConstructorArgs(~constrName=typeConstr, p),
            ),
          );
        switch (p.token) {
        | Equal =>
          Parser.next(p);
          let (priv, kind) = parseTypeRepresentation(p);
          (Some(typ), priv, kind);
        | EqualGreater =>
          Parser.next(p);
          let returnType = parseTypExpr(~alias=false, p);
          let loc = mkLoc(uidentStartPos, p.prevEndPos);
          let arrowType =
            Ast_helper.Typ.arrow(~loc, Asttypes.Nolabel, typ, returnType);
          let typ = parseTypeAlias(p, arrowType);
          (Some(typ), Asttypes.Public, Parsetree.Ptype_abstract);
        | _ => (Some(typ), Asttypes.Public, Parsetree.Ptype_abstract)
        };
      | _ =>
        let uidentEndPos = p.endPos;
        let (args, res) = parseConstrDeclArgs(p);
        let first =
          Some(
            {
              let uidentLoc = mkLoc(uidentStartPos, uidentEndPos);
              Ast_helper.Type.constructor(
                ~loc=mkLoc(uidentStartPos, p.prevEndPos),
                ~res?,
                ~args,
                Location.mkloc(uident, uidentLoc),
              );
            },
          );
        (
          None,
          Asttypes.Public,
          Parsetree.Ptype_variant(
            parseTypeConstructorDeclarations(p, ~first?),
          ),
        );
      };
    | t =>
      Parser.err(p, Diagnostics.uident(t));
      /* TODO: is this a good idea? */
      (None, Asttypes.Public, Parsetree.Ptype_abstract);
    };
  }

  and parseRecordOrBsObjectDecl = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(Lbrace, p);
    switch (p.Parser.token) {
    | DotDot
    | Dot =>
      let closedFlag =
        switch (p.token) {
        | DotDot =>
          Parser.next(p);
          Asttypes.Open;
        | Dot =>
          Parser.next(p);
          Asttypes.Closed;
        | _ => Asttypes.Closed
        };

      let fields =
        parseCommaDelimitedRegion(
          ~grammar=Grammar.StringFieldDeclarations,
          ~closing=Rbrace,
          ~f=parseStringFieldDeclaration,
          p,
        );

      Parser.expect(Rbrace, p);
      let loc = mkLoc(startPos, p.prevEndPos);
      let typ =
        makeBsObjType(~attrs=[], ~loc, ~closed=closedFlag, fields)
        |> parseTypeAlias(p);

      let typ = parseArrowTypeRest(~es6Arrow=true, ~startPos, typ, p);
      (Some(typ), Asttypes.Public, Parsetree.Ptype_abstract);
    | _ =>
      let attrs = parseAttributes(p);
      switch (p.Parser.token) {
      | String(_) =>
        let closedFlag = Asttypes.Closed;
        let fields =
          switch (attrs) {
          | [] =>
            parseCommaDelimitedRegion(
              ~grammar=Grammar.StringFieldDeclarations,
              ~closing=Rbrace,
              ~f=parseStringFieldDeclaration,
              p,
            )
          | attrs =>
            let first = {
              Parser.leaveBreadcrumb(p, Grammar.StringFieldDeclarations);
              let field =
                switch (parseStringFieldDeclaration(p)) {
                | Some(field) => field
                | None => assert(false)
                };

              /* parse comma after first */
              let () =
                switch (p.Parser.token) {
                | Rbrace
                | Eof => ()
                | Comma => Parser.next(p)
                | _ => Parser.expect(Comma, p)
                };

              Parser.eatBreadcrumb(p);
              switch (field) {
              | [@implicit_arity] Parsetree.Otag(label, _, ct) =>
                [@implicit_arity] Parsetree.Otag(label, attrs, ct)
              | Oinherit(ct) => Oinherit(ct)
              };
            };

            [
              first,
              ...parseCommaDelimitedRegion(
                   ~grammar=Grammar.StringFieldDeclarations,
                   ~closing=Rbrace,
                   ~f=parseStringFieldDeclaration,
                   p,
                 ),
            ];
          };

        Parser.expect(Rbrace, p);
        let loc = mkLoc(startPos, p.prevEndPos);
        let typ =
          makeBsObjType(~attrs=[], ~loc, ~closed=closedFlag, fields)
          |> parseTypeAlias(p);

        let typ = parseArrowTypeRest(~es6Arrow=true, ~startPos, typ, p);
        (Some(typ), Asttypes.Public, Parsetree.Ptype_abstract);
      | _ =>
        Parser.leaveBreadcrumb(p, Grammar.RecordDecl);
        let fields =
          switch (attrs) {
          | [] =>
            parseCommaDelimitedRegion(
              ~grammar=Grammar.FieldDeclarations,
              ~closing=Rbrace,
              ~f=parseFieldDeclarationRegion,
              p,
            )
          | [attr, ..._] as attrs =>
            let first = {
              let field = parseFieldDeclaration(p);
              Parser.optional(p, Comma) |> ignore;
              {
                ...field,
                Parsetree.pld_attributes: attrs,
                pld_loc: {
                  ...field.Parsetree.pld_loc,
                  loc_start: (attr |> fst).loc.loc_start,
                },
              };
            };

            [
              first,
              ...parseCommaDelimitedRegion(
                   ~grammar=Grammar.FieldDeclarations,
                   ~closing=Rbrace,
                   ~f=parseFieldDeclarationRegion,
                   p,
                 ),
            ];
          };

        let () =
          switch (fields) {
          | [] =>
            Parser.err(
              ~startPos,
              p,
              Diagnostics.message("A record needs at least one field"),
            )
          | _ => ()
          };

        Parser.expect(Rbrace, p);
        Parser.eatBreadcrumb(p);
        (None, Asttypes.Public, Parsetree.Ptype_record(fields));
      };
    };
  }

  and parsePrivateEqOrRepr = p => {
    Parser.expect(Private, p);
    switch (p.Parser.token) {
    | Lbrace =>
      let (manifest, _, kind) = parseRecordOrBsObjectDecl(p);
      (manifest, Asttypes.Private, kind);
    | Uident(_) =>
      let (manifest, _, kind) = parseTypeEquationOrConstrDecl(p);
      (manifest, Asttypes.Private, kind);
    | Bar
    | DotDot =>
      let (_, kind) = parseTypeRepresentation(p);
      (None, Asttypes.Private, kind);
    | t when Grammar.isTypExprStart(t) => (
        Some(parseTypExpr(p)),
        Asttypes.Private,
        Parsetree.Ptype_abstract,
      )
    | _ =>
      let (_, kind) = parseTypeRepresentation(p);
      (None, Asttypes.Private, kind);
    };
  }

  /*
     polymorphic-variant-type	::=
                               | [ tag-spec-first  { | tag-spec } ]
                               | [> [ tag-spec ]  { | tag-spec } ]
                               | [< [|] tag-spec-full  { | tag-spec-full }  [ > { `tag-name }+ ] ]

               tag-spec-first	::=	`tag-name  [ of typexpr ]
                               |	[ typexpr ] |  tag-spec

                     tag-spec	::=	`tag-name  [ of typexpr ]
                               |	typexpr

                 tag-spec-full	::=	`tag-name  [ of [&] typexpr  { & typexpr } ]
                                |	typexpr
   */
  and parsePolymorphicVariantType = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.expect(Lbracket, p);
    switch (p.token) {
    | GreaterThan =>
      Parser.next(p);
      let rowFields =
        switch (p.token) {
        | Rbracket => []
        | Bar => parseTagSpecs(p)
        | _ =>
          let rowField = parseTagSpec(p);
          [rowField, ...parseTagSpecs(p)];
        };

      let variant = {
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Typ.variant(~attrs, ~loc, rowFields, Open, None);
      };
      Parser.expect(Rbracket, p);
      variant;
    | LessThan =>
      Parser.next(p);
      Parser.optional(p, Bar) |> ignore;
      let rowField = parseTagSpecFull(p);
      let rowFields = parseTagSpecFulls(p);
      let tagNames =
        if (p.token === GreaterThan) {
          Parser.next(p);
          let rec loop = p =>
            switch (p.Parser.token) {
            | Rbracket => []
            | _ =>
              let (ident, _loc) = parseHashIdent(~startPos=p.startPos, p);
              [ident, ...loop(p)];
            };

          loop(p);
        } else {
          [];
        };
      let variant = {
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Typ.variant(
          ~attrs,
          ~loc,
          [rowField, ...rowFields],
          Closed,
          Some(tagNames),
        );
      };
      Parser.expect(Rbracket, p);
      variant;
    | _ =>
      let rowFields1 = parseTagSpecFirst(p);
      let rowFields2 = parseTagSpecs(p);
      let variant = {
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Typ.variant(
          ~attrs,
          ~loc,
          rowFields1 @ rowFields2,
          Closed,
          None,
        );
      };
      Parser.expect(Rbracket, p);
      variant;
    };
  }

  and parseTagSpecFulls = p =>
    switch (p.Parser.token) {
    | Rbracket => []
    | GreaterThan => []
    | Bar =>
      Parser.next(p);
      let rowField = parseTagSpecFull(p);
      [rowField, ...parseTagSpecFulls(p)];
    | _ => []
    }

  and parseTagSpecFull = p => {
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | Hash => parsePolymorphicVariantTypeSpecHash(~attrs, ~full=true, p)
    | _ =>
      let typ = parseTypExpr(~attrs, p);
      Parsetree.Rinherit(typ);
    };
  }

  and parseTagSpecs = p =>
    switch (p.Parser.token) {
    | Bar =>
      Parser.next(p);
      let rowField = parseTagSpec(p);
      [rowField, ...parseTagSpecs(p)];
    | _ => []
    }

  and parseTagSpec = p => {
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | Hash => parsePolymorphicVariantTypeSpecHash(~attrs, ~full=false, p)
    | _ =>
      let typ = parseTypExpr(~attrs, p);
      Parsetree.Rinherit(typ);
    };
  }

  and parseTagSpecFirst = p => {
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | Bar =>
      Parser.next(p);
      [parseTagSpec(p)];
    | Hash => [parsePolymorphicVariantTypeSpecHash(~attrs, ~full=false, p)]
    | _ =>
      let typ = parseTypExpr(~attrs, p);
      Parser.expect(Bar, p);
      [Parsetree.Rinherit(typ), parseTagSpec(p)];
    };
  }

  and parsePolymorphicVariantTypeSpecHash =
      (~attrs, ~full, p): Parsetree.row_field => {
    let startPos = p.Parser.startPos;
    let (ident, loc) = parseHashIdent(~startPos, p);
    let rec loop = p =>
      switch (p.Parser.token) {
      | Band when full =>
        Parser.next(p);
        let rowField = parsePolymorphicVariantTypeArgs(p);
        [rowField, ...loop(p)];
      | _ => []
      };

    let (firstTuple, tagContainsAConstantEmptyConstructor) =
      switch (p.Parser.token) {
      | Band when full =>
        Parser.next(p);
        ([parsePolymorphicVariantTypeArgs(p)], true);
      | Lparen => ([parsePolymorphicVariantTypeArgs(p)], false)
      | _ => ([], true)
      };

    let tuples = firstTuple @ loop(p);
    [@implicit_arity]
    Parsetree.Rtag(
      Location.mkloc(ident, loc),
      attrs,
      tagContainsAConstantEmptyConstructor,
      tuples,
    );
  }

  and parsePolymorphicVariantTypeArgs = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(Lparen, p);
    let args =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.TypExprList,
        ~closing=Rparen,
        ~f=parseTypExprRegion,
        p,
      );

    Parser.expect(Rparen, p);
    let attrs = [];
    let loc = mkLoc(startPos, p.prevEndPos);
    switch (args) {
    | [{ptyp_desc: Ptyp_tuple(_)} as typ] as types =>
      if (p.mode == ParseForTypeChecker) {
        typ;
      } else {
        Ast_helper.Typ.tuple(~loc, ~attrs, types);
      }
    | [typ] => typ
    | types => Ast_helper.Typ.tuple(~loc, ~attrs, types)
    };
  }

  and parseTypeEquationAndRepresentation = p =>
    switch (p.Parser.token) {
    | (Equal | Bar) as token =>
      if (token == Bar) {
        Parser.expect(Equal, p);
      };
      Parser.next(p);
      switch (p.Parser.token) {
      | Uident(_) => parseTypeEquationOrConstrDecl(p)
      | Lbrace => parseRecordOrBsObjectDecl(p)
      | Private => parsePrivateEqOrRepr(p)
      | Bar
      | DotDot =>
        let (priv, kind) = parseTypeRepresentation(p);
        (None, priv, kind);
      | _ =>
        let manifest = Some(parseTypExpr(p));
        switch (p.Parser.token) {
        | Equal =>
          Parser.next(p);
          let (priv, kind) = parseTypeRepresentation(p);
          (manifest, priv, kind);
        | _ => (manifest, Public, Parsetree.Ptype_abstract)
        };
      };
    | _ => (None, Public, Parsetree.Ptype_abstract)
    }

  /* type-definition	::=	type [rec] typedef  { and typedef }
   * typedef	::=	typeconstr-name [type-params] type-information
   * type-information	::=	[type-equation]  [type-representation]  { type-constraint }
   * type-equation	::=	= typexpr */
  and parseTypeDef = (~attrs, ~startPos, p) => {
    Parser.leaveBreadcrumb(p, Grammar.TypeDef);
    /* let attrs = match attrs with | Some attrs -> attrs | None -> parseAttributes p in */
    Parser.leaveBreadcrumb(p, Grammar.TypeConstrName);
    let (name, loc) = parseLident(p);
    let typeConstrName = Location.mkloc(name, loc);
    Parser.eatBreadcrumb(p);
    let params = {
      let constrName = Location.mkloc(Longident.Lident(name), loc);
      parseTypeParams(~parent=constrName, p);
    };
    let typeDef = {
      let (manifest, priv, kind) = parseTypeEquationAndRepresentation(p);
      let cstrs = parseTypeConstraints(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Type.mk(
        ~loc,
        ~attrs,
        ~priv,
        ~kind,
        ~params,
        ~cstrs,
        ~manifest?,
        typeConstrName,
      );
    };

    Parser.eatBreadcrumb(p);
    typeDef;
  }

  and parseTypeExtension = (~params, ~attrs, ~name, p) => {
    Parser.expect(PlusEqual, p);
    let priv =
      if (Parser.optional(p, Token.Private)) {
        Asttypes.Private;
      } else {
        Asttypes.Public;
      };

    let constrStart = p.Parser.startPos;
    Parser.optional(p, Bar) |> ignore;
    let first = {
      let (attrs, name, kind) =
        switch (p.Parser.token) {
        | Bar =>
          Parser.next(p);
          parseConstrDef(~parseAttrs=true, p);
        | _ => parseConstrDef(~parseAttrs=true, p)
        };

      let loc = mkLoc(constrStart, p.prevEndPos);
      Ast_helper.Te.constructor(~loc, ~attrs, name, kind);
    };

    let rec loop = (p, cs) =>
      switch (p.Parser.token) {
      | Bar =>
        let startPos = p.Parser.startPos;
        Parser.next(p);
        let (attrs, name, kind) = parseConstrDef(~parseAttrs=true, p);
        let extConstr =
          Ast_helper.Te.constructor(
            ~attrs,
            ~loc=mkLoc(startPos, p.prevEndPos),
            name,
            kind,
          );

        loop(p, [extConstr, ...cs]);
      | _ => List.rev(cs)
      };

    let constructors = loop(p, [first]);
    Ast_helper.Te.mk(~attrs, ~params, ~priv, name, constructors);
  }

  and parseTypeDefinitions = (~attrs, ~name, ~params, ~startPos, p) => {
    let typeDef = {
      let (manifest, priv, kind) = parseTypeEquationAndRepresentation(p);
      let cstrs = parseTypeConstraints(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Type.mk(
        ~loc,
        ~attrs,
        ~priv,
        ~kind,
        ~params,
        ~cstrs,
        ~manifest?,
        {...name, txt: lidentOfPath(name.Location.txt)},
      );
    };

    let rec loop = (p, defs) => {
      let startPos = p.Parser.startPos;
      let attrs = parseAttributesAndBinding(p);
      switch (p.Parser.token) {
      | And =>
        Parser.next(p);
        let attrs =
          switch (p.token) {
          | Export =>
            let exportLoc = mkLoc(p.startPos, p.endPos);
            Parser.next(p);
            let genTypeAttr = (
              Location.mkloc("genType", exportLoc),
              Parsetree.PStr([]),
            );
            [genTypeAttr, ...attrs];
          | _ => attrs
          };

        let typeDef = parseTypeDef(~attrs, ~startPos, p);
        loop(p, [typeDef, ...defs]);
      | _ => List.rev(defs)
      };
    };

    loop(p, [typeDef]);
  }

  /* TODO: decide if we really want type extensions (eg. type x += Blue)
   * It adds quite a bit of complexity that can be avoided,
   * implemented for now. Needed to get a feel for the complexities of
   * this territory of the grammar */
  and parseTypeDefinitionOrExtension = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.expect(Token.Typ, p);
    let recFlag =
      switch (p.token) {
      | Rec =>
        Parser.next(p);
        Asttypes.Recursive;
      | Lident("nonrec") =>
        Parser.next(p);
        Asttypes.Nonrecursive;
      | _ => Asttypes.Nonrecursive
      };

    let name = parseValuePath(p);
    let params = parseTypeParams(~parent=name, p);
    switch (p.Parser.token) {
    | PlusEqual => TypeExt(parseTypeExtension(~params, ~attrs, ~name, p))
    | _ =>
      let typeDefs =
        parseTypeDefinitions(~attrs, ~name, ~params, ~startPos, p);
      TypeDef({recFlag, types: typeDefs});
    };
  }

  and parsePrimitive = p =>
    switch (p.Parser.token) {
    | String(s) =>
      Parser.next(p);
      Some(s);
    | _ => None
    }

  and parsePrimitives = p =>
    switch (parseRegion(~grammar=Grammar.Primitive, ~f=parsePrimitive, p)) {
    | [] =>
      let msg = "An external definition should have at least one primitive. Example: \"setTimeout\"";
      Parser.err(p, Diagnostics.message(msg));
      [];
    | primitives => primitives
    }

  /* external value-name : typexp = external-declaration */
  and parseExternalDef = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.leaveBreadcrumb(p, Grammar.External);
    Parser.expect(Token.External, p);
    let (name, loc) = parseLident(p);
    let name = Location.mkloc(name, loc);
    Parser.expect(~grammar=Grammar.TypeExpression, Colon, p);
    let typExpr = parseTypExpr(p);
    Parser.expect(Equal, p);
    let prim = parsePrimitives(p);
    let loc = mkLoc(startPos, p.prevEndPos);
    let vb = Ast_helper.Val.mk(~loc, ~attrs, ~prim, name, typExpr);
    Parser.eatBreadcrumb(p);
    vb;
  }

  /* constr-def ::=
   *  | constr-decl
   *  | constr-name = constr
   *
   *  constr-decl ::= constr-name constr-args
   *  constr-name ::= uident
   *  constr      ::= path-uident */
  and parseConstrDef = (~parseAttrs, p) => {
    let attrs =
      if (parseAttrs) {
        parseAttributes(p);
      } else {
        [];
      };
    let name =
      switch (p.Parser.token) {
      | Uident(name) =>
        let loc = mkLoc(p.startPos, p.endPos);
        Parser.next(p);
        Location.mkloc(name, loc);
      | t =>
        Parser.err(p, Diagnostics.uident(t));
        Location.mknoloc("_");
      };

    let kind =
      switch (p.Parser.token) {
      | Lparen =>
        let (args, res) = parseConstrDeclArgs(p);
        [@implicit_arity] Parsetree.Pext_decl(args, res);
      | Equal =>
        Parser.next(p);
        let longident = parseModuleLongIdent(~lowercase=false, p);
        Parsetree.Pext_rebind(longident);
      | _ => [@implicit_arity] Parsetree.Pext_decl(Pcstr_tuple([]), None)
      };

    (attrs, name, kind);
  }

  /*
   * exception-definition	::=
   *  | exception constr-decl
   *  ∣	exception constr-name = constr
   *
   *  constr-name ::= uident
   *  constr ::= long_uident */
  and parseExceptionDef = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.expect(Token.Exception, p);
    let (_, name, kind) = parseConstrDef(~parseAttrs=false, p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Te.constructor(~loc, ~attrs, name, kind);
  }

  /* module structure on the file level */
  [@progress (Parser.next, Parser.expect, Parser.checkProgress)]
  and parseImplementation = (p): Parsetree.structure =>
    parseRegion(
      p,
      ~grammar=Grammar.Implementation,
      ~f=parseStructureItemRegion,
    )

  and parseStructureItemRegion = p => {
    let startPos = p.Parser.startPos;
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | Open =>
      let openDescription = parseOpenDescription(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Str.open_(~loc, openDescription));
    | Let =>
      let (recFlag, letBindings) = parseLetBindings(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Str.value(~loc, recFlag, letBindings));
    | Typ =>
      Parser.beginRegion(p);
      switch (parseTypeDefinitionOrExtension(~attrs, p)) {
      | TypeDef({recFlag, types}) =>
        Parser.optional(p, Semicolon) |> ignore;
        let loc = mkLoc(startPos, p.prevEndPos);
        Parser.endRegion(p);
        Some(Ast_helper.Str.type_(~loc, recFlag, types));
      | TypeExt(ext) =>
        Parser.optional(p, Semicolon) |> ignore;
        let loc = mkLoc(startPos, p.prevEndPos);
        Parser.endRegion(p);
        Some(Ast_helper.Str.type_extension(~loc, ext));
      };
    | External =>
      let externalDef = parseExternalDef(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Str.primitive(~loc, externalDef));
    | Import =>
      let importDescr = parseJsImport(~startPos, ~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      let structureItem = JsFfi.toParsetree(importDescr);
      Some({...structureItem, pstr_loc: loc});
    | Exception =>
      let exceptionDef = parseExceptionDef(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Str.exception_(~loc, exceptionDef));
    | Include =>
      let includeStatement = parseIncludeStatement(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Str.include_(~loc, includeStatement));
    | Export =>
      let structureItem = parseJsExport(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some({...structureItem, pstr_loc: loc});
    | Module =>
      let structureItem = parseModuleOrModuleTypeImplOrPackExpr(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some({...structureItem, pstr_loc: loc});
    | AtAt =>
      let attr = parseStandaloneAttribute(p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Str.attribute(~loc, attr));
    | PercentPercent =>
      let extension = parseExtension(~moduleLanguage=true, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Str.extension(~attrs, ~loc, extension));
    | token when Grammar.isExprStart(token) =>
      let prevEndPos = p.Parser.endPos;
      let exp = parseExpr(p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Parser.checkProgress(
        ~prevEndPos,
        ~result=Ast_helper.Str.eval(~loc, ~attrs, exp),
        p,
      );
    | _ => None
    };
  }

  and parseJsImport = (~startPos, ~attrs, p) => {
    Parser.expect(Token.Import, p);
    let importSpec =
      switch (p.Parser.token) {
      | Token.Lident(_)
      | Token.At =>
        let decl =
          switch (parseJsFfiDeclaration(p)) {
          | Some(decl) => decl
          | None => assert(false)
          };

        JsFfi.Default(decl);
      | _ => JsFfi.Spec(parseJsFfiDeclarations(p))
      };

    let scope = parseJsFfiScope(p);
    let loc = mkLoc(startPos, p.prevEndPos);
    JsFfi.importDescr(~attrs, ~importSpec, ~scope, ~loc);
  }

  and parseJsExport = (~attrs, p) => {
    let exportStart = p.Parser.startPos;
    Parser.expect(Token.Export, p);
    let exportLoc = mkLoc(exportStart, p.prevEndPos);
    let genTypeAttr = (
      Location.mkloc("genType", exportLoc),
      Parsetree.PStr([]),
    );
    let attrs = [genTypeAttr, ...attrs];
    switch (p.Parser.token) {
    | Typ =>
      switch (parseTypeDefinitionOrExtension(~attrs, p)) {
      | TypeDef({recFlag, types}) => Ast_helper.Str.type_(recFlag, types)
      | TypeExt(ext) => Ast_helper.Str.type_extension(ext)
      }
    | /* Let */ _ =>
      let (recFlag, letBindings) = parseLetBindings(~attrs, p);
      Ast_helper.Str.value(recFlag, letBindings);
    };
  }

  and parseJsFfiScope = p =>
    switch (p.Parser.token) {
    | Token.Lident("from") =>
      Parser.next(p);
      switch (p.token) {
      | String(s) =>
        Parser.next(p);
        JsFfi.Module(s);
      | Uident(_)
      | Lident(_) =>
        let value = parseIdentPath(p);
        JsFfi.Scope(value);
      | _ => JsFfi.Global
      };
    | _ => JsFfi.Global
    }

  and parseJsFfiDeclarations = p => {
    Parser.expect(Token.Lbrace, p);
    let decls =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.JsFfiImport,
        ~closing=Rbrace,
        ~f=parseJsFfiDeclaration,
        p,
      );

    Parser.expect(Rbrace, p);
    decls;
  }

  and parseJsFfiDeclaration = p => {
    let startPos = p.Parser.startPos;
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | Lident(_) =>
      let (ident, _) = parseLident(p);
      let alias =
        switch (p.token) {
        | As =>
          Parser.next(p);
          let (ident, _) = parseLident(p);
          ident;
        | _ => ident
        };

      Parser.expect(Token.Colon, p);
      let typ = parseTypExpr(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(JsFfi.decl(~loc, ~alias, ~attrs, ~name=ident, ~typ));
    | _ => None
    };
  }

  /* include-statement ::= include module-expr */
  and parseIncludeStatement = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.expect(Token.Include, p);
    let modExpr = parseModuleExpr(p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Incl.mk(~loc, ~attrs, modExpr);
  }

  and parseAtomicModuleExpr = p => {
    let startPos = p.Parser.startPos;
    switch (p.Parser.token) {
    | Uident(_ident) =>
      let longident = parseModuleLongIdent(~lowercase=false, p);
      Ast_helper.Mod.ident(~loc=longident.loc, longident);
    | Lbrace =>
      Parser.next(p);
      let structure =
        Ast_helper.Mod.structure(
          parseDelimitedRegion(
            ~grammar=Grammar.Structure,
            ~closing=Rbrace,
            ~f=parseStructureItemRegion,
            p,
          ),
        );
      Parser.expect(Rbrace, p);
      let endPos = p.prevEndPos;
      {...structure, pmod_loc: mkLoc(startPos, endPos)};
    | Lparen =>
      Parser.next(p);
      let modExpr =
        switch (p.token) {
        | Rparen =>
          Ast_helper.Mod.structure(~loc=mkLoc(startPos, p.prevEndPos), [])
        | _ => parseConstrainedModExpr(p)
        };

      Parser.expect(Rparen, p);
      modExpr;
    | Lident("unpack") =>
      /* TODO: should this be made a keyword?? */
      Parser.next(p);
      Parser.expect(Lparen, p);
      let expr = parseExpr(p);
      switch (p.Parser.token) {
      | Colon =>
        let colonStart = p.Parser.startPos;
        Parser.next(p);
        let attrs = parseAttributes(p);
        let packageType = parsePackageType(~startPos=colonStart, ~attrs, p);
        Parser.expect(Rparen, p);
        let loc = mkLoc(startPos, p.prevEndPos);
        let constraintExpr =
          Ast_helper.Exp.constraint_(~loc, expr, packageType);

        Ast_helper.Mod.unpack(~loc, constraintExpr);
      | _ =>
        Parser.expect(Rparen, p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Mod.unpack(~loc, expr);
      };
    | Percent =>
      let extension = parseExtension(p);
      let loc = mkLoc(startPos, p.prevEndPos);
      Ast_helper.Mod.extension(~loc, extension);
    | token =>
      Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
      Recover.defaultModuleExpr();
    };
  }

  and parsePrimaryModExpr = p => {
    let startPos = p.Parser.startPos;
    let modExpr = parseAtomicModuleExpr(p);
    let rec loop = (p, modExpr) =>
      switch (p.Parser.token) {
      | Lparen when p.prevEndPos.pos_lnum === p.startPos.pos_lnum =>
        loop(p, parseModuleApplication(p, modExpr))
      | _ => modExpr
      };

    let modExpr = loop(p, modExpr);
    {...modExpr, pmod_loc: mkLoc(startPos, p.prevEndPos)};
  }

  /*
   * functor-arg ::=
   *  | uident : modtype
   *  | _ : modtype
   *  | modtype           --> "punning" for _ : modtype
   *  | attributes functor-arg
   */
  and parseFunctorArg = p => {
    let startPos = p.Parser.startPos;
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | Uident(ident) =>
      Parser.next(p);
      let uidentEndPos = p.prevEndPos;
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        let moduleType = parseModuleType(p);
        let loc = mkLoc(startPos, uidentEndPos);
        let argName = Location.mkloc(ident, loc);
        Some((attrs, argName, Some(moduleType), startPos));
      | Dot =>
        Parser.next(p);
        let moduleType = {
          let moduleLongIdent =
            parseModuleLongIdentTail(
              ~lowercase=false,
              p,
              startPos,
              Longident.Lident(ident),
            );
          Ast_helper.Mty.ident(~loc=moduleLongIdent.loc, moduleLongIdent);
        };

        let argName = Location.mknoloc("_");
        Some((attrs, argName, Some(moduleType), startPos));
      | _ =>
        let loc = mkLoc(startPos, uidentEndPos);
        let modIdent = Location.mkloc(Longident.Lident(ident), loc);
        let moduleType = Ast_helper.Mty.ident(~loc, modIdent);
        let argName = Location.mknoloc("_");
        Some((attrs, argName, Some(moduleType), startPos));
      };
    | Underscore =>
      Parser.next(p);
      let argName = Location.mkloc("_", mkLoc(startPos, p.prevEndPos));
      Parser.expect(Colon, p);
      let moduleType = parseModuleType(p);
      Some((attrs, argName, Some(moduleType), startPos));
    | _ => None
    };
  }

  and parseFunctorArgs = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(Lparen, p);
    let args =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.FunctorArgs,
        ~closing=Rparen,
        ~f=parseFunctorArg,
        p,
      );

    Parser.expect(Rparen, p);
    switch (args) {
    | [] => [
        (
          [],
          Location.mkloc("*", mkLoc(startPos, p.prevEndPos)),
          None,
          startPos,
        ),
      ]
    | args => args
    };
  }

  and parseFunctorModuleExpr = p => {
    let startPos = p.Parser.startPos;
    let args = parseFunctorArgs(p);
    let returnType =
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        Some(parseModuleType(~es6Arrow=false, p));
      | _ => None
      };

    Parser.expect(EqualGreater, p);
    let rhsModuleExpr = {
      let modExpr = parseModuleExpr(p);
      switch (returnType) {
      | Some(modType) =>
        Ast_helper.Mod.constraint_(
          ~loc=
            mkLoc(
              modExpr.pmod_loc.loc_start,
              modType.Parsetree.pmty_loc.loc_end,
            ),
          modExpr,
          modType,
        )
      | None => modExpr
      };
    };

    let endPos = p.prevEndPos;
    let modExpr =
      List.fold_right(
        ((attrs, name, moduleType, startPos), acc) =>
          Ast_helper.Mod.functor_(
            ~loc=mkLoc(startPos, endPos),
            ~attrs,
            name,
            moduleType,
            acc,
          ),
        args,
        rhsModuleExpr,
      );

    {...modExpr, pmod_loc: mkLoc(startPos, endPos)};
  }

  /* module-expr	::=
   *  | module-path
   *  ∣	{ structure-items }
   *  ∣	functorArgs =>  module-expr
   *  ∣	module-expr(module-expr)
   *  ∣	( module-expr )
   *  ∣	( module-expr : module-type )
   *  | extension
   *  | attributes module-expr */
  and parseModuleExpr = p => {
    let attrs = parseAttributes(p);
    let modExpr =
      if (isEs6ArrowFunctor(p)) {
        parseFunctorModuleExpr(p);
      } else {
        parsePrimaryModExpr(p);
      };

    {
      ...modExpr,
      pmod_attributes: List.concat([modExpr.pmod_attributes, attrs]),
    };
  }

  and parseConstrainedModExpr = p => {
    let modExpr = parseModuleExpr(p);
    switch (p.Parser.token) {
    | Colon =>
      Parser.next(p);
      let modType = parseModuleType(p);
      let loc = mkLoc(modExpr.pmod_loc.loc_start, modType.pmty_loc.loc_end);
      Ast_helper.Mod.constraint_(~loc, modExpr, modType);
    | _ => modExpr
    };
  }

  and parseConstrainedModExprRegion = p =>
    if (Grammar.isModExprStart(p.Parser.token)) {
      Some(parseConstrainedModExpr(p));
    } else {
      None;
    }

  and parseModuleApplication = (p, modExpr) => {
    let startPos = p.Parser.startPos;
    Parser.expect(Lparen, p);
    let args =
      parseCommaDelimitedRegion(
        ~grammar=Grammar.ModExprList,
        ~closing=Rparen,
        ~f=parseConstrainedModExprRegion,
        p,
      );

    Parser.expect(Rparen, p);
    let args =
      switch (args) {
      | [] =>
        let loc = mkLoc(startPos, p.prevEndPos);
        [Ast_helper.Mod.structure(~loc, [])];
      | args => args
      };

    List.fold_left(
      (modExpr, arg) =>
        Ast_helper.Mod.apply(
          ~loc=
            mkLoc(
              modExpr.Parsetree.pmod_loc.loc_start,
              arg.Parsetree.pmod_loc.loc_end,
            ),
          modExpr,
          arg,
        ),
      modExpr,
      args,
    );
  }

  and parseModuleOrModuleTypeImplOrPackExpr = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.expect(Module, p);
    switch (p.Parser.token) {
    | Typ => parseModuleTypeImpl(~attrs, startPos, p)
    | Lparen =>
      let expr = parseFirstClassModuleExpr(~startPos, p);
      Ast_helper.Str.eval(~attrs, expr);
    | _ => parseMaybeRecModuleBinding(~attrs, ~startPos, p)
    };
  }

  and parseModuleTypeImpl = (~attrs, startPos, p) => {
    Parser.expect(Typ, p);
    let nameStart = p.Parser.startPos;
    let name =
      switch (p.Parser.token) {
      | List =>
        Parser.next(p);
        let loc = mkLoc(nameStart, p.prevEndPos);
        Location.mkloc("list", loc);
      | Lident(ident) =>
        Parser.next(p);
        let loc = mkLoc(nameStart, p.prevEndPos);
        Location.mkloc(ident, loc);
      | Uident(ident) =>
        Parser.next(p);
        let loc = mkLoc(nameStart, p.prevEndPos);
        Location.mkloc(ident, loc);
      | t =>
        Parser.err(p, Diagnostics.uident(t));
        Location.mknoloc("_");
      };

    Parser.expect(Equal, p);
    let moduleType = parseModuleType(p);
    let moduleTypeDeclaration =
      Ast_helper.Mtd.mk(
        ~attrs,
        ~loc=mkLoc(nameStart, p.prevEndPos),
        ~typ=moduleType,
        name,
      );

    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Str.modtype(~loc, moduleTypeDeclaration);
  }

  /* definition	::=
     ∣	 module rec module-name :  module-type =  module-expr   { and module-name
     :  module-type =  module-expr } */
  and parseMaybeRecModuleBinding = (~attrs, ~startPos, p) =>
    switch (p.Parser.token) {
    | Token.Rec =>
      Parser.next(p);
      Ast_helper.Str.rec_module(parseModuleBindings(~startPos, ~attrs, p));
    | _ =>
      Ast_helper.Str.module_(
        parseModuleBinding(~attrs, ~startPos=p.Parser.startPos, p),
      )
    }

  and parseModuleBinding = (~attrs, ~startPos, p) => {
    let name =
      switch (p.Parser.token) {
      | Uident(ident) =>
        let startPos = p.Parser.startPos;
        Parser.next(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Location.mkloc(ident, loc);
      | t =>
        Parser.err(p, Diagnostics.uident(t));
        Location.mknoloc("_");
      };

    let body = parseModuleBindingBody(p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Mb.mk(~attrs, ~loc, name, body);
  }

  and parseModuleBindingBody = p => {
    /* TODO: make required with good error message when rec module binding */
    let returnModType =
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        Some(parseModuleType(p));
      | _ => None
      };

    Parser.expect(Equal, p);
    let modExpr = parseModuleExpr(p);
    switch (returnModType) {
    | Some(modType) =>
      Ast_helper.Mod.constraint_(
        ~loc=mkLoc(modType.pmty_loc.loc_start, modExpr.pmod_loc.loc_end),
        modExpr,
        modType,
      )
    | None => modExpr
    };
  }

  /* module-name :  module-type =  module-expr
   * { and module-name :  module-type =  module-expr } */
  and parseModuleBindings = (~attrs, ~startPos, p) => {
    let rec loop = (p, acc) => {
      let startPos = p.Parser.startPos;
      let attrs = parseAttributesAndBinding(p);
      switch (p.Parser.token) {
      | And =>
        Parser.next(p);
        ignore(Parser.optional(p, Module)); /* over-parse for fault-tolerance */
        let modBinding = parseModuleBinding(~attrs, ~startPos, p);
        loop(p, [modBinding, ...acc]);
      | _ => List.rev(acc)
      };
    };

    let first = parseModuleBinding(~attrs, ~startPos, p);
    loop(p, [first]);
  }

  and parseAtomicModuleType = p => {
    let startPos = p.Parser.startPos;
    let moduleType =
      switch (p.Parser.token) {
      | Uident(_)
      | Lident(_)
      | List =>
        /* Ocaml allows module types to end with lowercase: module Foo : bar = { ... }
         * lets go with uppercase terminal for now */
        let moduleLongIdent = parseModuleLongIdent(~lowercase=true, p);
        Ast_helper.Mty.ident(~loc=moduleLongIdent.loc, moduleLongIdent);
      | Lparen =>
        Parser.next(p);
        let mty = parseModuleType(p);
        Parser.expect(Rparen, p);
        {...mty, pmty_loc: mkLoc(startPos, p.prevEndPos)};
      | Lbrace =>
        Parser.next(p);
        let spec =
          parseDelimitedRegion(
            ~grammar=Grammar.Signature,
            ~closing=Rbrace,
            ~f=parseSignatureItemRegion,
            p,
          );

        Parser.expect(Rbrace, p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Mty.signature(~loc, spec);
      | Module =>
        /* TODO: check if this is still atomic when implementing first class modules*/
        parseModuleTypeOf(p)
      | Percent =>
        let extension = parseExtension(p);
        let loc = mkLoc(startPos, p.prevEndPos);
        Ast_helper.Mty.extension(~loc, extension);
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        Recover.defaultModuleType();
      };

    let moduleTypeLoc = mkLoc(startPos, p.prevEndPos);
    {...moduleType, pmty_loc: moduleTypeLoc};
  }

  and parseFunctorModuleType = p => {
    let startPos = p.Parser.startPos;
    let args = parseFunctorArgs(p);
    Parser.expect(EqualGreater, p);
    let rhs = parseModuleType(p);
    let endPos = p.prevEndPos;
    let modType =
      List.fold_right(
        ((attrs, name, moduleType, startPos), acc) =>
          Ast_helper.Mty.functor_(
            ~loc=mkLoc(startPos, endPos),
            ~attrs,
            name,
            moduleType,
            acc,
          ),
        args,
        rhs,
      );

    {...modType, pmty_loc: mkLoc(startPos, endPos)};
  }

  /* Module types are the module-level equivalent of type expressions: they
   * specify the general shape and type properties of modules.
   *
   * module-type ::=
   *  | modtype-path
   *  | { signature }
   *  | ( module-type )               --> parenthesized module-type
   *  | functor-args => module-type   --> functor
   *  | module-type => module-type    --> functor
   *  | module type of module-expr
   *  | attributes module-type
   *  | module-type with-mod-constraints
   *  | extension
   */
  and parseModuleType = (~es6Arrow=true, ~with_=true, p) => {
    let attrs = parseAttributes(p);
    let modty =
      if (es6Arrow && isEs6ArrowFunctor(p)) {
        parseFunctorModuleType(p);
      } else {
        let modty = parseAtomicModuleType(p);
        switch (p.Parser.token) {
        | EqualGreater when es6Arrow === true =>
          Parser.next(p);
          let rhs = parseModuleType(~with_=false, p);
          let str = Location.mknoloc("_");
          let loc = mkLoc(modty.pmty_loc.loc_start, p.prevEndPos);
          Ast_helper.Mty.functor_(~loc, str, Some(modty), rhs);
        | _ => modty
        };
      };

    let moduleType = {
      ...modty,
      pmty_attributes: List.concat([modty.pmty_attributes, attrs]),
    };
    if (with_) {
      parseWithConstraints(moduleType, p);
    } else {
      moduleType;
    };
  }

  and parseWithConstraints = (moduleType, p) =>
    switch (p.Parser.token) {
    | With =>
      Parser.next(p);
      let first = parseWithConstraint(p);
      let rec loop = (p, acc) =>
        switch (p.Parser.token) {
        | And =>
          Parser.next(p);
          loop(p, [parseWithConstraint(p), ...acc]);
        | _ => List.rev(acc)
        };

      let constraints = loop(p, [first]);
      let loc = mkLoc(moduleType.pmty_loc.loc_start, p.prevEndPos);
      Ast_helper.Mty.with_(~loc, moduleType, constraints);
    | _ => moduleType
    }

  /* mod-constraint	::=
   *  |  type typeconstr<type-params> type-equation type-constraints?
   *  ∣	 type typeconstr-name<type-params> := typexpr
   *  ∣	 module module-path = extended-module-path
   *  ∣	 module module-path :=  extended-module-path
   *
   *  TODO: split this up into multiple functions, better errors */
  and parseWithConstraint = p =>
    switch (p.Parser.token) {
    | Module =>
      Parser.next(p);
      let modulePath = parseModuleLongIdent(~lowercase=false, p);
      switch (p.Parser.token) {
      | ColonEqual =>
        Parser.next(p);
        let lident = parseModuleLongIdent(~lowercase=false, p);
        [@implicit_arity] Parsetree.Pwith_modsubst(modulePath, lident);
      | Equal =>
        Parser.next(p);
        let lident = parseModuleLongIdent(~lowercase=false, p);
        [@implicit_arity] Parsetree.Pwith_module(modulePath, lident);
      | token =>
        /* TODO: revisit */
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        let lident = parseModuleLongIdent(~lowercase=false, p);
        [@implicit_arity] Parsetree.Pwith_modsubst(modulePath, lident);
      };
    | Typ =>
      Parser.next(p);
      let typeConstr = parseValuePath(p);
      let params = parseTypeParams(~parent=typeConstr, p);
      switch (p.Parser.token) {
      | ColonEqual =>
        Parser.next(p);
        let typExpr = parseTypExpr(p);
        [@implicit_arity]
        Parsetree.Pwith_typesubst(
          typeConstr,
          Ast_helper.Type.mk(
            ~loc=typeConstr.loc,
            ~params,
            ~manifest=typExpr,
            Location.mkloc(Longident.last(typeConstr.txt), typeConstr.loc),
          ),
        );
      | Equal =>
        Parser.next(p);
        let typExpr = parseTypExpr(p);
        let typeConstraints = parseTypeConstraints(p);
        [@implicit_arity]
        Parsetree.Pwith_type(
          typeConstr,
          Ast_helper.Type.mk(
            ~loc=typeConstr.loc,
            ~params,
            ~manifest=typExpr,
            ~cstrs=typeConstraints,
            Location.mkloc(Longident.last(typeConstr.txt), typeConstr.loc),
          ),
        );
      | token =>
        /* TODO: revisit */
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        let typExpr = parseTypExpr(p);
        let typeConstraints = parseTypeConstraints(p);
        [@implicit_arity]
        Parsetree.Pwith_type(
          typeConstr,
          Ast_helper.Type.mk(
            ~loc=typeConstr.loc,
            ~params,
            ~manifest=typExpr,
            ~cstrs=typeConstraints,
            Location.mkloc(Longident.last(typeConstr.txt), typeConstr.loc),
          ),
        );
      };
    | token =>
      Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
      exit(-1);
    } /* TODO: handle this case */

  and parseModuleTypeOf = p => {
    let startPos = p.Parser.startPos;
    Parser.expect(Module, p);
    Parser.expect(Typ, p);
    Parser.expect(Of, p);
    let moduleExpr = parseModuleExpr(p);
    Ast_helper.Mty.typeof_(~loc=mkLoc(startPos, p.prevEndPos), moduleExpr);
  }

  /* module signature on the file level */
  [@progress (Parser.next, Parser.expect, Parser.checkProgress)]
  and parseSpecification = p =>
    parseRegion(
      ~grammar=Grammar.Specification,
      ~f=parseSignatureItemRegion,
      p,
    )

  and parseSignatureItemRegion = p => {
    let startPos = p.Parser.startPos;
    let attrs = parseAttributes(p);
    switch (p.Parser.token) {
    | Let =>
      Parser.beginRegion(p);
      let valueDesc = parseSignLetDesc(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Parser.endRegion(p);
      Some(Ast_helper.Sig.value(~loc, valueDesc));
    | Typ =>
      Parser.beginRegion(p);
      switch (parseTypeDefinitionOrExtension(~attrs, p)) {
      | TypeDef({recFlag, types}) =>
        Parser.optional(p, Semicolon) |> ignore;
        let loc = mkLoc(startPos, p.prevEndPos);
        Parser.endRegion(p);
        Some(Ast_helper.Sig.type_(~loc, recFlag, types));
      | TypeExt(ext) =>
        Parser.optional(p, Semicolon) |> ignore;
        let loc = mkLoc(startPos, p.prevEndPos);
        Parser.endRegion(p);
        Some(Ast_helper.Sig.type_extension(~loc, ext));
      };
    | External =>
      let externalDef = parseExternalDef(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Sig.value(~loc, externalDef));
    | Exception =>
      let exceptionDef = parseExceptionDef(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Sig.exception_(~loc, exceptionDef));
    | Open =>
      let openDescription = parseOpenDescription(~attrs, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Sig.open_(~loc, openDescription));
    | Include =>
      Parser.next(p);
      let moduleType = parseModuleType(p);
      let includeDescription =
        Ast_helper.Incl.mk(
          ~loc=mkLoc(startPos, p.prevEndPos),
          ~attrs,
          moduleType,
        );

      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Sig.include_(~loc, includeDescription));
    | Module =>
      Parser.next(p);
      switch (p.Parser.token) {
      | Uident(_) =>
        let modDecl = parseModuleDeclarationOrAlias(~attrs, p);
        Parser.optional(p, Semicolon) |> ignore;
        let loc = mkLoc(startPos, p.prevEndPos);
        Some(Ast_helper.Sig.module_(~loc, modDecl));
      | Rec =>
        let recModule = parseRecModuleSpec(~attrs, ~startPos, p);
        Parser.optional(p, Semicolon) |> ignore;
        let loc = mkLoc(startPos, p.prevEndPos);
        Some(Ast_helper.Sig.rec_module(~loc, recModule));
      | Typ => Some(parseModuleTypeDeclaration(~attrs, ~startPos, p))
      | _t =>
        let modDecl = parseModuleDeclarationOrAlias(~attrs, p);
        Parser.optional(p, Semicolon) |> ignore;
        let loc = mkLoc(startPos, p.prevEndPos);
        Some(Ast_helper.Sig.module_(~loc, modDecl));
      };
    | AtAt =>
      let attr = parseStandaloneAttribute(p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Sig.attribute(~loc, attr));
    | PercentPercent =>
      let extension = parseExtension(~moduleLanguage=true, p);
      Parser.optional(p, Semicolon) |> ignore;
      let loc = mkLoc(startPos, p.prevEndPos);
      Some(Ast_helper.Sig.extension(~attrs, ~loc, extension));
    | Import =>
      Parser.next(p);
      parseSignatureItemRegion(p);
    | _ => None
    };
  }

  /* module rec module-name :  module-type  { and module-name:  module-type } */
  and parseRecModuleSpec = (~attrs, ~startPos, p) => {
    Parser.expect(Rec, p);
    let rec loop = (p, spec) => {
      let startPos = p.Parser.startPos;
      let attrs = parseAttributesAndBinding(p);
      switch (p.Parser.token) {
      | And =>
        /* TODO: give a good error message when with constraint, no parens
         * and ASet: (Set.S with type elt = A.t)
         * and BTree: (Btree.S with type elt = A.t)
         * Without parens, the `and` signals the start of another
         * `with-constraint`
         */
        Parser.expect(And, p);
        let decl = parseRecModuleDeclaration(~attrs, ~startPos, p);
        loop(p, [decl, ...spec]);
      | _ => List.rev(spec)
      };
    };

    let first = parseRecModuleDeclaration(~attrs, ~startPos, p);
    loop(p, [first]);
  }

  /* module-name : module-type */
  and parseRecModuleDeclaration = (~attrs, ~startPos, p) => {
    let name =
      switch (p.Parser.token) {
      | Uident(modName) =>
        let loc = mkLoc(p.startPos, p.endPos);
        Parser.next(p);
        Location.mkloc(modName, loc);
      | t =>
        Parser.err(p, Diagnostics.uident(t));
        Location.mknoloc("_");
      };

    Parser.expect(Colon, p);
    let modType = parseModuleType(p);
    Ast_helper.Md.mk(
      ~loc=mkLoc(startPos, p.prevEndPos),
      ~attrs,
      name,
      modType,
    );
  }

  and parseModuleDeclarationOrAlias = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    let moduleName =
      switch (p.Parser.token) {
      | Uident(ident) =>
        let loc = mkLoc(p.Parser.startPos, p.endPos);
        Parser.next(p);
        Location.mkloc(ident, loc);
      | t =>
        Parser.err(p, Diagnostics.uident(t));
        Location.mknoloc("_");
      };

    let body =
      switch (p.Parser.token) {
      | Colon =>
        Parser.next(p);
        parseModuleType(p);
      | Equal =>
        Parser.next(p);
        let lident = parseModuleLongIdent(~lowercase=false, p);
        Ast_helper.Mty.alias(lident);
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        Recover.defaultModuleType();
      };

    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Md.mk(~loc, ~attrs, moduleName, body);
  }

  and parseModuleTypeDeclaration = (~attrs, ~startPos, p) => {
    Parser.expect(Typ, p);
    let moduleName =
      switch (p.Parser.token) {
      | Uident(ident) =>
        let loc = mkLoc(p.startPos, p.endPos);
        Parser.next(p);
        Location.mkloc(ident, loc);
      | Lident(ident) =>
        let loc = mkLoc(p.startPos, p.endPos);
        Parser.next(p);
        Location.mkloc(ident, loc);
      | t =>
        Parser.err(p, Diagnostics.uident(t));
        Location.mknoloc("_");
      };

    let typ =
      switch (p.Parser.token) {
      | Equal =>
        Parser.next(p);
        Some(parseModuleType(p));
      | _ => None
      };

    let moduleDecl = Ast_helper.Mtd.mk(~attrs, ~typ?, moduleName);
    Ast_helper.Sig.modtype(~loc=mkLoc(startPos, p.prevEndPos), moduleDecl);
  }

  and parseSignLetDesc = (~attrs, p) => {
    let startPos = p.Parser.startPos;
    Parser.expect(Let, p);
    let (name, loc) = parseLident(p);
    let name = Location.mkloc(name, loc);
    Parser.expect(Colon, p);
    let typExpr = parsePolyTypeExpr(p);
    let loc = mkLoc(startPos, p.prevEndPos);
    Ast_helper.Val.mk(~loc, ~attrs, name, typExpr);
  }

  /*    attr-id	::=	lowercase-ident
        ∣	  capitalized-ident
        ∣	  attr-id .  attr-id   */
  and parseAttributeId = p => {
    let startPos = p.Parser.startPos;
    let rec loop = (p, acc) =>
      switch (p.Parser.token) {
      | Lident(ident)
      | Uident(ident) =>
        Parser.next(p);
        let id = acc ++ ident;
        switch (p.Parser.token) {
        | Dot =>
          Parser.next(p);
          loop(p, id ++ ".");
        | _ => id
        };
      | token when Token.isKeyword(token) =>
        Parser.next(p);
        let id = acc ++ Token.toString(token);
        switch (p.Parser.token) {
        | Dot =>
          Parser.next(p);
          loop(p, id ++ ".");
        | _ => id
        };
      | token =>
        Parser.err(p, Diagnostics.unexpected(token, p.breadcrumbs));
        acc;
      };

    let id = loop(p, "");
    let endPos = p.prevEndPos;
    Location.mkloc(id, mkLoc(startPos, endPos));
  }

  /*
   * payload ::=  empty
   *          |  ( structure-item )
   *
   * TODO: what about multiple structure items?
   * @attr({let x = 1; let x = 2})
   *
   * Also what about type-expressions and specifications?
   * @attr(:myType) ???
   */
  and parsePayload = p =>
    switch (p.Parser.token) {
    | Lparen when p.startPos.pos_cnum == p.prevEndPos.pos_cnum =>
      Parser.next(p);
      switch (p.token) {
      | Colon =>
        Parser.next(p);
        let typ = parseTypExpr(p);
        Parser.expect(Rparen, p);
        Parsetree.PTyp(typ);
      | _ =>
        let items =
          parseDelimitedRegion(
            ~grammar=Grammar.Structure,
            ~closing=Rparen,
            ~f=parseStructureItemRegion,
            p,
          );

        Parser.expect(Rparen, p);
        Parsetree.PStr(items);
      };
    | _ => Parsetree.PStr([])
    }

  /* type attribute = string loc * payload */
  and parseAttribute = p =>
    switch (p.Parser.token) {
    | At =>
      Parser.next(p);
      let attrId = parseAttributeId(p);
      let payload = parsePayload(p);
      Some((attrId, payload));
    | _ => None
    }

  and parseAttributes = p =>
    parseRegion(p, ~grammar=Grammar.Attribute, ~f=parseAttribute)

  /*
   * standalone-attribute ::=
   *  | @@ atribute-id
   *  | @@ attribute-id ( structure-item )
   */
  and parseStandaloneAttribute = p => {
    Parser.expect(AtAt, p);
    let attrId = parseAttributeId(p);
    let payload = parsePayload(p);
    (attrId, payload);
  }

  /* extension	::=	% attr-id  attr-payload
   *              | %% attr-id(
   *  expr	::=	 ...
   *    ∣	 extension
   *
   *  typexpr	::=	 ...
   *    ∣	 extension
   *
   *  pattern	::=	 ...
   *    ∣	 extension
   *
   *  module-expr	::=	 ...
   *    ∣	 extension
   *
   *  module-type	::=	 ...
   *    ∣	 extension
   *
   *  class-expr	::=	 ...
   *    ∣	 extension
   *
   *  class-type	::=	 ...
   *    ∣	 extension
   *
   *
   * item extension nodes usable in structures and signature
   *
   * item-extension ::= %% attr-id
   *                  | %% attr-id(structure-item)
   *
   *  attr-payload ::= structure-item
   *
   *  ~moduleLanguage represents whether we're on the module level or not
   */
  and parseExtension = (~moduleLanguage=false, p) => {
    if (moduleLanguage) {
      Parser.expect(PercentPercent, p);
    } else {
      Parser.expect(Percent, p);
    };
    let attrId = parseAttributeId(p);
    let payload = parsePayload(p);
    (attrId, payload);
  };
};

module OutcomePrinter: {
  open Format;
  open Outcometree;

  [@live]
  let out_value: ref((formatter, out_value) => unit);
  [@live]
  let out_type: ref((formatter, out_type) => unit);
  [@live]
  let out_class_type: ref((formatter, out_class_type) => unit);
  [@live]
  let out_module_type: ref((formatter, out_module_type) => unit);
  [@live]
  let out_sig_item: ref((formatter, out_sig_item) => unit);
  [@live]
  let out_signature: ref((formatter, list(out_sig_item)) => unit);
  [@live]
  let out_type_extension: ref((formatter, out_type_extension) => unit);
  [@live]
  let out_phrase: ref((formatter, out_phrase) => unit);

  [@live]
  let parenthesized_ident: string => bool;
} = {
  /* Napkin doesn't have parenthesized identifiers.
   * We don't support custom operators. */
  let parenthesized_ident = _name => true;

  /* TODO: better allocation strategy for the buffer */
  let escapeStringContents = s => {
    let len = String.length(s);
    let b = Buffer.create(len);
    for (i in 0 to len - 1) {
      let c = s.[i];
      if (c == '\b') {
        Buffer.add_char(b, '\\');
        Buffer.add_char(b, 'b');
      } else if (c == '\t') {
        Buffer.add_char(b, '\\');
        Buffer.add_char(b, 't');
      } else if (c == '\n') {
        Buffer.add_char(b, '\\');
        Buffer.add_char(b, 'n');
      } else if (c == '\r') {
        Buffer.add_char(b, '\\');
        Buffer.add_char(b, 'r');
      } else if (c == '"') {
        Buffer.add_char(b, '\\');
        Buffer.add_char(b, '"');
      } else if (c == '\\') {
        Buffer.add_char(b, '\\');
        Buffer.add_char(b, '\\');
      } else {
        Buffer.add_char(b, c);
      };
    };
    Buffer.contents(b);
  };

  /* let rec print_ident fmt ident = match ident with
     | Outcometree.Oide_ident s -> Format.pp_print_string fmt s
     | Oide_dot (id, s) ->
       print_ident fmt id;
       Format.pp_print_char fmt '.';
       Format.pp_print_string fmt s
     | Oide_apply (id1, id2) ->
       print_ident fmt id1;
       Format.pp_print_char fmt '(';
       print_ident fmt id2;
       Format.pp_print_char fmt ')' */

  let rec printOutIdentDoc = (ident: Outcometree.out_ident) =>
    switch (ident) {
    | Oide_ident(s) => Doc.text(s)
    | [@implicit_arity] Oide_dot(ident, s) =>
      Doc.concat([printOutIdentDoc(ident), Doc.dot, Doc.text(s)])
    | [@implicit_arity] Oide_apply(call, arg) =>
      Doc.concat([
        printOutIdentDoc(call),
        Doc.lparen,
        printOutIdentDoc(arg),
        Doc.rparen,
      ])
    };

  let printOutAttributeDoc = (outAttribute: Outcometree.out_attribute) =>
    Doc.concat([Doc.text("@"), Doc.text(outAttribute.oattr_name)]);

  let printOutAttributesDoc = (attrs: list(Outcometree.out_attribute)) =>
    switch (attrs) {
    | [] => Doc.nil
    | attrs =>
      Doc.concat([
        Doc.group(
          Doc.join(~sep=Doc.line, List.map(printOutAttributeDoc, attrs)),
        ),
        Doc.line,
      ])
    };

  let rec collectArrowArgs = (outType: Outcometree.out_type, args) =>
    switch (outType) {
    | [@implicit_arity] Otyp_arrow(label, argType, returnType) =>
      let arg = (label, argType);
      collectArrowArgs(returnType, [arg, ...args]);
    | _ as returnType => (List.rev(args), returnType)
    };

  let rec collectFunctorArgs =
          (outModuleType: Outcometree.out_module_type, args) =>
    switch (outModuleType) {
    | [@implicit_arity] Omty_functor(lbl, optModType, returnModType) =>
      let arg = (lbl, optModType);
      collectFunctorArgs(returnModType, [arg, ...args]);
    | _ => (List.rev(args), outModuleType)
    };

  let rec printOutTypeDoc = (outType: Outcometree.out_type) =>
    switch (outType) {
    | Otyp_abstract
    | Otyp_variant(_) /* don't support poly-variants atm */
    | Otyp_open => Doc.nil
    | [@implicit_arity] Otyp_alias(typ, aliasTxt) =>
      Doc.concat([
        printOutTypeDoc(typ),
        Doc.text(" as '"),
        Doc.text(aliasTxt),
      ])
    | [@implicit_arity] Otyp_constr(outIdent, []) =>
      printOutIdentDoc(outIdent)
    | [@implicit_arity] Otyp_manifest(typ1, typ2) =>
      Doc.concat([
        printOutTypeDoc(typ1),
        Doc.text(" = "),
        printOutTypeDoc(typ2),
      ])
    | Otyp_record(record) => printRecordDeclarationDoc(~inline=true, record)
    | Otyp_stuff(txt) => Doc.text(txt)
    | [@implicit_arity] Otyp_var(ng, s) =>
      Doc.concat([Doc.text("'" ++ (if (ng) {"_"} else {""})), Doc.text(s)])
    | [@implicit_arity] Otyp_object(fields, rest) =>
      printObjectFields(fields, rest)
    | Otyp_class(_) => Doc.nil
    | [@implicit_arity] Otyp_attribute(typ, attribute) =>
      Doc.group(
        Doc.concat([
          printOutAttributeDoc(attribute),
          Doc.line,
          printOutTypeDoc(typ),
        ]),
      )
    /* example: Red | Blue | Green | CustomColour(float, float, float) */
    | Otyp_sum(constructors) => printOutConstructorsDoc(constructors)

    /* example: {"name": string, "age": int} */
    | [@implicit_arity]
      Otyp_constr(
        [@implicit_arity] Oide_dot(Oide_ident("Js"), "t"),
        [[@implicit_arity] Otyp_object(fields, rest)],
      ) =>
      printObjectFields(fields, rest)

    /* example: node<root, 'value> */
    | [@implicit_arity] Otyp_constr(outIdent, args) =>
      let argsDoc =
        switch (args) {
        | [] => Doc.nil
        | args =>
          Doc.concat([
            Doc.lessThan,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.comma, Doc.line]),
                  List.map(printOutTypeDoc, args),
                ),
              ]),
            ),
            Doc.trailingComma,
            Doc.softLine,
            Doc.greaterThan,
          ])
        };

      Doc.group(Doc.concat([printOutIdentDoc(outIdent), argsDoc]));
    | Otyp_tuple(tupleArgs) =>
      Doc.group(
        Doc.concat([
          Doc.lparen,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(printOutTypeDoc, tupleArgs),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.rparen,
        ]),
      )
    | [@implicit_arity] Otyp_poly(vars, outType) =>
      Doc.group(
        Doc.concat([
          Doc.join(
            ~sep=Doc.space,
            List.map(var => Doc.text("'" ++ var), vars),
          ),
          printOutTypeDoc(outType),
        ]),
      )
    | Otyp_arrow(_) as typ =>
      let (typArgs, typ) = collectArrowArgs(typ, []);
      let args =
        Doc.join(
          ~sep=Doc.concat([Doc.comma, Doc.line]),
          List.map(
            ((lbl, typ)) =>
              if (lbl == "") {
                printOutTypeDoc(typ);
              } else {
                Doc.group(
                  Doc.concat([
                    Doc.text("~" ++ lbl ++ ": "),
                    printOutTypeDoc(typ),
                  ]),
                );
              },
            typArgs,
          ),
        );
      let argsDoc = {
        let needsParens =
          switch (typArgs) {
          | [(_, Otyp_tuple(_) | Otyp_arrow(_))] => true
          /* single argument should not be wrapped */
          | [("", _)] => false
          | _ => true
          };

        if (needsParens) {
          Doc.group(
            Doc.concat([
              Doc.lparen,
              Doc.indent(Doc.concat([Doc.softLine, args])),
              Doc.trailingComma,
              Doc.softLine,
              Doc.rparen,
            ]),
          );
        } else {
          args;
        };
      };

      Doc.concat([argsDoc, Doc.text(" => "), printOutTypeDoc(typ)]);
    | [@implicit_arity] Otyp_module(_modName, _stringList, _outTypes) => Doc.nil
    }

  and printObjectFields = (fields, rest) => {
    let dots =
      switch (rest) {
      | Some(non_gen) => Doc.text((if (non_gen) {"_"} else {""}) ++ "..")
      | None => Doc.nil
      };

    Doc.group(
      Doc.concat([
        Doc.lbrace,
        dots,
        Doc.indent(
          Doc.concat([
            Doc.softLine,
            Doc.join(
              ~sep=Doc.concat([Doc.comma, Doc.line]),
              List.map(
                ((lbl, outType)) =>
                  Doc.group(
                    Doc.concat([
                      Doc.text("\"" ++ lbl ++ "\": "),
                      printOutTypeDoc(outType),
                    ]),
                  ),
                fields,
              ),
            ),
          ]),
        ),
        Doc.softLine,
        Doc.trailingComma,
        Doc.rbrace,
      ]),
    );
  }

  and printOutConstructorsDoc = constructors =>
    Doc.group(
      Doc.indent(
        Doc.concat([
          Doc.line,
          Doc.join(
            ~sep=Doc.line,
            List.mapi(
              (i, constructor) =>
                Doc.concat([
                  if (i > 0) {
                    Doc.text("| ");
                  } else {
                    Doc.ifBreaks(Doc.text("| "), Doc.nil);
                  },
                  printOutConstructorDoc(constructor),
                ]),
              constructors,
            ),
          ),
        ]),
      ),
    )

  and printOutConstructorDoc = ((name, args, gadt)) => {
    let gadtDoc =
      switch (gadt) {
      | Some(outType) =>
        Doc.concat([Doc.text(": "), printOutTypeDoc(outType)])
      | None => Doc.nil
      };

    let argsDoc =
      switch (args) {
      | [] => Doc.nil
      | [Otyp_record(record)] =>
        /* inline records
         *   | Root({
         *      mutable value: 'value,
         *      mutable updatedTime: float,
         *    })
         */
        Doc.concat([
          Doc.lparen,
          Doc.indent(printRecordDeclarationDoc(~inline=true, record)),
          Doc.rparen,
        ])
      | _types =>
        Doc.indent(
          Doc.concat([
            Doc.lparen,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.comma, Doc.line]),
                  List.map(printOutTypeDoc, args),
                ),
              ]),
            ),
            Doc.trailingComma,
            Doc.softLine,
            Doc.rparen,
          ]),
        )
      };

    Doc.group(Doc.concat([Doc.text(name), argsDoc, gadtDoc]));
  }

  and printRecordDeclRowDoc = ((name, mut, arg)) =>
    Doc.group(
      Doc.concat([
        if (mut) {
          Doc.text("mutable ");
        } else {
          Doc.nil;
        },
        Doc.text(name),
        Doc.text(": "),
        printOutTypeDoc(arg),
      ]),
    )

  and printRecordDeclarationDoc = (~inline, rows) => {
    let content =
      Doc.concat([
        Doc.lbrace,
        Doc.indent(
          Doc.concat([
            Doc.softLine,
            Doc.join(
              ~sep=Doc.concat([Doc.comma, Doc.line]),
              List.map(printRecordDeclRowDoc, rows),
            ),
          ]),
        ),
        Doc.trailingComma,
        Doc.softLine,
        Doc.rbrace,
      ]);
    if (!inline) {
      Doc.group(content);
    } else {
      content;
    };
  };

  let printOutType = (fmt, outType) =>
    Format.pp_print_string(
      fmt,
      Doc.toString(~width=80, printOutTypeDoc(outType)),
    );

  let printTypeParameterDoc = ((typ, (co, cn))) =>
    Doc.concat([
      if (!cn) {
        Doc.text("+");
      } else if (!co) {
        Doc.text("-");
      } else {
        Doc.nil;
      },
      if (typ == "_") {
        Doc.text("_");
      } else {
        Doc.text("'" ++ typ);
      },
    ]);

  let rec printOutSigItemDoc = (outSigItem: Outcometree.out_sig_item) =>
    switch (outSigItem) {
    | Osig_class(_)
    | Osig_class_type(_) => Doc.nil
    | Osig_ellipsis => Doc.dotdotdot
    | Osig_value(valueDecl) =>
      Doc.group(
        Doc.concat([
          printOutAttributesDoc(valueDecl.oval_attributes),
          Doc.text(
            switch (valueDecl.oval_prims) {
            | [] => "let "
            | _ => "external "
            },
          ),
          Doc.text(valueDecl.oval_name),
          Doc.text(":"),
          Doc.space,
          printOutTypeDoc(valueDecl.oval_type),
          switch (valueDecl.oval_prims) {
          | [] => Doc.nil
          | primitives =>
            Doc.indent(
              Doc.concat([
                Doc.text(" ="),
                Doc.line,
                Doc.group(
                  Doc.join(
                    ~sep=Doc.line,
                    List.map(
                      prim => Doc.text("\"" ++ prim ++ "\""),
                      primitives,
                    ),
                  ),
                ),
              ]),
            )
          },
        ]),
      )
    | [@implicit_arity] Osig_typext(outExtensionConstructor, _outExtStatus) =>
      printOutExtensionConstructorDoc(outExtensionConstructor)
    | [@implicit_arity] Osig_modtype(modName, Omty_signature([])) =>
      Doc.concat([Doc.text("module type "), Doc.text(modName)])
    | [@implicit_arity] Osig_modtype(modName, outModuleType) =>
      Doc.group(
        Doc.concat([
          Doc.text("module type "),
          Doc.text(modName),
          Doc.text(" = "),
          printOutModuleTypeDoc(outModuleType),
        ]),
      )
    | [@implicit_arity] Osig_module(modName, Omty_alias(ident), _) =>
      Doc.group(
        Doc.concat([
          Doc.text("module "),
          Doc.text(modName),
          Doc.text(" ="),
          Doc.line,
          printOutIdentDoc(ident),
        ]),
      )
    | [@implicit_arity] Osig_module(modName, outModType, outRecStatus) =>
      Doc.group(
        Doc.concat([
          Doc.text(
            switch (outRecStatus) {
            | Orec_not => "module "
            | Orec_first => "module rec "
            | Orec_next => "and"
            },
          ),
          Doc.text(modName),
          Doc.text(" = "),
          printOutModuleTypeDoc(outModType),
        ]),
      )
    | [@implicit_arity] Osig_type(outTypeDecl, outRecStatus) =>
      /* TODO: manifest ? */
      let attrs =
        switch (outTypeDecl.otype_immediate, outTypeDecl.otype_unboxed) {
        | (false, false) => Doc.nil
        | (true, false) => Doc.concat([Doc.text("@immediate"), Doc.line])
        | (false, true) => Doc.concat([Doc.text("@unboxed"), Doc.line])
        | (true, true) =>
          Doc.concat([Doc.text("@immediate @unboxed"), Doc.line])
        };

      let kw =
        Doc.text(
          switch (outRecStatus) {
          | Orec_not => "type "
          | Orec_first => "type rec "
          | Orec_next => "and "
          },
        );
      let typeParams =
        switch (outTypeDecl.otype_params) {
        | [] => Doc.nil
        | _params =>
          Doc.group(
            Doc.concat([
              Doc.lessThan,
              Doc.indent(
                Doc.concat([
                  Doc.softLine,
                  Doc.join(
                    ~sep=Doc.concat([Doc.comma, Doc.line]),
                    List.map(printTypeParameterDoc, outTypeDecl.otype_params),
                  ),
                ]),
              ),
              Doc.trailingComma,
              Doc.softLine,
              Doc.greaterThan,
            ]),
          )
        };

      let privateDoc =
        switch (outTypeDecl.otype_private) {
        | Asttypes.Private => Doc.text("private ")
        | Public => Doc.nil
        };

      let kind =
        switch (outTypeDecl.otype_type) {
        | Otyp_open =>
          Doc.concat([Doc.text(" = "), privateDoc, Doc.text("..")])
        | Otyp_abstract => Doc.nil
        | Otyp_record(record) =>
          Doc.concat([
            Doc.text(" = "),
            privateDoc,
            printRecordDeclarationDoc(~inline=false, record),
          ])
        | typ => Doc.concat([Doc.text(" = "), printOutTypeDoc(typ)])
        };

      let constraints =
        switch (outTypeDecl.otype_cstrs) {
        | [] => Doc.nil
        | _ =>
          Doc.group(
            Doc.concat([
              Doc.line,
              Doc.indent(
                Doc.concat([
                  Doc.hardLine,
                  Doc.join(
                    ~sep=Doc.line,
                    List.map(
                      ((typ1, typ2)) =>
                        Doc.group(
                          Doc.concat([
                            Doc.text("constraint "),
                            printOutTypeDoc(typ1),
                            Doc.text(" ="),
                            Doc.indent(
                              Doc.concat([Doc.line, printOutTypeDoc(typ2)]),
                            ),
                          ]),
                        ),
                      outTypeDecl.otype_cstrs,
                    ),
                  ),
                ]),
              ),
            ]),
          )
        };
      Doc.group(
        Doc.concat([
          attrs,
          Doc.group(
            Doc.concat([
              attrs,
              kw,
              Doc.text(outTypeDecl.otype_name),
              typeParams,
              kind,
            ]),
          ),
          constraints,
        ]),
      );
    }

  and printOutModuleTypeDoc = (outModType: Outcometree.out_module_type) =>
    switch (outModType) {
    | Omty_abstract => Doc.nil
    | Omty_ident(ident) => printOutIdentDoc(ident)
    /* example: module Increment = (M: X_int) => X_int */
    | Omty_functor(_) =>
      let (args, returnModType) = collectFunctorArgs(outModType, []);
      let argsDoc =
        switch (args) {
        | [(_, None)] => Doc.text("()")
        | args =>
          Doc.group(
            Doc.concat([
              Doc.lparen,
              Doc.indent(
                Doc.concat([
                  Doc.softLine,
                  Doc.join(
                    ~sep=Doc.concat([Doc.comma, Doc.line]),
                    List.map(
                      ((lbl, optModType)) =>
                        Doc.group(
                          Doc.concat([
                            Doc.text(lbl),
                            switch (optModType) {
                            | None => Doc.nil
                            | Some(modType) =>
                              Doc.concat([
                                Doc.text(": "),
                                printOutModuleTypeDoc(modType),
                              ])
                            },
                          ]),
                        ),
                      args,
                    ),
                  ),
                ]),
              ),
              Doc.trailingComma,
              Doc.softLine,
              Doc.rparen,
            ]),
          )
        };

      Doc.group(
        Doc.concat([
          argsDoc,
          Doc.text(" => "),
          printOutModuleTypeDoc(returnModType),
        ]),
      );
    | Omty_signature([]) => Doc.nil
    | Omty_signature(signature) =>
      Doc.breakableGroup(
        ~forceBreak=true,
        Doc.concat([
          Doc.lbrace,
          Doc.indent(
            Doc.concat([Doc.line, printOutSignatureDoc(signature)]),
          ),
          Doc.softLine,
          Doc.rbrace,
        ]),
      )
    | Omty_alias(_ident) => Doc.nil
    }

  and printOutSignatureDoc = (signature: list(Outcometree.out_sig_item)) => {
    let rec loop = (signature, acc) =>
      switch (signature) {
      | [] => List.rev(acc)
      | [
          [@implicit_arity] Outcometree.Osig_typext(ext, Oext_first),
          ...items,
        ] =>
        /* Gather together the extension constructors */
        let rec gather_extensions = (acc, items) =>
          switch (items) {
          | [
              [@implicit_arity] Outcometree.Osig_typext(ext, Oext_next),
              ...items,
            ] =>
            gather_extensions(
              [(ext.oext_name, ext.oext_args, ext.oext_ret_type), ...acc],
              items,
            )
          | _ => (List.rev(acc), items)
          };

        let (exts, items) =
          gather_extensions(
            [(ext.oext_name, ext.oext_args, ext.oext_ret_type)],
            items,
          );

        let te = {
          Outcometree.otyext_name: ext.oext_type_name,
          otyext_params: ext.oext_type_params,
          otyext_constructors: exts,
          otyext_private: ext.oext_private,
        };

        let doc = printOutTypeExtensionDoc(te);
        loop(items, [doc, ...acc]);
      | [item, ...items] =>
        let doc = printOutSigItemDoc(item);
        loop(items, [doc, ...acc]);
      };

    switch (loop(signature, [])) {
    | [doc] => doc
    | docs =>
      Doc.breakableGroup(~forceBreak=true, Doc.join(~sep=Doc.line, docs))
    };
  }

  and printOutExtensionConstructorDoc =
      (outExt: Outcometree.out_extension_constructor) => {
    let typeParams =
      switch (outExt.oext_type_params) {
      | [] => Doc.nil
      | params =>
        Doc.group(
          Doc.concat([
            Doc.lessThan,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.comma, Doc.line]),
                  List.map(
                    ty =>
                      Doc.text(
                        if (ty == "_") {
                          ty;
                        } else {
                          "'" ++ ty;
                        },
                      ),
                    params,
                  ),
                ),
              ]),
            ),
            Doc.softLine,
            Doc.greaterThan,
          ]),
        )
      };

    Doc.group(
      Doc.concat([
        Doc.text("type "),
        Doc.text(outExt.oext_type_name),
        typeParams,
        Doc.text(" +="),
        Doc.line,
        if (outExt.oext_private == Asttypes.Private) {
          Doc.text("private ");
        } else {
          Doc.nil;
        },
        printOutConstructorDoc((
          outExt.oext_name,
          outExt.oext_args,
          outExt.oext_ret_type,
        )),
      ]),
    );
  }

  and printOutTypeExtensionDoc =
      (typeExtension: Outcometree.out_type_extension) => {
    let typeParams =
      switch (typeExtension.otyext_params) {
      | [] => Doc.nil
      | params =>
        Doc.group(
          Doc.concat([
            Doc.lessThan,
            Doc.indent(
              Doc.concat([
                Doc.softLine,
                Doc.join(
                  ~sep=Doc.concat([Doc.comma, Doc.line]),
                  List.map(
                    ty =>
                      Doc.text(
                        if (ty == "_") {
                          ty;
                        } else {
                          "'" ++ ty;
                        },
                      ),
                    params,
                  ),
                ),
              ]),
            ),
            Doc.softLine,
            Doc.greaterThan,
          ]),
        )
      };

    Doc.group(
      Doc.concat([
        Doc.text("type "),
        Doc.text(typeExtension.otyext_name),
        typeParams,
        Doc.text(" +="),
        if (typeExtension.otyext_private == Asttypes.Private) {
          Doc.text("private ");
        } else {
          Doc.nil;
        },
        printOutConstructorsDoc(typeExtension.otyext_constructors),
      ]),
    );
  };

  let printOutSigItem = (fmt, outSigItem) =>
    Format.pp_print_string(
      fmt,
      Doc.toString(~width=80, printOutSigItemDoc(outSigItem)),
    );

  let printOutSignature = (fmt, signature) =>
    Format.pp_print_string(
      fmt,
      Doc.toString(~width=80, printOutSignatureDoc(signature)),
    );

  let validFloatLexeme = s => {
    let l = String.length(s);
    let rec loop = i =>
      if (i >= l) {
        s ++ ".";
      } else {
        switch ([@doesNotRaise] s.[i]) {
        | '0'..'9'
        | '-' => loop(i + 1)
        | _ => s
        };
      };
    loop(0);
  };

  let floatRepres = f =>
    switch (classify_float(f)) {
    | FP_nan => "nan"
    | FP_infinite =>
      if (f < 0.0) {
        "neg_infinity";
      } else {
        "infinity";
      }
    | _ =>
      let float_val = {
        let s1 = Printf.sprintf("%.12g", f);
        if (f == ([@doesNotRaise] float_of_string)(s1)) {
          s1;
        } else {
          let s2 = Printf.sprintf("%.15g", f);
          if (f == ([@doesNotRaise] float_of_string)(s2)) {
            s2;
          } else {
            Printf.sprintf("%.18g", f);
          };
        };
      };
      validFloatLexeme(float_val);
    };

  let rec printOutValueDoc = (outValue: Outcometree.out_value) =>
    switch (outValue) {
    | Oval_array(outValues) =>
      Doc.group(
        Doc.concat([
          Doc.lbracket,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(printOutValueDoc, outValues),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.rbracket,
        ]),
      )
    | Oval_char(c) => Doc.text("'" ++ Char.escaped(c) ++ "'")
    | [@implicit_arity] Oval_constr(outIdent, outValues) =>
      Doc.group(
        Doc.concat([
          printOutIdentDoc(outIdent),
          Doc.lparen,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(printOutValueDoc, outValues),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.rparen,
        ]),
      )
    | Oval_ellipsis => Doc.text("...")
    | Oval_int(i) => Doc.text(Format.sprintf("%i", i))
    | Oval_int32(i) => Doc.text(Format.sprintf("%lil", i))
    | Oval_int64(i) => Doc.text(Format.sprintf("%LiL", i))
    | Oval_nativeint(i) => Doc.text(Format.sprintf("%nin", i))
    | Oval_float(f) => Doc.text(floatRepres(f))
    | Oval_list(outValues) =>
      Doc.group(
        Doc.concat([
          Doc.text("list["),
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(printOutValueDoc, outValues),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.rbracket,
        ]),
      )
    | Oval_printer(fn) =>
      let fmt = Format.str_formatter;
      fn(fmt);
      let str = Format.flush_str_formatter();
      Doc.text(str);
    | Oval_record(rows) =>
      Doc.group(
        Doc.concat([
          Doc.lparen,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(
                  ((outIdent, outValue)) =>
                    Doc.group(
                      Doc.concat([
                        printOutIdentDoc(outIdent),
                        Doc.text(": "),
                        printOutValueDoc(outValue),
                      ]),
                    ),
                  rows,
                ),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.rparen,
        ]),
      )
    | [@implicit_arity] Oval_string(txt, _sizeToPrint, _kind) =>
      Doc.text(escapeStringContents(txt))
    | Oval_stuff(txt) => Doc.text(txt)
    | Oval_tuple(outValues) =>
      Doc.group(
        Doc.concat([
          Doc.lparen,
          Doc.indent(
            Doc.concat([
              Doc.softLine,
              Doc.join(
                ~sep=Doc.concat([Doc.comma, Doc.line]),
                List.map(printOutValueDoc, outValues),
              ),
            ]),
          ),
          Doc.trailingComma,
          Doc.softLine,
          Doc.rparen,
        ]),
      )
    /* Not supported by NapkinScript */
    | Oval_variant(_) => Doc.nil
    };

  let printOutExceptionDoc = (exc, outValue) =>
    switch (exc) {
    | Sys.Break => Doc.text("Interrupted.")
    | Out_of_memory => Doc.text("Out of memory during evaluation.")
    | Stack_overflow =>
      Doc.text("Stack overflow during evaluation (looping recursion?).")
    | _ =>
      Doc.group(
        Doc.indent(
          Doc.concat([
            Doc.text("Exception:"),
            Doc.line,
            printOutValueDoc(outValue),
          ]),
        ),
      )
    };

  let printOutPhraseSignature = signature => {
    let rec loop = (signature, acc) =>
      switch (signature) {
      | [] => List.rev(acc)
      | [
          ([@implicit_arity] Outcometree.Osig_typext(ext, Oext_first), None),
          ...signature,
        ] =>
        /* Gather together extension constructors */
        let rec gather_extensions = (acc, items) =>
          switch (items) {
          | [
              (
                [@implicit_arity] Outcometree.Osig_typext(ext, Oext_next),
                None,
              ),
              ...items,
            ] =>
            gather_extensions(
              [(ext.oext_name, ext.oext_args, ext.oext_ret_type), ...acc],
              items,
            )
          | _ => (List.rev(acc), items)
          };

        let (exts, signature) =
          gather_extensions(
            [(ext.oext_name, ext.oext_args, ext.oext_ret_type)],
            signature,
          );

        let te = {
          Outcometree.otyext_name: ext.oext_type_name,
          otyext_params: ext.oext_type_params,
          otyext_constructors: exts,
          otyext_private: ext.oext_private,
        };

        let doc = printOutTypeExtensionDoc(te);
        loop(signature, [doc, ...acc]);
      | [(sigItem, optOutValue), ...signature] =>
        let doc =
          switch (optOutValue) {
          | None => printOutSigItemDoc(sigItem)
          | Some(outValue) =>
            Doc.group(
              Doc.concat([
                printOutSigItemDoc(sigItem),
                Doc.text(" = "),
                printOutValueDoc(outValue),
              ]),
            )
          };

        loop(signature, [doc, ...acc]);
      };

    Doc.breakableGroup(
      ~forceBreak=true,
      Doc.join(~sep=Doc.line, loop(signature, [])),
    );
  };

  let printOutPhraseDoc = (outPhrase: Outcometree.out_phrase) =>
    switch (outPhrase) {
    | [@implicit_arity] Ophr_eval(outValue, outType) =>
      Doc.group(
        Doc.concat([
          Doc.text("- : "),
          printOutTypeDoc(outType),
          Doc.text(" ="),
          Doc.indent(Doc.concat([Doc.line, printOutValueDoc(outValue)])),
        ]),
      )
    | Ophr_signature([]) => Doc.nil
    | Ophr_signature(signature) => printOutPhraseSignature(signature)
    | [@implicit_arity] Ophr_exception(exc, outValue) =>
      printOutExceptionDoc(exc, outValue)
    };

  let printOutPhase = (fmt, outPhrase) =>
    Format.pp_print_string(
      fmt,
      Doc.toString(~width=80, printOutPhraseDoc(outPhrase)),
    );

  let printOutModuleType = (fmt, outModuleType) =>
    Format.pp_print_string(
      fmt,
      Doc.toString(~width=80, printOutModuleTypeDoc(outModuleType)),
    );

  let printOutTypeExtension = (fmt, typeExtension) =>
    Format.pp_print_string(
      fmt,
      Doc.toString(~width=80, printOutTypeExtensionDoc(typeExtension)),
    );

  let printOutValue = (fmt, outValue) =>
    Format.pp_print_string(
      fmt,
      Doc.toString(~width=80, printOutValueDoc(outValue)),
    );

  /* Not supported in Napkin */
  let printOutClassType = (_fmt, _) => ();

  let out_value = ref(printOutValue);
  let out_type = ref(printOutType);
  let out_module_type = ref(printOutModuleType);
  let out_sig_item = ref(printOutSigItem);
  let out_signature = ref(printOutSignature);
  let out_type_extension = ref(printOutTypeExtension);
  let out_phrase = [@live] ref(printOutPhase);
  let out_class_type = ref(printOutClassType);
};

module Repl = {
  let parseToplevelPhrase = filename => {
    let src = IO.readFile(filename);
    let p = Parser.make(src, filename);
    Parsetree.Ptop_def(NapkinScript.parseImplementation(p));
  };

  let typeAndPrintOutcome = filename => {
    Compmisc.init_path(false);
    let env = Compmisc.initial_env();
    try({
      let sstr =
        switch (parseToplevelPhrase(filename)) {
        | Parsetree.Ptop_def(sstr) => sstr
        | _ => assert(false)
        };

      let (_str, signature, _newenv) =
        Typemod.type_toplevel_phrase(env, sstr);
      let outSigItems = Printtyp.tree_of_signature(signature);
      let fmt = Format.str_formatter;
      OutcomePrinter.out_signature^(fmt, outSigItems);
      let result = Format.flush_str_formatter();
      print_string(result);
    }) {
    | [@implicit_arity] Typetexp.Error(_, _, err) =>
      let fmt = Format.str_formatter;
      Typetexp.report_error(env, fmt, err);
      let result = Format.flush_str_formatter();
      let () = print_endline(result);
      ();
    | _ => print_endline("catch all")
    };
  };
};

/* command line flags */
module Clflags: {
  let recover: ref(bool);
  let print: ref(string);
  let width: ref(int);
  let origin: ref(string);
  let files: ref(list(string));
  let interface: ref(bool);
  let report: ref(string);

  let parse: unit => unit;
  let outcome: ref(bool);
} = {
  let recover = ref(false);
  let width = ref(100);

  let files = ref([]);
  let addFilename = filename => files := [filename, ...files^];

  let print = ref("");
  let outcome = ref(false);
  let origin = ref("");
  let interface = ref(false);
  let report = ref("pretty");

  let usage = "Usage: napkinscript <options> <file>\nOptions are:";

  let spec = [
    ("-recover", Arg.Unit(() => recover := true), "Emit partial ast"),
    (
      "-print",
      Arg.String(txt => print := txt),
      "Print either binary, ocaml or ast",
    ),
    (
      "-parse",
      Arg.String(txt => origin := txt),
      "Parse ocaml or napkinscript",
    ),
    (
      "-outcome",
      Arg.Bool(printOutcomeTree => outcome := printOutcomeTree),
      "print outcometree",
    ),
    (
      "-width",
      Arg.Int(w => width := w),
      "Specify the line length that the printer will wrap on",
    ),
    ("-interface", Arg.Unit(() => interface := true), "Parse as interface"),
    (
      "-report",
      Arg.String(txt => report := txt),
      "Stylize errors and messages using color and context. Accepts `Pretty` and `Plain`. Default `Plain`",
    ),
  ];

  let parse = () => Arg.parse(spec, addFilename, usage);
};

module Driver: {
  let processFile:
    (
      ~isInterface: bool,
      ~width: int,
      ~recover: bool,
      ~origin: string,
      ~target: string,
      ~report: string,
      string
    ) =>
    unit;
} = {
  type file_kind('a) =
    | Structure: file_kind(Parsetree.structure)
    | Signature: file_kind(Parsetree.signature);

  let parseNapkin = (type a, kind: file_kind(a), p): a =>
    switch (kind) {
    | Structure => NapkinScript.parseImplementation(p)
    | Signature => NapkinScript.parseSpecification(p)
    };

  let extractOcamlStringData = filename => {
    let lexbuf =
      if (String.length(filename) > 0) {
        IO.readFile(filename) |> Lexing.from_string;
      } else {
        Lexing.from_channel(stdin);
      };

    let stringLocs = ref([]);
    let rec next = () => {
      let token = Lexer.token_with_comments(lexbuf);
      switch (token) {
      | [@implicit_arity] OcamlParser.STRING(_txt, None) =>
        open Location;
        let loc = {
          loc_start: lexbuf.lex_start_p,
          loc_end: lexbuf.Lexing.lex_curr_p,
          loc_ghost: false,
        };
        let len = loc.loc_end.pos_cnum - loc.loc_start.pos_cnum;
        let txt =
          Bytes.to_string(
            ([@doesNotRaise] Bytes.sub)(
              lexbuf.Lexing.lex_buffer,
              loc.loc_start.pos_cnum,
              len,
            ),
          );
        stringLocs := [(txt, loc), ...stringLocs^];
        next();
      | OcamlParser.EOF => ()
      | _ => next()
      };
    };

    next();
    List.rev(stringLocs^);
  };

  let parseOcaml = (type a, kind: file_kind(a), filename): a => {
    let lexbuf =
      if (String.length(filename) > 0) {
        IO.readFile(filename) |> Lexing.from_string;
      } else {
        Lexing.from_channel(stdin);
      };

    let stringData = extractOcamlStringData(filename);
    switch (kind) {
    | Structure =>
      Parse.implementation(lexbuf)
      |> ParsetreeCompatibility.replaceStringLiteralStructure(stringData)
      |> ParsetreeCompatibility.structure
    | Signature =>
      Parse.interface(lexbuf)
      |> ParsetreeCompatibility.replaceStringLiteralSignature(stringData)
      |> ParsetreeCompatibility.signature
    };
  };

  let parseNapkinFile = (~destination, kind, filename) => {
    let src =
      if (String.length(filename) > 0) {
        IO.readFile(filename);
      } else {
        IO.readStdin();
      };

    let p = {
      let mode =
        switch (destination) {
        | "napkinscript"
        | "ns"
        | "sexp" => Parser.Default
        | _ => Parser.ParseForTypeChecker
        };

      Parser.make(~mode, src, filename);
    };
    let ast = parseNapkin(kind, p);
    let report =
      switch (p.diagnostics) {
      | [] => None
      | diagnostics => Some(diagnostics)
      };

    (ast, report, p);
  };

  let parseOcamlFile = (kind, filename) => {
    let ast = parseOcaml(kind, filename);
    let lexbuf2 =
      if (String.length(filename) > 0) {
        IO.readFile(filename) |> Lexing.from_string;
      } else {
        Lexing.from_channel(stdin);
      };

    let comments = {
      let rec next = (prevTokEndPos: Lexing.position, comments, lb) => {
        let token = Lexer.token_with_comments(lb);
        switch (token) {
        | OcamlParser.EOF => comments
        | [@implicit_arity] OcamlParser.COMMENT(txt, loc) =>
          let comment = Comment.fromOcamlComment(~loc, ~prevTokEndPos, ~txt);

          next(loc.Location.loc_end, [comment, ...comments], lb);
        | _ => next(lb.Lexing.lex_curr_p, comments, lb)
        };
      };

      let cmts = next(lexbuf2.Lexing.lex_start_p, [], lexbuf2);
      cmts;
    };

    let p = Parser.make("", filename);
    p.comments = comments;
    (ast, None, p);
  };

  let reasonFilename = ref("");
  let commentData = ref([]);
  let stringData = ref([]);

  let parseReasonBinaryFromStdin = (type a, kind: file_kind(a), filename): a => {
    let (chan, close) =
      String.length(filename) === 0
        ? (stdin, _ => ())
        : {
          let file_chan = open_in_bin(filename);
          seek_in(file_chan, 0);
          (file_chan, close_in_noerr);
        };

    let ic = chan;
    let magic =
      switch (kind) {
      | Structure => Config.ast_impl_magic_number
      | Signature => Config.ast_intf_magic_number
      };

    let buffer =
      ([@doesNotRaise] really_input_string)(ic, String.length(magic));
    assert(buffer == magic);
    let filename = input_value(ic);
    reasonFilename := filename;
    let ast = input_value(ic);
    close(chan);

    let src =
      if (String.length(filename) > 0) {
        IO.readFile(filename);
      } else {
        IO.readStdin();
      };

    let scanner = Scanner.make(Bytes.of_string(src), filename);

    let rec next = (prevEndPos, scanner) => {
      let (startPos, endPos, token) = Scanner.scan(scanner);
      switch (token) {
      | Eof => ()
      | Comment(c) =>
        Comment.setPrevTokEndPos(c, prevEndPos);
        commentData := [c, ...commentData^];
        next(endPos, scanner);
      | String(_) =>
        let loc = {
          Location.loc_start: startPos,
          loc_end: endPos,
          loc_ghost: false,
        };
        let len = endPos.pos_cnum - startPos.pos_cnum;
        let txt = ([@doesNotRaise] String.sub)(src, startPos.pos_cnum, len);
        stringData := [(txt, loc), ...stringData^];
        next(endPos, scanner);
      | _ => next(endPos, scanner)
      };
    };

    next(Lexing.dummy_pos, scanner);

    switch (kind) {
    | Structure =>
      ast
      |> ParsetreeCompatibility.replaceStringLiteralStructure(stringData^)
      |> ParsetreeCompatibility.normalizeReasonArityStructure(
           ~forPrinter=true,
         )
      |> ParsetreeCompatibility.structure
    | Signature =>
      ast
      |> ParsetreeCompatibility.replaceStringLiteralSignature(stringData^)
      |> ParsetreeCompatibility.normalizeReasonAritySignature(
           ~forPrinter=true,
         )
      |> ParsetreeCompatibility.signature
    };
  };

  let isReasonDocComment = (comment: Comment.t) => {
    let content = Comment.txt(comment);
    let len = String.length(content);
    if (len == 0) {
      true;
    } else if (len >= 2
               && String.unsafe_get(content, 0) == '*'
               && String.unsafe_get(content, 1) == '*') {
      false;
    } else if (len >= 1 && String.unsafe_get(content, 0) == '*') {
      true;
    } else {
      false;
    };
  };

  let parseReasonBinary = (kind, filename) => {
    let ast = parseReasonBinaryFromStdin(kind, filename);
    let p = Parser.make("", reasonFilename^);
    p.comments = List.filter(c => !isReasonDocComment(c), commentData^);
    (ast, None, p);
  };

  let parseImplementation = (~origin, ~destination, filename) =>
    switch (origin) {
    | "ml"
    | "ocaml" => parseOcamlFile(Structure, filename)
    | "reasonBinary" => parseReasonBinary(Structure, filename)
    | _ => parseNapkinFile(~destination, Structure, filename)
    };

  let parseInterface = (~destination, ~origin, filename) =>
    switch (origin) {
    | "ml"
    | "ocaml" => parseOcamlFile(Signature, filename)
    | "reasonBinary" => parseReasonBinary(Signature, filename)
    | _ => parseNapkinFile(~destination, Signature, filename)
    };

  let process = (~reportStyle, parseFn, printFn, recover, filename) => {
    let (ast, report, parserState) = parseFn(filename);
    switch (report) {
    | Some(report) when recover == true =>
      printFn(ast, parserState);
      prerr_string(
        Diagnostics.stringOfReport(
          ~style=Diagnostics.parseReportStyle(reportStyle),
          report,
          Bytes.to_string(parserState.Parser.scanner.src),
        ),
      );
    | Some(report) =>
      prerr_string(
        Diagnostics.stringOfReport(
          ~style=Diagnostics.parseReportStyle(reportStyle),
          report,
          Bytes.to_string(parserState.Parser.scanner.src),
        ),
      );
      exit(1);
    | None => printFn(ast, parserState)
    };
  };

  type action =
    | ProcessImplementation
    | ProcessInterface;

  let printImplementation = (~target, ~width, filename, ast, _parserState) =>
    switch (target) {
    | "ml"
    | "ocaml" => Pprintast.structure(Format.std_formatter, ast)
    | "ns"
    | "napkinscript" =>
      Printer.printImplementation(
        ~width,
        ast,
        List.rev(_parserState.Parser.comments),
      )
    | "ast" => Printast.implementation(Format.std_formatter, ast)
    | "sexp" => ast |> SexpAst.implementation |> Sexp.toString |> print_string
    | _ =>
      /* default binary */
      output_string(stdout, Config.ast_impl_magic_number);
      output_value(stdout, filename);
      output_value(stdout, ast);
    };

  let printInterface = (~target, ~width, filename, ast, _parserState) =>
    switch (target) {
    | "ml"
    | "ocaml" => Pprintast.signature(Format.std_formatter, ast)
    | "ns"
    | "napkinscript" =>
      Printer.printInterface(
        ~width,
        ast,
        List.rev(_parserState.Parser.comments),
      )
    | "ast" => Printast.interface(Format.std_formatter, ast)
    | "sexp" => ast |> SexpAst.interface |> Sexp.toString |> print_string
    | _ =>
      /* default binary */
      output_string(stdout, Config.ast_intf_magic_number);
      output_value(stdout, filename);
      output_value(stdout, ast);
    };

  let processFile =
      (~isInterface, ~width, ~recover, ~origin, ~target, ~report, filename) =>
    try({
      let len = String.length(filename);
      let action =
        if (isInterface || len > 0 && filename.[len - 1] == 'i') {
          ProcessInterface;
        } else {
          ProcessImplementation;
        };

      switch (action) {
      | ProcessImplementation =>
        process(
          ~reportStyle=report,
          parseImplementation(~origin, ~destination=target),
          printImplementation(~target, ~width, filename),
          recover,
          filename,
        )
      | ProcessInterface =>
        process(
          ~reportStyle=report,
          parseInterface(~origin, ~destination=target),
          printInterface(~target, ~width, filename),
          recover,
          filename,
        )
      };
    }) {
    | Failure(txt) =>
      prerr_string(txt);
      prerr_newline();
      exit(1);
    | _ => exit(1)
    };
};

let () = {
  Clflags.parse();
  if (Clflags.outcome^) {
    Repl.typeAndPrintOutcome(List.hd(Clflags.files^));
  } else {
    let () =
      switch (Clflags.files^) {
      | [_file, ..._] as files =>
        List.iter(
          filename =>
            Driver.processFile(
              ~isInterface=Clflags.interface^,
              ~width=Clflags.width^,
              ~recover=Clflags.recover^,
              ~target=Clflags.print^,
              ~origin=Clflags.origin^,
              ~report=Clflags.report^,
              filename,
            ),
          files,
        )
      | [] =>
        Driver.processFile(
          ~isInterface=Clflags.interface^,
          ~width=Clflags.width^,
          ~recover=Clflags.recover^,
          ~target=Clflags.print^,
          ~origin=Clflags.origin^,
          ~report=Clflags.report^,
          "",
        )
      };

    exit(0);
  };
};