%% 
%% Search data file for syntax_tools 2.1
%% generated September 20, 2016
%% 
{"epp_dodger.html", {function, {"syntax_tools", "epp_dodger"}},
[
  {"parse", "parse(Dev::IODevice)", "parse-1"},
  {"parse", "parse(Dev::IODevice, L::StartLine)", "parse-2"},
  {"parse", "parse(Dev::IODevice, L0::StartLine, Options)", "parse-3"},
  {"parse_file", "parse_file(File)", "parse_file-1"},
  {"parse_file", "parse_file(File, Options)", "parse_file-2"},
  {"parse_form", "parse_form(Dev::IODevice, L0::StartLine)", "parse_form-2"},
  {"parse_form", "parse_form(Dev::IODevice, L0::StartLine, Options)", "parse_form-3"},
  {"quick_parse", "quick_parse(Dev::IODevice)", "quick_parse-1"},
  {"quick_parse", "quick_parse(Dev::IODevice, L::StartLine)", "quick_parse-2"},
  {"quick_parse", "quick_parse(Dev::IODevice, L0::StartLine, Options)", "quick_parse-3"},
  {"quick_parse_file", "quick_parse_file(File)", "quick_parse_file-1"},
  {"quick_parse_file", "quick_parse_file(File, Options)", "quick_parse_file-2"},
  {"quick_parse_form", "quick_parse_form(Dev::IODevice, L0::StartLine)", "quick_parse_form-2"},
  {"quick_parse_form", "quick_parse_form(Dev::IODevice, L0::StartLine, Options)", "quick_parse_form-3"},
  {"tokens_to_string", "tokens_to_string(Tokens::[term()])", "tokens_to_string-1"}
]}.
{"epp_dodger.html", {module, "syntax_tools"}, ["epp_dodger"]}.
{"erl_comment_scan.html", {function, {"syntax_tools", "erl_comment_scan"}},
[
  {"file", "file(FileName::file:filename())", "file-1"},
  {"join_lines", "join_lines(Lines::[CommentLine])", "join_lines-1"},
  {"scan_lines", "scan_lines(Text::string())", "scan_lines-1"},
  {"string", "string(Text::string())", "string-1"}
]}.
{"erl_comment_scan.html", {module, "syntax_tools"}, ["erl_comment_scan"]}.
{"erl_prettypr.html", {function, {"syntax_tools", "erl_prettypr"}},
[
  {"best", "best(Tree::syntaxTree())", "best-1"},
  {"best", "best(Tree::syntaxTree(), Options::[term()])", "best-2"},
  {"format", "format(Tree::syntaxTree())", "format-1"},
  {"format", "format(Tree::syntaxTree(), Options::[term()])", "format-2"},
  {"get_ctxt_hook", "get_ctxt_hook(Ctxt::context())", "get_ctxt_hook-1"},
  {"get_ctxt_linewidth", "get_ctxt_linewidth(Ctxt::context())", "get_ctxt_linewidth-1"},
  {"get_ctxt_paperwidth", "get_ctxt_paperwidth(Ctxt::context())", "get_ctxt_paperwidth-1"},
  {"get_ctxt_precedence", "get_ctxt_precedence(Ctxt::context())", "get_ctxt_precedence-1"},
  {"get_ctxt_user", "get_ctxt_user(Ctxt::context())", "get_ctxt_user-1"},
  {"layout", "layout(Tree::syntaxTree())", "layout-1"},
  {"layout", "layout(Tree::syntaxTree(), Options::[term()])", "layout-2"},
  {"set_ctxt_hook", "set_ctxt_hook(Ctxt::context(), Hook::hook())", "set_ctxt_hook-2"},
  {"set_ctxt_linewidth", "set_ctxt_linewidth(Ctxt::context(), W::integer())", "set_ctxt_linewidth-2"},
  {"set_ctxt_paperwidth", "set_ctxt_paperwidth(Ctxt::context(), W::integer())", "set_ctxt_paperwidth-2"},
  {"set_ctxt_precedence", "set_ctxt_precedence(Ctxt::context(), Prec::integer())", "set_ctxt_precedence-2"},
  {"set_ctxt_user", "set_ctxt_user(Ctxt::context(), X::term())", "set_ctxt_user-2"}
]}.
{"erl_prettypr.html", {module, "syntax_tools"}, ["erl_prettypr"]}.
{"erl_recomment.html", {function, {"syntax_tools", "erl_recomment"}},
[
  {"quick_recomment_forms", "quick_recomment_forms(Tree::Forms, Comments::[Comment])", "quick_recomment_forms-2"},
  {"recomment_forms", "recomment_forms(Tree::Forms, Comments::[Comment])", "recomment_forms-2"},
  {"recomment_tree", "recomment_tree(Tree::syntaxTree(), Comments::[Comment])", "recomment_tree-2"}
]}.
{"erl_recomment.html", {module, "syntax_tools"}, ["erl_recomment"]}.
{"erl_syntax.html", {function, {"syntax_tools", "erl_syntax"}},
[
  {"abstract", "abstract(T::term())", "abstract-1"},
  {"add_ann", "add_ann(A::term(), Node::syntaxTree())", "add_ann-2"},
  {"add_postcomments", "add_postcomments(Cs::[syntaxTree()], Node::syntaxTree())", "add_postcomments-2"},
  {"add_precomments", "add_precomments(Cs::[syntaxTree()], Node::syntaxTree())", "add_precomments-2"},
  {"annotated_type", "annotated_type(Name::syntaxTree(), Type::syntaxTree())", "annotated_type-2"},
  {"annotated_type_body", "annotated_type_body(Node::syntaxTree())", "annotated_type_body-1"},
  {"annotated_type_name", "annotated_type_name(Node::syntaxTree())", "annotated_type_name-1"},
  {"application", "application(Operator::syntaxTree(), Arguments::[syntaxTree()])", "application-2"},
  {"application", "application(Module::none | syntaxTree(), Name::syntaxTree(), Arguments::[syntaxTree()])", "application-3"},
  {"application_arguments", "application_arguments(Node::syntaxTree())", "application_arguments-1"},
  {"application_operator", "application_operator(Node::syntaxTree())", "application_operator-1"},
  {"arity_qualifier", "arity_qualifier(Body::syntaxTree(), Arity::syntaxTree())", "arity_qualifier-2"},
  {"arity_qualifier_argument", "arity_qualifier_argument(Node::syntaxTree())", "arity_qualifier_argument-1"},
  {"arity_qualifier_body", "arity_qualifier_body(Node::syntaxTree())", "arity_qualifier_body-1"},
  {"atom", "atom(Name::atom() | string())", "atom-1"},
  {"atom_literal", "atom_literal(Node::syntaxTree())", "atom_literal-1"},
  {"atom_name", "atom_name(Node::syntaxTree())", "atom_name-1"},
  {"atom_value", "atom_value(Node::syntaxTree())", "atom_value-1"},
  {"attribute", "attribute(Name::syntaxTree())", "attribute-1"},
  {"attribute", "attribute(Name::syntaxTree(), Args::none | [syntaxTree()])", "attribute-2"},
  {"attribute_arguments", "attribute_arguments(Node::syntaxTree())", "attribute_arguments-1"},
  {"attribute_name", "attribute_name(Node::syntaxTree())", "attribute_name-1"},
  {"binary", "binary(List::[syntaxTree()])", "binary-1"},
  {"binary_comp", "binary_comp(Template::syntaxTree(), Body::[syntaxTree()])", "binary_comp-2"},
  {"binary_comp_body", "binary_comp_body(Node::syntaxTree())", "binary_comp_body-1"},
  {"binary_comp_template", "binary_comp_template(Node::syntaxTree())", "binary_comp_template-1"},
  {"binary_field", "binary_field(Body::syntaxTree())", "binary_field-1"},
  {"binary_field", "binary_field(Body::syntaxTree(), Types::[syntaxTree()])", "binary_field-2"},
  {"binary_field", "binary_field(Body::syntaxTree(), Size::none | syntaxTree(), Types::[syntaxTree()])", "binary_field-3"},
  {"binary_field_body", "binary_field_body(Node::syntaxTree())", "binary_field_body-1"},
  {"binary_field_size", "binary_field_size(Node::syntaxTree())", "binary_field_size-1"},
  {"binary_field_types", "binary_field_types(Node::syntaxTree())", "binary_field_types-1"},
  {"binary_fields", "binary_fields(Node::syntaxTree())", "binary_fields-1"},
  {"binary_generator", "binary_generator(Pattern::syntaxTree(), Body::syntaxTree())", "binary_generator-2"},
  {"binary_generator_body", "binary_generator_body(Node::syntaxTree())", "binary_generator_body-1"},
  {"binary_generator_pattern", "binary_generator_pattern(Node::syntaxTree())", "binary_generator_pattern-1"},
  {"bitstring_type", "bitstring_type(M::syntaxTree(), N::syntaxTree())", "bitstring_type-2"},
  {"bitstring_type_m", "bitstring_type_m(Node::syntaxTree())", "bitstring_type_m-1"},
  {"bitstring_type_n", "bitstring_type_n(Node::syntaxTree())", "bitstring_type_n-1"},
  {"block_expr", "block_expr(Body::[syntaxTree()])", "block_expr-1"},
  {"block_expr_body", "block_expr_body(Node::syntaxTree())", "block_expr_body-1"},
  {"case_expr", "case_expr(Argument::syntaxTree(), Clauses::[syntaxTree()])", "case_expr-2"},
  {"case_expr_argument", "case_expr_argument(Node::syntaxTree())", "case_expr_argument-1"},
  {"case_expr_clauses", "case_expr_clauses(Node::syntaxTree())", "case_expr_clauses-1"},
  {"catch_expr", "catch_expr(Expr::syntaxTree())", "catch_expr-1"},
  {"catch_expr_body", "catch_expr_body(Node::syntaxTree())", "catch_expr_body-1"},
  {"char", "char(Char::char())", "char-1"},
  {"char_literal", "char_literal(Node::syntaxTree())", "char_literal-1"},
  {"char_literal", "char_literal(Node::syntaxTree(), X2::encoding())", "char_literal-2"},
  {"char_value", "char_value(Node::syntaxTree())", "char_value-1"},
  {"class_qualifier", "class_qualifier(Class::syntaxTree(), Body::syntaxTree())", "class_qualifier-2"},
  {"class_qualifier_argument", "class_qualifier_argument(Node::syntaxTree())", "class_qualifier_argument-1"},
  {"class_qualifier_body", "class_qualifier_body(Node::syntaxTree())", "class_qualifier_body-1"},
  {"clause", "clause(Guard::guard(), Body::[syntaxTree()])", "clause-2"},
  {"clause", "clause(Patterns::[syntaxTree()], Guard::guard(), Body::[syntaxTree()])", "clause-3"},
  {"clause_body", "clause_body(Node::syntaxTree())", "clause_body-1"},
  {"clause_guard", "clause_guard(Node::syntaxTree())", "clause_guard-1"},
  {"clause_patterns", "clause_patterns(Node::syntaxTree())", "clause_patterns-1"},
  {"comment", "comment(Strings::[string()])", "comment-1"},
  {"comment", "comment(Pad::padding(), Strings::[string()])", "comment-2"},
  {"comment_padding", "comment_padding(Node::syntaxTree())", "comment_padding-1"},
  {"comment_text", "comment_text(Node::syntaxTree())", "comment_text-1"},
  {"compact_list", "compact_list(Node::syntaxTree())", "compact_list-1"},
  {"concrete", "concrete(Node::syntaxTree())", "concrete-1"},
  {"cond_expr", "cond_expr(Clauses::[syntaxTree()])", "cond_expr-1"},
  {"cond_expr_clauses", "cond_expr_clauses(Node::syntaxTree())", "cond_expr_clauses-1"},
  {"conjunction", "conjunction(Tests::[syntaxTree()])", "conjunction-1"},
  {"conjunction_body", "conjunction_body(Node::syntaxTree())", "conjunction_body-1"},
  {"cons", "cons(Head::syntaxTree(), Tail::syntaxTree())", "cons-2"},
  {"constrained_function_type", "constrained_function_type(FunctionType::syntaxTree(), FunctionConstraint::[syntaxTree()])", "constrained_function_type-2"},
  {"constrained_function_type_argument", "constrained_function_type_argument(Node::syntaxTree())", "constrained_function_type_argument-1"},
  {"constrained_function_type_body", "constrained_function_type_body(Node::syntaxTree())", "constrained_function_type_body-1"},
  {"constraint", "constraint(Name::syntaxTree(), Types::[syntaxTree()])", "constraint-2"},
  {"constraint_argument", "constraint_argument(Node::syntaxTree())", "constraint_argument-1"},
  {"constraint_body", "constraint_body(Node::syntaxTree())", "constraint_body-1"},
  {"copy_ann", "copy_ann(Source::syntaxTree(), Target::syntaxTree())", "copy_ann-2"},
  {"copy_attrs", "copy_attrs(S::syntaxTree(), T::syntaxTree())", "copy_attrs-2"},
  {"copy_comments", "copy_comments(Source::syntaxTree(), Target::syntaxTree())", "copy_comments-2"},
  {"copy_pos", "copy_pos(Source::syntaxTree(), Target::syntaxTree())", "copy_pos-2"},
  {"data", "data(Tree::syntaxTree())", "data-1"},
  {"disjunction", "disjunction(Tests::[syntaxTree()])", "disjunction-1"},
  {"disjunction_body", "disjunction_body(Node::syntaxTree())", "disjunction_body-1"},
  {"eof_marker", "eof_marker()", "eof_marker-0"},
  {"error_marker", "error_marker(Error::term())", "error_marker-1"},
  {"error_marker_info", "error_marker_info(Node::syntaxTree())", "error_marker_info-1"},
  {"flatten_form_list", "flatten_form_list(Node::syntaxTree())", "flatten_form_list-1"},
  {"float", "float(Value::float())", "float-1"},
  {"float_literal", "float_literal(Node::syntaxTree())", "float_literal-1"},
  {"float_value", "float_value(Node::syntaxTree())", "float_value-1"},
  {"form_list", "form_list(Forms::[syntaxTree()])", "form_list-1"},
  {"form_list_elements", "form_list_elements(Node::syntaxTree())", "form_list_elements-1"},
  {"fun_expr", "fun_expr(Clauses::[syntaxTree()])", "fun_expr-1"},
  {"fun_expr_arity", "fun_expr_arity(Node::syntaxTree())", "fun_expr_arity-1"},
  {"fun_expr_clauses", "fun_expr_clauses(Node::syntaxTree())", "fun_expr_clauses-1"},
  {"fun_type", "fun_type()", "fun_type-0"},
  {"function", "function(Name::syntaxTree(), Clauses::[syntaxTree()])", "function-2"},
  {"function_arity", "function_arity(Node::syntaxTree())", "function_arity-1"},
  {"function_clauses", "function_clauses(Node::syntaxTree())", "function_clauses-1"},
  {"function_name", "function_name(Node::syntaxTree())", "function_name-1"},
  {"function_type", "function_type(Type)", "function_type-1"},
  {"function_type", "function_type(Arguments::any_arity | syntaxTree(), Return::syntaxTree())", "function_type-2"},
  {"function_type_arguments", "function_type_arguments(Node::syntaxTree())", "function_type_arguments-1"},
  {"function_type_return", "function_type_return(Node::syntaxTree())", "function_type_return-1"},
  {"generator", "generator(Pattern::syntaxTree(), Body::syntaxTree())", "generator-2"},
  {"generator_body", "generator_body(Node::syntaxTree())", "generator_body-1"},
  {"generator_pattern", "generator_pattern(Node::syntaxTree())", "generator_pattern-1"},
  {"get_ann", "get_ann(Tree::syntaxTree())", "get_ann-1"},
  {"get_attrs", "get_attrs(Tree::syntaxTree())", "get_attrs-1"},
  {"get_pos", "get_pos(Tree::syntaxTree())", "get_pos-1"},
  {"get_postcomments", "get_postcomments(Tree::syntaxTree())", "get_postcomments-1"},
  {"get_precomments", "get_precomments(Tree::syntaxTree())", "get_precomments-1"},
  {"has_comments", "has_comments(Tree::syntaxTree())", "has_comments-1"},
  {"if_expr", "if_expr(Clauses::[syntaxTree()])", "if_expr-1"},
  {"if_expr_clauses", "if_expr_clauses(Node::syntaxTree())", "if_expr_clauses-1"},
  {"implicit_fun", "implicit_fun(Name::syntaxTree())", "implicit_fun-1"},
  {"implicit_fun", "implicit_fun(Name::syntaxTree(), Arity::none | syntaxTree())", "implicit_fun-2"},
  {"implicit_fun", "implicit_fun(Module::none | syntaxTree(), Name::syntaxTree(), Arity::syntaxTree())", "implicit_fun-3"},
  {"implicit_fun_name", "implicit_fun_name(Node::syntaxTree())", "implicit_fun_name-1"},
  {"infix_expr", "infix_expr(Left::syntaxTree(), Operator::syntaxTree(), Right::syntaxTree())", "infix_expr-3"},
  {"infix_expr_left", "infix_expr_left(Node::syntaxTree())", "infix_expr_left-1"},
  {"infix_expr_operator", "infix_expr_operator(Node::syntaxTree())", "infix_expr_operator-1"},
  {"infix_expr_right", "infix_expr_right(Node::syntaxTree())", "infix_expr_right-1"},
  {"integer", "integer(Value::integer())", "integer-1"},
  {"integer_literal", "integer_literal(Node::syntaxTree())", "integer_literal-1"},
  {"integer_range_type", "integer_range_type(Low::syntaxTree(), High::syntaxTree())", "integer_range_type-2"},
  {"integer_range_type_high", "integer_range_type_high(Node::syntaxTree())", "integer_range_type_high-1"},
  {"integer_range_type_low", "integer_range_type_low(Node::syntaxTree())", "integer_range_type_low-1"},
  {"integer_value", "integer_value(Node::syntaxTree())", "integer_value-1"},
  {"is_atom", "is_atom(Node::syntaxTree(), Value::atom())", "is_atom-2"},
  {"is_char", "is_char(Node::syntaxTree(), Value::char())", "is_char-2"},
  {"is_form", "is_form(Node::syntaxTree())", "is_form-1"},
  {"is_integer", "is_integer(Node::syntaxTree(), Value::integer())", "is_integer-2"},
  {"is_leaf", "is_leaf(Node::syntaxTree())", "is_leaf-1"},
  {"is_list_skeleton", "is_list_skeleton(Node::syntaxTree())", "is_list_skeleton-1"},
  {"is_literal", "is_literal(T::syntaxTree())", "is_literal-1"},
  {"is_proper_list", "is_proper_list(Node::syntaxTree())", "is_proper_list-1"},
  {"is_string", "is_string(Node::syntaxTree(), Value::string())", "is_string-2"},
  {"is_tree", "is_tree(Tree::syntaxTree())", "is_tree-1"},
  {"join_comments", "join_comments(Source::syntaxTree(), Target::syntaxTree())", "join_comments-2"},
  {"list", "list(List::[syntaxTree()])", "list-1"},
  {"list", "list(Elements::[syntaxTree()], Tail::none | syntaxTree())", "list-2"},
  {"list_comp", "list_comp(Template::syntaxTree(), Body::[syntaxTree()])", "list_comp-2"},
  {"list_comp_body", "list_comp_body(Node::syntaxTree())", "list_comp_body-1"},
  {"list_comp_template", "list_comp_template(Node::syntaxTree())", "list_comp_template-1"},
  {"list_elements", "list_elements(Node::syntaxTree())", "list_elements-1"},
  {"list_head", "list_head(Node::syntaxTree())", "list_head-1"},
  {"list_length", "list_length(Node::syntaxTree())", "list_length-1"},
  {"list_prefix", "list_prefix(Node::syntaxTree())", "list_prefix-1"},
  {"list_suffix", "list_suffix(Node::syntaxTree())", "list_suffix-1"},
  {"list_tail", "list_tail(Node::syntaxTree())", "list_tail-1"},
  {"macro", "macro(Name::syntaxTree())", "macro-1"},
  {"macro", "macro(Name::syntaxTree(), Arguments::none | [syntaxTree()])", "macro-2"},
  {"macro_arguments", "macro_arguments(Node::syntaxTree())", "macro_arguments-1"},
  {"macro_name", "macro_name(Node::syntaxTree())", "macro_name-1"},
  {"make_tree", "make_tree(X1::atom(), X2::[[syntaxTree()]])", "make_tree-2"},
  {"map_expr", "map_expr(Fields::[syntaxTree()])", "map_expr-1"},
  {"map_expr", "map_expr(Argument::none | syntaxTree(), Fields::[syntaxTree()])", "map_expr-2"},
  {"map_expr_argument", "map_expr_argument(Node::syntaxTree())", "map_expr_argument-1"},
  {"map_expr_fields", "map_expr_fields(Node::syntaxTree())", "map_expr_fields-1"},
  {"map_field_assoc", "map_field_assoc(Name::syntaxTree(), Value::syntaxTree())", "map_field_assoc-2"},
  {"map_field_assoc_name", "map_field_assoc_name(Node::syntaxTree())", "map_field_assoc_name-1"},
  {"map_field_assoc_value", "map_field_assoc_value(Node::syntaxTree())", "map_field_assoc_value-1"},
  {"map_field_exact", "map_field_exact(Name::syntaxTree(), Value::syntaxTree())", "map_field_exact-2"},
  {"map_field_exact_name", "map_field_exact_name(Node::syntaxTree())", "map_field_exact_name-1"},
  {"map_field_exact_value", "map_field_exact_value(Node::syntaxTree())", "map_field_exact_value-1"},
  {"map_type", "map_type()", "map_type-0"},
  {"map_type", "map_type(Fields::any_size | [syntaxTree()])", "map_type-1"},
  {"map_type_assoc", "map_type_assoc(Name::syntaxTree(), Value::syntaxTree())", "map_type_assoc-2"},
  {"map_type_assoc_name", "map_type_assoc_name(Node::syntaxTree())", "map_type_assoc_name-1"},
  {"map_type_assoc_value", "map_type_assoc_value(Node::syntaxTree())", "map_type_assoc_value-1"},
  {"map_type_exact", "map_type_exact(Name::syntaxTree(), Value::syntaxTree())", "map_type_exact-2"},
  {"map_type_exact_name", "map_type_exact_name(Node::syntaxTree())", "map_type_exact_name-1"},
  {"map_type_exact_value", "map_type_exact_value(Node::syntaxTree())", "map_type_exact_value-1"},
  {"map_type_fields", "map_type_fields(Node::syntaxTree())", "map_type_fields-1"},
  {"match_expr", "match_expr(Pattern::syntaxTree(), Body::syntaxTree())", "match_expr-2"},
  {"match_expr_body", "match_expr_body(Node::syntaxTree())", "match_expr_body-1"},
  {"match_expr_pattern", "match_expr_pattern(Node::syntaxTree())", "match_expr_pattern-1"},
  {"meta", "meta(T::syntaxTree())", "meta-1"},
  {"module_qualifier", "module_qualifier(Module::syntaxTree(), Body::syntaxTree())", "module_qualifier-2"},
  {"module_qualifier_argument", "module_qualifier_argument(Node::syntaxTree())", "module_qualifier_argument-1"},
  {"module_qualifier_body", "module_qualifier_body(Node::syntaxTree())", "module_qualifier_body-1"},
  {"named_fun_expr", "named_fun_expr(Name::syntaxTree(), Clauses::[syntaxTree()])", "named_fun_expr-2"},
  {"named_fun_expr_arity", "named_fun_expr_arity(Node::syntaxTree())", "named_fun_expr_arity-1"},
  {"named_fun_expr_clauses", "named_fun_expr_clauses(Node::syntaxTree())", "named_fun_expr_clauses-1"},
  {"named_fun_expr_name", "named_fun_expr_name(Node::syntaxTree())", "named_fun_expr_name-1"},
  {"nil", "nil()", "nil-0"},
  {"normalize_list", "normalize_list(Node::syntaxTree())", "normalize_list-1"},
  {"operator", "operator(Name::atom() | string())", "operator-1"},
  {"operator_literal", "operator_literal(Node::syntaxTree())", "operator_literal-1"},
  {"operator_name", "operator_name(Node::syntaxTree())", "operator_name-1"},
  {"parentheses", "parentheses(Expr::syntaxTree())", "parentheses-1"},
  {"parentheses_body", "parentheses_body(Node::syntaxTree())", "parentheses_body-1"},
  {"prefix_expr", "prefix_expr(Operator::syntaxTree(), Argument::syntaxTree())", "prefix_expr-2"},
  {"prefix_expr_argument", "prefix_expr_argument(Node::syntaxTree())", "prefix_expr_argument-1"},
  {"prefix_expr_operator", "prefix_expr_operator(Node::syntaxTree())", "prefix_expr_operator-1"},
  {"receive_expr", "receive_expr(Clauses::[syntaxTree()])", "receive_expr-1"},
  {"receive_expr", "receive_expr(Clauses::[syntaxTree()], Timeout::none | syntaxTree(), Action::[syntaxTree()])", "receive_expr-3"},
  {"receive_expr_action", "receive_expr_action(Node::syntaxTree())", "receive_expr_action-1"},
  {"receive_expr_clauses", "receive_expr_clauses(Node::syntaxTree())", "receive_expr_clauses-1"},
  {"receive_expr_timeout", "receive_expr_timeout(Node::syntaxTree())", "receive_expr_timeout-1"},
  {"record_access", "record_access(Argument::syntaxTree(), Type::syntaxTree(), Field::syntaxTree())", "record_access-3"},
  {"record_access_argument", "record_access_argument(Node::syntaxTree())", "record_access_argument-1"},
  {"record_access_field", "record_access_field(Node::syntaxTree())", "record_access_field-1"},
  {"record_access_type", "record_access_type(Node::syntaxTree())", "record_access_type-1"},
  {"record_expr", "record_expr(Type::syntaxTree(), Fields::[syntaxTree()])", "record_expr-2"},
  {"record_expr", "record_expr(Argument::none | syntaxTree(), Type::syntaxTree(), Fields::[syntaxTree()])", "record_expr-3"},
  {"record_expr_argument", "record_expr_argument(Node::syntaxTree())", "record_expr_argument-1"},
  {"record_expr_fields", "record_expr_fields(Node::syntaxTree())", "record_expr_fields-1"},
  {"record_expr_type", "record_expr_type(Node::syntaxTree())", "record_expr_type-1"},
  {"record_field", "record_field(Name::syntaxTree())", "record_field-1"},
  {"record_field", "record_field(Name::syntaxTree(), Value::none | syntaxTree())", "record_field-2"},
  {"record_field_name", "record_field_name(Node::syntaxTree())", "record_field_name-1"},
  {"record_field_value", "record_field_value(Node::syntaxTree())", "record_field_value-1"},
  {"record_index_expr", "record_index_expr(Type::syntaxTree(), Field::syntaxTree())", "record_index_expr-2"},
  {"record_index_expr_field", "record_index_expr_field(Node::syntaxTree())", "record_index_expr_field-1"},
  {"record_index_expr_type", "record_index_expr_type(Node::syntaxTree())", "record_index_expr_type-1"},
  {"record_type", "record_type(Name::syntaxTree(), Fields::[syntaxTree()])", "record_type-2"},
  {"record_type_field", "record_type_field(Name::syntaxTree(), Type::syntaxTree())", "record_type_field-2"},
  {"record_type_field_name", "record_type_field_name(Node::syntaxTree())", "record_type_field_name-1"},
  {"record_type_field_type", "record_type_field_type(Node::syntaxTree())", "record_type_field_type-1"},
  {"record_type_fields", "record_type_fields(Node::syntaxTree())", "record_type_fields-1"},
  {"record_type_name", "record_type_name(Node::syntaxTree())", "record_type_name-1"},
  {"remove_comments", "remove_comments(Node::syntaxTree())", "remove_comments-1"},
  {"revert", "revert(Node::syntaxTree())", "revert-1"},
  {"revert_forms", "revert_forms(Forms::forms())", "revert_forms-1"},
  {"set_ann", "set_ann(Node::syntaxTree(), As::[term()])", "set_ann-2"},
  {"set_attrs", "set_attrs(Node::syntaxTree(), Attr::syntaxTreeAttributes())", "set_attrs-2"},
  {"set_pos", "set_pos(Node::syntaxTree(), Pos::term())", "set_pos-2"},
  {"set_postcomments", "set_postcomments(Node::syntaxTree(), Cs::[syntaxTree()])", "set_postcomments-2"},
  {"set_precomments", "set_precomments(Node::syntaxTree(), Cs::[syntaxTree()])", "set_precomments-2"},
  {"size_qualifier", "size_qualifier(Body::syntaxTree(), Size::syntaxTree())", "size_qualifier-2"},
  {"size_qualifier_argument", "size_qualifier_argument(Node::syntaxTree())", "size_qualifier_argument-1"},
  {"size_qualifier_body", "size_qualifier_body(Node::syntaxTree())", "size_qualifier_body-1"},
  {"string", "string(String::string())", "string-1"},
  {"string_literal", "string_literal(Node::syntaxTree())", "string_literal-1"},
  {"string_literal", "string_literal(Node::syntaxTree(), X2::encoding())", "string_literal-2"},
  {"string_value", "string_value(Node::syntaxTree())", "string_value-1"},
  {"subtrees", "subtrees(T::syntaxTree())", "subtrees-1"},
  {"text", "text(String::string())", "text-1"},
  {"text_string", "text_string(Node::syntaxTree())", "text_string-1"},
  {"tree", "tree(Type::atom())", "tree-1"},
  {"tree", "tree(Type::atom(), Data::term())", "tree-2"},
  {"try_after_expr", "try_after_expr(Body::[syntaxTree()], After::[syntaxTree()])", "try_after_expr-2"},
  {"try_expr", "try_expr(Body::[syntaxTree()], Handlers::[syntaxTree()])", "try_expr-2"},
  {"try_expr", "try_expr(Body::[syntaxTree()], Clauses::[syntaxTree()], Handlers::[syntaxTree()])", "try_expr-3"},
  {"try_expr", "try_expr(Body::[syntaxTree()], Clauses::[syntaxTree()], Handlers::[syntaxTree()], After::[syntaxTree()])", "try_expr-4"},
  {"try_expr_after", "try_expr_after(Node::syntaxTree())", "try_expr_after-1"},
  {"try_expr_body", "try_expr_body(Node::syntaxTree())", "try_expr_body-1"},
  {"try_expr_clauses", "try_expr_clauses(Node::syntaxTree())", "try_expr_clauses-1"},
  {"try_expr_handlers", "try_expr_handlers(Node::syntaxTree())", "try_expr_handlers-1"},
  {"tuple", "tuple(List::[syntaxTree()])", "tuple-1"},
  {"tuple_elements", "tuple_elements(Node::syntaxTree())", "tuple_elements-1"},
  {"tuple_size", "tuple_size(Node::syntaxTree())", "tuple_size-1"},
  {"tuple_type", "tuple_type()", "tuple_type-0"},
  {"tuple_type", "tuple_type(Elements::any_size | [syntaxTree()])", "tuple_type-1"},
  {"tuple_type_elements", "tuple_type_elements(Node::syntaxTree())", "tuple_type_elements-1"},
  {"type", "type(Tree::syntaxTree())", "type-1"},
  {"type_application", "type_application(TypeName::syntaxTree(), Arguments::[syntaxTree()])", "type_application-2"},
  {"type_application", "type_application(Module::none | syntaxTree(), TypeName::syntaxTree(), Arguments::[syntaxTree()])", "type_application-3"},
  {"type_application_arguments", "type_application_arguments(Node::syntaxTree())", "type_application_arguments-1"},
  {"type_application_name", "type_application_name(Node::syntaxTree())", "type_application_name-1"},
  {"type_union", "type_union(Types::[syntaxTree()])", "type_union-1"},
  {"type_union_types", "type_union_types(Node::syntaxTree())", "type_union_types-1"},
  {"typed_record_field", "typed_record_field(Field::syntaxTree(), Type::syntaxTree())", "typed_record_field-2"},
  {"typed_record_field_body", "typed_record_field_body(Node::syntaxTree())", "typed_record_field_body-1"},
  {"typed_record_field_type", "typed_record_field_type(Node::syntaxTree())", "typed_record_field_type-1"},
  {"underscore", "underscore()", "underscore-0"},
  {"update_tree", "update_tree(Node::syntaxTree(), Groups::[[syntaxTree()]])", "update_tree-2"},
  {"user_type_application", "user_type_application(TypeName::syntaxTree(), Arguments::[syntaxTree()])", "user_type_application-2"},
  {"user_type_application_arguments", "user_type_application_arguments(Node::syntaxTree())", "user_type_application_arguments-1"},
  {"user_type_application_name", "user_type_application_name(Node::syntaxTree())", "user_type_application_name-1"},
  {"variable", "variable(Name::atom() | string())", "variable-1"},
  {"variable_literal", "variable_literal(Node::syntaxTree())", "variable_literal-1"},
  {"variable_name", "variable_name(Node::syntaxTree())", "variable_name-1"},
  {"warning_marker", "warning_marker(Warning::term())", "warning_marker-1"},
  {"warning_marker_info", "warning_marker_info(Node::syntaxTree())", "warning_marker_info-1"}
]}.
{"erl_syntax.html", {module, "syntax_tools"}, ["erl_syntax"]}.
{"erl_syntax_lib.html", {function, {"syntax_tools", "erl_syntax_lib"}},
[
  {"analyze_application", "analyze_application(Node::syntaxTree())", "analyze_application-1"},
  {"analyze_attribute", "analyze_attribute(Node::syntaxTree())", "analyze_attribute-1"},
  {"analyze_export_attribute", "analyze_export_attribute(Node::syntaxTree())", "analyze_export_attribute-1"},
  {"analyze_file_attribute", "analyze_file_attribute(Node::syntaxTree())", "analyze_file_attribute-1"},
  {"analyze_form", "analyze_form(Node::syntaxTree())", "analyze_form-1"},
  {"analyze_forms", "analyze_forms(Forms)", "analyze_forms-1"},
  {"analyze_function", "analyze_function(Node::syntaxTree())", "analyze_function-1"},
  {"analyze_function_name", "analyze_function_name(Node::syntaxTree())", "analyze_function_name-1"},
  {"analyze_implicit_fun", "analyze_implicit_fun(Node::syntaxTree())", "analyze_implicit_fun-1"},
  {"analyze_import_attribute", "analyze_import_attribute(Node::syntaxTree())", "analyze_import_attribute-1"},
  {"analyze_module_attribute", "analyze_module_attribute(Node::syntaxTree())", "analyze_module_attribute-1"},
  {"analyze_record_attribute", "analyze_record_attribute(Node::syntaxTree())", "analyze_record_attribute-1"},
  {"analyze_record_expr", "analyze_record_expr(Node::syntaxTree())", "analyze_record_expr-1"},
  {"analyze_record_field", "analyze_record_field(Node::syntaxTree())", "analyze_record_field-1"},
  {"analyze_type_application", "analyze_type_application(Node::syntaxTree())", "analyze_type_application-1"},
  {"analyze_type_name", "analyze_type_name(Node::syntaxTree())", "analyze_type_name-1"},
  {"analyze_wild_attribute", "analyze_wild_attribute(Node::syntaxTree())", "analyze_wild_attribute-1"},
  {"annotate_bindings", "annotate_bindings(Tree::syntaxTree())", "annotate_bindings-1"},
  {"annotate_bindings", "annotate_bindings(Tree::syntaxTree(), Bindings::ordset(atom()))", "annotate_bindings-2"},
  {"fold", "fold(F::Function, Start::term(), Tree::syntaxTree())", "fold-3"},
  {"fold_subtrees", "fold_subtrees(F::Function, Start::term(), Tree::syntaxTree())", "fold_subtrees-3"},
  {"foldl_listlist", "foldl_listlist(F::Function, Start::term(), Ls::[[term()]])", "foldl_listlist-3"},
  {"function_name_expansions", "function_name_expansions(Names::[Name])", "function_name_expansions-1"},
  {"is_fail_expr", "is_fail_expr(Tree::syntaxTree())", "is_fail_expr-1"},
  {"limit", "limit(Tree, Depth)", "limit-2"},
  {"limit", "limit(Tree::syntaxTree(), Depth::integer(), Node::syntaxTree())", "limit-3"},
  {"map", "map(F::Function, Tree::syntaxTree())", "map-2"},
  {"map_subtrees", "map_subtrees(F::Function, Tree::syntaxTree())", "map_subtrees-2"},
  {"mapfold", "mapfold(F::Function, Start::term(), Tree::syntaxTree())", "mapfold-3"},
  {"mapfold_subtrees", "mapfold_subtrees(F::Function, Start::term(), Tree::syntaxTree())", "mapfold_subtrees-3"},
  {"mapfoldl_listlist", "mapfoldl_listlist(F::Function, S::State, Ls::[[term()]])", "mapfoldl_listlist-3"},
  {"new_variable_name", "new_variable_name(Used::set(atom()))", "new_variable_name-1"},
  {"new_variable_name", "new_variable_name(F::Function, Used::set(atom()))", "new_variable_name-2"},
  {"new_variable_names", "new_variable_names(N::integer(), Used::set(atom()))", "new_variable_names-2"},
  {"new_variable_names", "new_variable_names(N::integer(), F::Function, Used::set(atom()))", "new_variable_names-3"},
  {"strip_comments", "strip_comments(Tree::syntaxTree())", "strip_comments-1"},
  {"to_comment", "to_comment(Tree)", "to_comment-1"},
  {"to_comment", "to_comment(Tree::syntaxTree(), Prefix::string())", "to_comment-2"},
  {"to_comment", "to_comment(Tree::syntaxTree(), Prefix::string(), F::Printer)", "to_comment-3"},
  {"variables", "variables(Tree::syntaxTree())", "variables-1"}
]}.
{"erl_syntax_lib.html", {module, "syntax_tools"}, ["erl_syntax_lib"]}.
{"erl_tidy.html", {function, {"syntax_tools", "erl_tidy"}},
[
  {"dir", "dir()", "dir-0"},
  {"dir", "dir(Dir)", "dir-1"},
  {"dir", "dir(Directory::filename(), Options::[term()])", "dir-2"},
  {"file", "file(Name)", "file-1"},
  {"file", "file(Name::filename(), Options::[term()])", "file-2"},
  {"module", "module(Forms)", "module-1"},
  {"module", "module(Forms, Options::[term()])", "module-2"}
]}.
{"erl_tidy.html", {module, "syntax_tools"}, ["erl_tidy"]}.
{"igor.html", {function, {"syntax_tools", "igor"}},
[
  {"create_stubs", "create_stubs(Stubs::[stubDescriptor()], Options::[term()])", "create_stubs-2"},
  {"merge", "merge(Name::atom(), Files::[filename()])", "merge-2"},
  {"merge", "merge(Name::atom(), Files::[filename()], Options::[term()])", "merge-3"},
  {"merge_files", "merge_files(Name::atom(), Files::[filename()], Options::[term()])", "merge_files-3"},
  {"merge_files", "merge_files(Name::atom(), Sources::[Forms], Files::[filename()], Options::[term()])", "merge_files-4"},
  {"merge_sources", "merge_sources(Name::atom(), Sources::[Forms], Options::[term()])", "merge_sources-3"},
  {"parse_transform", "parse_transform(Forms::[syntaxTree()], Options::[term()])", "parse_transform-2"},
  {"rename", "rename(Files::[filename()], Renamings)", "rename-2"},
  {"rename", "rename(Files::[filename()], Renamings, Options::[term()])", "rename-3"}
]}.
{"igor.html", {module, "syntax_tools"}, ["igor"]}.
{"merl.html", {function, {"syntax_tools", "merl"}},
[
  {"alpha", "alpha(Trees::pattern_or_patterns(), Env::[{id(), id()}])", "alpha-2"},
  {"compile", "compile(Code)", "compile-1"},
  {"compile", "compile(Code, Options)", "compile-2"},
  {"compile_and_load", "compile_and_load(Code)", "compile_and_load-1"},
  {"compile_and_load", "compile_and_load(Code, Options)", "compile_and_load-2"},
  {"match", "match(Patterns::pattern_or_patterns(), Trees::tree_or_trees())", "match-2"},
  {"meta_template", "meta_template(Templates::template_or_templates())", "meta_template-1"},
  {"print", "print(Ts)", "print-1"},
  {"qquote", "qquote(Text::text(), Env::env())", "qquote-2"},
  {"qquote", "qquote(StartPos::location(), Text::text(), Env::env())", "qquote-3"},
  {"quote", "quote(Text::text())", "quote-1"},
  {"quote", "quote(StartPos::location(), Text::text())", "quote-2"},
  {"show", "show(Ts)", "show-1"},
  {"subst", "subst(Trees::pattern_or_patterns(), Env::env())", "subst-2"},
  {"switch", "switch(Trees::tree_or_trees(), Cs::[switch_clause()])", "switch-2"},
  {"template", "template(Trees::pattern_or_patterns())", "template-1"},
  {"template_vars", "template_vars(Template::template_or_templates())", "template_vars-1"},
  {"term", "term(Term::term())", "term-1"},
  {"tree", "tree(Templates::template_or_templates())", "tree-1"},
  {"tsubst", "tsubst(Trees::pattern_or_patterns(), Env::env())", "tsubst-2"},
  {"var", "var(Name::atom())", "var-1"}
]}.
{"merl.html", {module, "syntax_tools"}, ["merl"]}.
{"merl_transform.html", {function, {"syntax_tools", "merl_transform"}},
[
  {"parse_transform", "parse_transform(Forms, Options)", "parse_transform-2"}
]}.
{"merl_transform.html", {module, "syntax_tools"}, ["merl_transform"]}.
{"prettypr.html", {function, {"syntax_tools", "prettypr"}},
[
  {"above", "above(D1::document(), D2::document())", "above-2"},
  {"beside", "beside(D1::document(), D2::document())", "beside-2"},
  {"best", "best(D::document(), PaperWidth::integer(), LineWidth::integer())", "best-3"},
  {"break", "break(D::document())", "break-1"},
  {"empty", "empty()", "empty-0"},
  {"floating", "floating(D::document())", "floating-1"},
  {"floating", "floating(D::document(), Hp::integer(), Vp::integer())", "floating-3"},
  {"follow", "follow(D1::document(), D2::document())", "follow-2"},
  {"follow", "follow(D1::document(), D2::document(), Offset::integer())", "follow-3"},
  {"format", "format(D::document())", "format-1"},
  {"format", "format(D::document(), PaperWidth::integer())", "format-2"},
  {"format", "format(D::document(), PaperWidth::integer(), LineWidth::integer())", "format-3"},
  {"nest", "nest(N::integer(), D::document())", "nest-2"},
  {"null_text", "null_text(Characters::string())", "null_text-1"},
  {"par", "par(Docs::[document()])", "par-1"},
  {"par", "par(Docs::[document()], Offset::integer())", "par-2"},
  {"sep", "sep(Docs::[document()])", "sep-1"},
  {"text", "text(Characters::string())", "text-1"},
  {"text_par", "text_par(Text::string())", "text_par-1"},
  {"text_par", "text_par(Text::string(), Indentation::integer())", "text_par-2"}
]}.
{"prettypr.html", {module, "syntax_tools"}, ["prettypr"]}.
{notused, application, ["syntax_tools"]}.
