#ifndef __CPP2_PARSE

#define __CPP2_PARSE

#include "lex.h"

#include <memory>

#include <variant>

#include <iostream>

namespace cpp2 {

auto violates_lifetime_safety = false;

auto is_prefix_operator(lexeme l) -> bool

{

return l == lexeme::Not;

}

auto is_postfix_operator(lexeme l) -> bool

}

auto is_assignment_operator(lexeme l) -> bool

}

template <int I>

auto try_visit(auto& variant, auto& visitor, int depth) -> void {

}

struct expression_list_node;

struct id_expression_node;

struct declaration_node;

struct primary_expression_node

};

struct postfix_expression_node;

struct prefix_expression_node

};

template<

String Name,

typename Term

>

struct binary_expression_node

};

using is_as_expression_node = binary_expression_node< "is-as" , prefix_expression_node >;

using multiplicative_expression_node = binary_expression_node< "multiplicative" , is_as_expression_node >;

using additive_expression_node = binary_expression_node< "additive" , multiplicative_expression_node >;

using shift_expression_node = binary_expression_node< "shift" , additive_expression_node >;

using compare_expression_node = binary_expression_node< "compare" , shift_expression_node >;

using relational_expression_node = binary_expression_node< "relational" , compare_expression_node >;

using equality_expression_node = binary_expression_node< "equality" , relational_expression_node >;

using bit_and_expression_node = binary_expression_node< "bit-and" , equality_expression_node >;

using bit_xor_expression_node = binary_expression_node< "bit-xor" , bit_and_expression_node >;

using bit_or_expression_node = binary_expression_node< "bit-or" , bit_xor_expression_node >;

using logical_and_expression_node = binary_expression_node< "logical-and" , bit_or_expression_node >;

using logical_or_expression_node = binary_expression_node< "logical-or" , logical_and_expression_node >;

using assignment_expression_node = binary_expression_node< "assignment" , logical_or_expression_node >;

struct expression_node

};

enum class passing_style { in=0, copy, inout, out, move, forward };

auto to_string_view(passing_style pass) -> std::string_view {

}

struct expression_list_node

};

struct expression_statement_node

};

struct capture {

postfix_expression_node* capture_expr;

std::string str;

};

using capture_group = std::vector<capture>;

struct postfix_expression_node

};

auto prefix_expression_node::position() const -> source_position

}

auto prefix_expression_node::visit(auto& v, int depth) -> void

}

struct unqualified_id_node

};

struct qualified_id_node

};

struct id_expression_node

};

struct statement_node;

struct compound_statement_node

};

struct selection_statement_node

};

struct parameter_declaration_node;

struct iteration_statement_node

};

struct return_statement_node

};

struct contract_node

};

struct parameter_declaration_list_node;

struct statement_node

};

auto compound_statement_node::visit(auto& v, int depth) -> void

}

struct parameter_declaration_node

};

struct parameter_declaration_list_node

};

auto statement_node::visit(auto& v, int depth) -> void

}

struct function_returns_tag { };

struct function_type_node

};

struct declaration_node

};

auto primary_expression_node::get_token() -> token const*

}

auto primary_expression_node::position() const -> source_position

}

auto primary_expression_node::visit(auto& v, int depth) -> void

}

auto iteration_statement_node::get_for_parameter() const -> parameter_declaration_node const* {

}

auto iteration_statement_node::visit(auto& v, int depth) -> void

}

auto statement_node::position() const -> source_position

}

auto parameter_declaration_node::position() const -> source_position

}

auto parameter_declaration_node::visit(auto& v, int depth) -> void

}

struct translation_unit_node

};