Comment_attachment (melange.Js_parser.Comment

module Ast = Flow_ast;

let id: ('a => 'a) => 'a => 'b => ('a => 'b) => 'b;

let map_loc: ('a => 'b => 'b) => ('a, 'b) => ('a, 'b);

let map_opt: ('a => 'a) => option('a) => option('a);

let id_list_last: ('a => 'a) => list('a) => list('a);

class (+'a) trailing_comments_remover: after_pos:Loc.position => { ... }

type trailing_and_remover_result = {

trailing: list(Flow_ast.Comment.t(Loc.t)),
remove_trailing: 'a. 'a => (trailing_comments_remover(Loc.t) => 'a => 'a) => 'a,

};

let trailing_and_remover_after_last_loc: 
  Parser_env.env =>
  trailing_and_remover_result;

let trailing_and_remover_after_last_line: 
  Parser_env.env =>
  trailing_and_remover_result;

let trailing_and_remover: Parser_env.env => trailing_and_remover_result;

let id_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Identifier.t(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Identifier.t(Loc.t, Loc.t);

let expression_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Expression.t(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Expression.t(Loc.t, Loc.t);

let block_remove_trailing: 
  Parser_env.env =>
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Statement.Block.t(Loc.t, Loc.t)) =>
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Statement.Block.t(Loc.t, Loc.t));

let type_params_remove_trailing: 
  Parser_env.env =>
  option(Js_parser.Flow_ast_mapper.Ast.Type.TypeParams.t(Loc.t, Loc.t)) =>
  option(Js_parser.Flow_ast_mapper.Ast.Type.TypeParams.t(Loc.t, Loc.t));

let type_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Type.t(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Type.t(Loc.t, Loc.t);

let type_annotation_hint_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Type.annotation_or_hint(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Type.annotation_or_hint(Loc.t, Loc.t);

let component_renders_annotation_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Type.component_renders_annotation(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Type.component_renders_annotation(Loc.t, Loc.t);

let return_annotation_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Function.ReturnAnnot.t(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Function.ReturnAnnot.t(Loc.t, Loc.t);

let function_params_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Function.Params.t(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Function.Params.t(Loc.t, Loc.t);

let component_params_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Statement.ComponentDeclaration.Params.t
    (Loc.t,
      Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Statement.ComponentDeclaration.Params.t
    (Loc.t,
      Loc.t);

let component_type_params_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Type.Component.Params.t(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Type.Component.Params.t(Loc.t, Loc.t);

let predicate_remove_trailing: 
  Parser_env.env =>
  option(Js_parser.Flow_ast_mapper.Ast.Type.Predicate.t(Loc.t, Loc.t)) =>
  option(Js_parser.Flow_ast_mapper.Ast.Type.Predicate.t(Loc.t, Loc.t));

let object_key_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Expression.Object.Property.key(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Expression.Object.Property.key(Loc.t, Loc.t);

let generic_type_remove_trailing: 
  Parser_env.env =>
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.Generic.t(Loc.t, Loc.t)) =>
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.Generic.t(Loc.t, Loc.t));

let generic_type_list_remove_trailing: 
  Parser_env.env =>
  list((Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.Generic.t(Loc.t, Loc.t))) =>
  list((Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.Generic.t(Loc.t, Loc.t)));

let class_implements_remove_trailing: 
  Parser_env.env =>
  Js_parser.Flow_ast_mapper.Ast.Class.Implements.t(Loc.t, Loc.t) =>
  Js_parser.Flow_ast_mapper.Ast.Class.Implements.t(Loc.t, Loc.t);

let string_literal_remove_trailing: 
  Parser_env.env =>
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.StringLiteral.t(Loc.t)) =>
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.StringLiteral.t(Loc.t));

let statement_add_comments: 
  Flow_ast.Statement.t(Loc.t, Loc.t) =>
  option(Flow_ast.Syntax.t(Loc.t, unit)) =>
  Flow_ast.Statement.t(Loc.t, Loc.t);

class (+'a) comment_bounds_collector: loc:Loc.t => { ... }

let comment_bounds: 
  Loc.t =>
  'a =>
  (comment_bounds_collector(Loc.t) => 'a => 'b) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Js_parser__Flow_ast.Comment.t')));

let expand_loc_with_comment_bounds: 
  Loc.t =>
  (option((Loc.t, 'a)), option((Loc.t, 'b))) =>
  Loc.t;

let comment_bounds_without_trailing_line_comment: 
  ('a, option(('b, Ast.Comment.t'))) =>
  ('a, option(('b, Ast.Comment.t')));

let collect_without_trailing_line_comment: 
  {.. comment_bounds: ('a, option(('b, Ast.Comment.t')))} =>
  ('a, option(('b, Ast.Comment.t')));

let statement_comment_bounds: 
  Flow_ast.Statement.t(Loc.t, Loc.t) =>
  (option(Flow_ast.Comment.t(Loc.t)), option(Flow_ast.Comment.t(Loc.t)));

let expression_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Expression.t'(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Js_parser__Flow_ast.Comment.t')));

let type_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.t'(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Js_parser__Flow_ast.Comment.t')));

let block_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Statement.Block.t(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Js_parser__Flow_ast.Comment.t')));

let object_property_comment_bounds: 
  Ast.Expression.Object.property(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let object_type_property_comment_bounds: 
  Ast.Type.Object.property(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let object_pattern_property_comment_bounds: 
  Loc.t =>
  Js_parser.Flow_ast_mapper.Ast.Pattern.Object.property(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let switch_case_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Statement.Switch.Case.t'(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Js_parser__Flow_ast.Comment.t')));

let function_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Function.Param.t'(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let function_rest_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Function.RestParam.t'(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let function_this_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Function.ThisParam.t'(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let function_type_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.Function.Param.t'(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let function_type_rest_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.Function.RestParam.t'(Loc.t,
                                                                    Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let function_type_this_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.Function.ThisParam.t'(Loc.t,
                                                                    Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let component_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Statement.ComponentDeclaration.Param.t'
            (Loc.t,
              Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let component_rest_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Statement.ComponentDeclaration.RestParam.t'
            (Loc.t,
              Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let component_type_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.Component.Param.t'(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let component_type_rest_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.Component.RestParam.t'(Loc.t,
                                                                    Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let array_element_comment_bounds: 
  Loc.t =>
  Js_parser.Flow_ast_mapper.Ast.Expression.Array.element(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let array_pattern_element_comment_bounds: 
  Loc.t =>
  Js_parser.Flow_ast_mapper.Ast.Pattern.Array.element(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let expression_or_spread_comment_bounds: 
  Loc.t =>
  Js_parser.Flow_ast_mapper.Ast.Expression.expression_or_spread(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let call_type_arg_comment_bounds: 
  Loc.t =>
  Js_parser.Flow_ast_mapper.Ast.Expression.CallTypeArg.t(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let type_param_comment_bounds: 
  (Loc.t, Js_parser.Flow_ast_mapper.Ast.Type.TypeParam.t'(Loc.t, Loc.t)) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Ast.Comment.t')));

let function_body_comment_bounds: 
  Ast.Function.body(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Js_parser__Flow_ast.Comment.t')));

let if_alternate_statement_comment_bounds: 
  Loc.t =>
  Js_parser.Flow_ast_mapper.Ast.Statement.If.Alternate.t'(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Js_parser__Flow_ast.Comment.t')));

let member_property_comment_bounds: 
  Loc.t =>
  Js_parser.Flow_ast_mapper.Ast.Expression.Member.property(Loc.t, Loc.t) =>
  (option((Loc.t, Js_parser__Flow_ast.Comment.t')), option((Loc.t, Js_parser__Flow_ast.Comment.t')));