Flow_ast_utils (melange.Js_parser.Flow_ast

type binding('loc) = ('loc, string);

type ident('loc) = ('loc, string);

type source('loc) = ('loc, string);

let fold_bindings_of_pattern: 
  ('a => Flow_ast.Identifier.t('m, 't) => 'a) =>
  'a =>
  Flow_ast.Pattern.t('m, 't) =>
  'a;

let fold_bindings_of_variable_declarations: 
  (bool => 'a => Flow_ast.Identifier.t('m, 't) => 'a) =>
  'a =>
  list(Flow_ast.Statement.VariableDeclaration.Declarator.t('m, 't)) =>
  'a;

let pattern_has_binding: Flow_ast.Pattern.t('m, 't) => bool;

let match_pattern_has_binding: Flow_ast.MatchPattern.t('m, 't) => bool;

let string_of_variable_kind: Flow_ast.Variable.kind => string;

let partition_directives: 
  list(Flow_ast.Statement.t(Loc.t, Loc.t)) =>
  (list(Flow_ast.Statement.t(Loc.t, Loc.t)), list(Flow_ast.Statement.t
                                                    (Loc.t,
                                                      Loc.t)));

let hoist_function_and_component_declarations: 
  list(Flow_ast.Statement.t('a, 'b)) =>
  list(Flow_ast.Statement.t('a, 'b));

let is_call_to_invariant: Flow_ast.Expression.t('a, 'b) => bool;

let is_call_to_require: Flow_ast.Expression.t('a, 'b) => bool;

let is_call_to_is_array: Flow_ast.Expression.t('a, 'b) => bool;

let is_call_to_object_dot_freeze: Flow_ast.Expression.t('a, 'b) => bool;

let get_call_to_object_dot_freeze_arg: 
  Flow_ast.Expression.t('a, 'b) =>
  option(Flow_ast.Expression.CallTypeArgs.t('a, 'b)) =>
  Flow_ast.Expression.ArgList.t('a, 'b) =>
  option(('b, Flow_ast.Expression.Object.t('a, 'b)));

let is_call_to_object_static_method: Flow_ast.Expression.t('a, 'b) => bool;

let is_module_dot_exports: Flow_ast.Expression.t('a, 'b) => bool;

let get_call_to_jest_module_mocking_fn: 
  Flow_ast.Expression.t('loc, 'annot) =>
  Flow_ast.Expression.ArgList.t('loc, 'annot) =>
  option(('annot, 'annot, string));

let is_super_member_access: Flow_ast.Expression.Member.t('a, 'b) => bool;

let acceptable_statement_in_declaration_context: 
  in_declare_namespace:bool =>
  Flow_ast.Statement.t'('a, 'b) =>
  result(unit, string);

let is_type_only_declaration_statement: Flow_ast.Statement.t('a, 'b) => bool;

let negate_number_literal: (float, string) => (float, string);

let negate_bigint_literal: (option(int64), string) => (option(int64), string);

let is_number_literal: Flow_ast.Expression.t'('a, 'b) => bool;

let extract_number_literal: 
  Flow_ast.Expression.t'('a, 'b) =>
  option((float, string));

let is_bigint_literal: Flow_ast.Expression.t'('a, 'b) => bool;

let extract_bigint_literal: 
  Flow_ast.Expression.t'('a, 'b) =>
  option((option(int64), string));

let loc_of_expression: Flow_ast.Expression.t('a, 'a) => 'a;

let loc_of_statement: Flow_ast.Statement.t('a, 'a) => 'a;

let loc_of_pattern: Flow_ast.Pattern.t('a, 'a) => 'a;

let loc_of_ident: Flow_ast.Identifier.t('a, 'a) => 'a;

let name_of_ident: Flow_ast.Identifier.t('loc, 'a) => string;

let source_of_ident: Flow_ast.Identifier.t('a, 'a) => source('a);

let ident_of_source: 
  ?comments:Flow_ast.Syntax.t('a, unit) =>
  source('a) =>
  Flow_ast.Identifier.t('a, 'a);

let mk_comments: 
  ?leading:list(Flow_ast.Comment.t('loc)) =>
  ?trailing:list(Flow_ast.Comment.t('loc)) =>
  'a =>
  Flow_ast.Syntax.t('loc, 'a);

let mk_comments_opt: 
  ?leading:list(Flow_ast.Comment.t('loc)) =>
  ?trailing:list(Flow_ast.Comment.t('loc)) =>
  unit =>
  option(Flow_ast.Syntax.t('loc, unit));

let mk_comments_with_internal_opt: 
  ?leading:list(Flow_ast.Comment.t('loc)) =>
  ?trailing:list(Flow_ast.Comment.t('loc)) =>
  internal:list(Flow_ast.Comment.t('loc)) =>
  unit =>
  option(Flow_ast.Syntax.t('loc, list(Flow_ast.Comment.t('loc))));

let merge_comments: 
  inner:option(Flow_ast.Syntax.t('M, unit)) =>
  outer:option(Flow_ast.Syntax.t('M, unit)) =>
  option(Flow_ast.Syntax.t('M, unit));

let merge_comments_with_internal: 
  inner:option(Flow_ast.Syntax.t('M, list(Flow_ast.Comment.t('loc)))) =>
  outer:option(Flow_ast.Syntax.t('M, 'a)) =>
  option(Flow_ast.Syntax.t('M, list(Flow_ast.Comment.t('loc))));

let split_comments: 
  option(Flow_ast.Syntax.t('loc, unit)) =>
  (option(Flow_ast.Syntax.t('loc, unit)), option(Flow_ast.Syntax.t('loc, unit)));

module ExpressionSort: { ... };

let string_of_assignment_operator: 
  Flow_ast.Expression.Assignment.operator =>
  string;

let string_of_binary_operator: Flow_ast.Expression.Binary.operator => string;

let loc_of_annotation_or_hint: 
  Flow_ast.Type.annotation_or_hint('loc, 'loc) =>
  'loc;

let loc_of_return_annot: Flow_ast.Function.ReturnAnnot.t('loc, 'loc) => 'loc;

let push_toplevel_type: 
  't =>
  Flow_ast.Expression.t('loc, ('loc, 't)) =>
  Flow_ast.Expression.t('loc, ('loc, 't));

let hook_function: Flow_ast.Function.t('a, 'b) => option('b);

let hook_call: Flow_ast.Expression.Call.t('a, 'b) => bool;

let hook_name: string => bool;

let match_root_name: string;

let match_root_ident: 'loc => Flow_ast.Identifier.t('loc, 'loc);

let expression_of_match_member_pattern: 
  visit_expression:(Flow_ast.Expression.t('loc, 'loc) => unit) =>
  Flow_ast.MatchPattern.MemberPattern.t('loc, 'loc) =>
  (Flow_ast.Expression.t('loc, 'loc), Flow_ast.Identifier.t('loc, 'loc));

let get_inferred_type_guard_candidate: 
  Flow_ast.Function.Params.t('l, 't) =>
  Flow_ast.Function.body('l, 't) =>
  Flow_ast.Function.ReturnAnnot.t('l, 't) =>
  option(('t, string));

let unwrap_nonnull_lhs_expr: 
  'loc 'tloc. Flow_ast.Expression.t('loc, 'loc) =>
  (Flow_ast.Expression.t('loc, 'loc), bool, (Flow_ast.Expression.t('loc, 'tloc) =>
   filter_nullish:('loc => 'tloc) =>
   Flow_ast.Expression.t('loc, 'tloc)));

let unwrap_nonnull_lhs: 
  'loc 'tloc. Flow_ast.Pattern.t('loc, 'tloc) =>
  (Flow_ast.Pattern.t('loc, 'tloc), bool);