{
push (Rust::Token::make (LET, stmt.get_locus ()));
auto &pattern = stmt.get_pattern ();
- if (pattern)
- visit (pattern);
+ visit (pattern);
if (stmt.has_type ())
{
VariadicParam::as_string () const
{
if (has_pattern ())
- return get_pattern ()->as_string () + " : ...";
+ return get_pattern ().as_string () + " : ...";
else
return "...";
}
if (!stmt.is_semicolon_followed ())
{
- expr = std::move (stmt.get_expr ());
+ expr = std::move (stmt.take_expr ());
statements.pop_back ();
}
}
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_borrowed_expr ()
+ Expr &get_borrowed_expr ()
{
rust_assert (main_or_left_expr != nullptr);
- return main_or_left_expr;
+ return *main_or_left_expr;
}
bool get_is_mut () const { return is_mut; }
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_dereferenced_expr ()
+ Expr &get_dereferenced_expr ()
{
rust_assert (main_or_left_expr != nullptr);
- return main_or_left_expr;
+ return *main_or_left_expr;
}
protected:
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_propagating_expr ()
+ Expr &get_propagating_expr ()
{
rust_assert (main_or_left_expr != nullptr);
- return main_or_left_expr;
+ return *main_or_left_expr;
}
protected:
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_negated_expr ()
+ Expr &get_negated_expr ()
{
rust_assert (main_or_left_expr != nullptr);
- return main_or_left_expr;
+ return *main_or_left_expr;
}
protected:
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_left_expr ()
+ Expr &get_left_expr ()
+ {
+ rust_assert (main_or_left_expr != nullptr);
+ return *main_or_left_expr;
+ }
+
+ std::unique_ptr<Expr> &get_left_expr_ptr ()
{
rust_assert (main_or_left_expr != nullptr);
return main_or_left_expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_right_expr ()
+ Expr &get_right_expr ()
+ {
+ rust_assert (right_expr != nullptr);
+ return *right_expr;
+ }
+
+ std::unique_ptr<Expr> &get_right_expr_ptr ()
{
rust_assert (right_expr != nullptr);
return right_expr;
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_left_expr ()
+ Expr &get_left_expr ()
+ {
+ rust_assert (main_or_left_expr != nullptr);
+ return *main_or_left_expr;
+ }
+
+ std::unique_ptr<Expr> &get_left_expr_ptr ()
{
rust_assert (main_or_left_expr != nullptr);
return main_or_left_expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_right_expr ()
+ Expr &get_right_expr ()
+ {
+ rust_assert (right_expr != nullptr);
+ return *right_expr;
+ }
+
+ std::unique_ptr<Expr> &get_right_expr_ptr ()
{
rust_assert (right_expr != nullptr);
return right_expr;
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_left_expr ()
+ Expr &get_left_expr ()
+ {
+ rust_assert (main_or_left_expr != nullptr);
+ return *main_or_left_expr;
+ }
+
+ std::unique_ptr<Expr> &get_left_expr_ptr ()
{
rust_assert (main_or_left_expr != nullptr);
return main_or_left_expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_right_expr ()
+ Expr &get_right_expr ()
+ {
+ rust_assert (right_expr != nullptr);
+ return *right_expr;
+ }
+
+ std::unique_ptr<Expr> &get_right_expr_ptr ()
{
rust_assert (right_expr != nullptr);
return right_expr;
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_casted_expr ()
+ Expr &get_casted_expr ()
{
rust_assert (main_or_left_expr != nullptr);
- return main_or_left_expr;
+ return *main_or_left_expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<TypeNoBounds> &get_type_to_cast_to ()
+ TypeNoBounds &get_type_to_cast_to ()
{
rust_assert (type_to_convert_to != nullptr);
- return type_to_convert_to;
+ return *type_to_convert_to;
}
protected:
void visit_rhs (ASTVisitor &vis) { right_expr->accept_vis (vis); }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_left_expr ()
+ Expr &get_left_expr ()
+ {
+ rust_assert (main_or_left_expr != nullptr);
+ return *main_or_left_expr;
+ }
+
+ std::unique_ptr<Expr> &get_left_expr_ptr ()
{
rust_assert (main_or_left_expr != nullptr);
return main_or_left_expr;
}
- // TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_right_expr ()
+ std::unique_ptr<Expr> &get_right_expr_ptr ()
{
rust_assert (right_expr != nullptr);
return right_expr;
}
+ // TODO: is this better? Or is a "vis_block" better?
+ Expr &get_right_expr ()
+ {
+ rust_assert (right_expr != nullptr);
+ return *right_expr;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_left_expr ()
+ Expr &get_left_expr ()
+ {
+ rust_assert (main_or_left_expr != nullptr);
+ return *main_or_left_expr;
+ }
+
+ std::unique_ptr<Expr> &get_left_expr_ptr ()
{
rust_assert (main_or_left_expr != nullptr);
return main_or_left_expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_right_expr ()
+ Expr &get_right_expr ()
+ {
+ rust_assert (right_expr != nullptr);
+ return *right_expr;
+ }
+
+ std::unique_ptr<Expr> &get_right_expr_ptr ()
{
rust_assert (right_expr != nullptr);
return right_expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_expr_in_parens ()
+ Expr &get_expr_in_parens ()
+ {
+ rust_assert (expr_in_parens != nullptr);
+ return *expr_in_parens;
+ }
+
+ std::unique_ptr<Expr> &get_expr_in_parens_ptr ()
{
rust_assert (expr_in_parens != nullptr);
return expr_in_parens;
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_elem_to_copy ()
+ Expr &get_elem_to_copy ()
{
rust_assert (elem_to_copy != nullptr);
- return elem_to_copy;
+ return *elem_to_copy;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_num_copies ()
+ Expr &get_num_copies ()
{
rust_assert (num_copies != nullptr);
- return num_copies;
+ return *num_copies;
}
protected:
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_array_expr ()
+ Expr &get_array_expr ()
{
rust_assert (array_expr != nullptr);
- return array_expr;
+ return *array_expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_index_expr ()
+ Expr &get_index_expr ()
{
rust_assert (index_expr != nullptr);
- return index_expr;
+ return *index_expr;
}
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
bool is_marked_for_strip () const override { return tuple_expr == nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_tuple_expr ()
+ Expr &get_tuple_expr ()
{
rust_assert (tuple_expr != nullptr);
- return tuple_expr;
+ return *tuple_expr;
}
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
std::string as_string () const;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_base_struct ()
+ Expr &get_base_struct ()
{
rust_assert (base_struct != nullptr);
- return base_struct;
+ return *base_struct;
}
};
std::string as_string () const override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_value ()
+ Expr &get_value ()
{
rust_assert (value != nullptr);
- return value;
+ return *value;
}
};
std::vector<std::unique_ptr<Expr> > &get_params () { return params; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_function_expr ()
+ Expr &get_function_expr ()
{
rust_assert (function != nullptr);
- return function;
+ return *function;
}
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
std::vector<std::unique_ptr<Expr> > &get_params () { return params; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_receiver_expr ()
+ Expr &get_receiver_expr ()
{
rust_assert (receiver != nullptr);
- return receiver;
+ return *receiver;
}
const PathExprSegment &get_method_name () const { return method_name; }
bool is_marked_for_strip () const override { return receiver == nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_receiver_expr ()
+ Expr &get_receiver_expr ()
{
rust_assert (receiver != nullptr);
- return receiver;
+ return *receiver;
}
Identifier get_field_name () const { return field; }
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
std::vector<Attribute> &get_outer_attrs () { return outer_attrs; }
- std::unique_ptr<Pattern> &get_pattern ()
+ Pattern &get_pattern ()
{
rust_assert (pattern != nullptr);
- return pattern;
+ return *pattern;
}
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (has_type_given ());
+ return *type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (has_type_given ());
return type;
return closure_inner == nullptr;
}
- std::unique_ptr<Expr> &get_definition_expr ()
+ Expr &get_definition_expr ()
{
rust_assert (closure_inner != nullptr);
- return closure_inner;
+ return *closure_inner;
}
protected:
std::vector<std::unique_ptr<Stmt> > &get_statements () { return statements; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_tail_expr ()
+ Expr &get_tail_expr ()
+ {
+ rust_assert (has_tail_expr ());
+ return *expr;
+ }
+
+ std::unique_ptr<Expr> &get_tail_expr_ptr ()
{
rust_assert (has_tail_expr ());
return expr;
bool is_marked_for_strip () const override { return expr == nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<BlockExpr> &get_definition_block ()
+ BlockExpr &get_definition_block ()
{
rust_assert (expr != nullptr);
- return expr;
+ return *expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_return_type ()
+ Type &get_return_type ()
+ {
+ rust_assert (return_type != nullptr);
+ return *return_type;
+ }
+
+ std::unique_ptr<Type> &get_return_type_ptr ()
{
rust_assert (return_type != nullptr);
return return_type;
bool is_marked_for_strip () const override { return marked_for_strip; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_break_expr ()
+ Expr &get_break_expr ()
{
rust_assert (has_break_expr ());
- return break_expr;
+ return *break_expr;
}
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_from_expr ()
+ Expr &get_from_expr ()
{
rust_assert (from != nullptr);
- return from;
+ return *from;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_to_expr ()
+ Expr &get_to_expr ()
{
rust_assert (to != nullptr);
- return to;
+ return *to;
}
protected:
bool is_marked_for_strip () const override { return from == nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_from_expr ()
+ Expr &get_from_expr ()
{
rust_assert (from != nullptr);
- return from;
+ return *from;
}
protected:
bool is_marked_for_strip () const override { return to == nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_to_expr ()
+ Expr &get_to_expr ()
{
rust_assert (to != nullptr);
- return to;
+ return *to;
}
protected:
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_from_expr ()
+ Expr &get_from_expr ()
{
rust_assert (from != nullptr);
- return from;
+ return *from;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_to_expr ()
+ Expr &get_to_expr ()
{
rust_assert (to != nullptr);
- return to;
+ return *to;
}
protected:
bool is_marked_for_strip () const override { return to == nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_to_expr ()
+ Expr &get_to_expr ()
{
rust_assert (to != nullptr);
- return to;
+ return *to;
}
protected:
bool is_marked_for_strip () const override { return marked_for_strip; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_returned_expr ()
+ Expr &get_returned_expr ()
{
rust_assert (return_expr != nullptr);
- return return_expr;
+ return *return_expr;
}
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
bool is_marked_for_strip () const override { return expr == nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<BlockExpr> &get_block_expr ()
+ BlockExpr &get_block_expr ()
{
rust_assert (expr != nullptr);
- return expr;
+ return *expr;
}
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
bool is_marked_for_strip () const override { return loop_block == nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<BlockExpr> &get_loop_block ()
+ BlockExpr &get_loop_block ()
{
rust_assert (loop_block != nullptr);
- return loop_block;
+ return *loop_block;
}
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_predicate_expr ()
+ Expr &get_predicate_expr ()
{
rust_assert (condition != nullptr);
- return condition;
+ return *condition;
}
protected:
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_scrutinee_expr ()
+ Expr &get_scrutinee_expr ()
{
rust_assert (scrutinee != nullptr);
- return scrutinee;
+ return *scrutinee;
}
// TODO: this mutable getter seems really dodgy. Think up better way.
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_iterator_expr ()
+ Expr &get_iterator_expr ()
{
rust_assert (iterator_expr != nullptr);
- return iterator_expr;
+ return *iterator_expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Pattern> &get_pattern ()
+ Pattern &get_pattern ()
{
rust_assert (pattern != nullptr);
- return pattern;
+ return *pattern;
}
protected:
void vis_if_block (ASTVisitor &vis) { if_block->accept_vis (vis); }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_condition_expr ()
+ Expr &get_condition_expr ()
+ {
+ rust_assert (condition != nullptr);
+ return *condition;
+ }
+
+ std::unique_ptr<Expr> &get_condition_expr_ptr ()
{
rust_assert (condition != nullptr);
return condition;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<BlockExpr> &get_if_block ()
+ BlockExpr &get_if_block ()
{
rust_assert (if_block != nullptr);
- return if_block;
+ return *if_block;
}
// Invalid if if block or condition is null, so base stripping on that.
void vis_else_block (ASTVisitor &vis) { else_block->accept_vis (vis); }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<ExprWithBlock> &get_else_block ()
+ ExprWithBlock &get_else_block ()
{
rust_assert (else_block != nullptr);
- return else_block;
+ return *else_block;
}
protected:
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_value_expr ()
+ Expr &get_value_expr ()
+ {
+ rust_assert (value != nullptr);
+ return *value;
+ }
+
+ std::unique_ptr<Expr> &get_value_expr_ptr ()
{
rust_assert (value != nullptr);
return value;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<BlockExpr> &get_if_block ()
+ BlockExpr &get_if_block ()
{
rust_assert (if_block != nullptr);
- return if_block;
+ return *if_block;
}
// TODO: this mutable getter seems really dodgy. Think up better way.
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<ExprWithBlock> &get_else_block ()
+ ExprWithBlock &get_else_block ()
{
rust_assert (else_block != nullptr);
- return else_block;
+ return *else_block;
}
protected:
std::string as_string () const;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_guard_expr ()
+ Expr &get_guard_expr ()
+ {
+ rust_assert (has_match_arm_guard ());
+ return *guard_expr;
+ }
+
+ std::unique_ptr<Expr> &get_guard_expr_ptr ()
{
rust_assert (has_match_arm_guard ());
return guard_expr;
std::string as_string () const;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_expr ()
+ Expr &get_expr ()
+ {
+ rust_assert (expr != nullptr);
+ return *expr;
+ }
+
+ std::unique_ptr<Expr> &get_expr_ptr ()
{
rust_assert (expr != nullptr);
return expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_scrutinee_expr ()
+ Expr &get_scrutinee_expr ()
{
rust_assert (branch_value != nullptr);
- return branch_value;
+ return *branch_value;
}
const std::vector<MatchCase> &get_match_cases () const { return match_arms; }
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (type != nullptr);
+ return *type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (type != nullptr);
return type;
void accept_vis (ASTVisitor &vis) override;
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (bound_type != nullptr);
+ return *bound_type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (bound_type != nullptr);
return bound_type;
NodeId get_node_id () const { return node_id; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (has_type ());
+ return *type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (has_type ());
return type;
return new VariadicParam (*this);
}
- std::unique_ptr<Pattern> &get_pattern ()
+ Pattern &get_pattern ()
{
rust_assert (param_name != nullptr);
- return param_name;
+ return *param_name;
}
- const std::unique_ptr<Pattern> &get_pattern () const
+ const Pattern &get_pattern () const
{
rust_assert (param_name != nullptr);
- return param_name;
+ return *param_name;
}
bool has_pattern () const { return param_name != nullptr; }
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Pattern> &get_pattern ()
+ Pattern &get_pattern ()
{
rust_assert (param_name != nullptr);
- return param_name;
+ return *param_name;
}
bool has_name () const { return param_name != nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (type != nullptr);
+ return *type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (type != nullptr);
return type;
WhereClause &get_where_clause () { return where_clause; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_return_type ()
+ Type &get_return_type ()
+ {
+ rust_assert (has_return_type ());
+ return *return_type;
+ }
+
+ std::unique_ptr<Type> &get_return_type_ptr ()
{
rust_assert (has_return_type ());
return return_type;
WhereClause &get_where_clause () { return where_clause; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type_aliased ()
+ Type &get_type_aliased ()
{
rust_assert (existing_type != nullptr);
- return existing_type;
+ return *existing_type;
}
Identifier get_new_type_name () const { return new_type_name; }
location_t get_locus () const { return locus; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_field_type ()
+ Type &get_field_type ()
+ {
+ rust_assert (field_type != nullptr);
+ return *field_type;
+ }
+
+ std::unique_ptr<Type> &get_field_type_ptr ()
{
rust_assert (field_type != nullptr);
return field_type;
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_field_type ()
+ Type &get_field_type ()
+ {
+ rust_assert (field_type != nullptr);
+ return *field_type;
+ }
+
+ std::unique_ptr<Type> &get_field_type_ptr ()
{
rust_assert (field_type != nullptr);
return field_type;
bool has_expr () { return expression != nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_expr ()
+ Expr &get_expr ()
+ {
+ rust_assert (expression != nullptr);
+ return *expression;
+ }
+
+ std::unique_ptr<Expr> &get_expr_ptr ()
{
rust_assert (expression != nullptr);
return expression;
bool has_expr () { return const_expr != nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_expr ()
+ Expr &get_expr ()
+ {
+ rust_assert (const_expr != nullptr);
+ return *const_expr;
+ }
+
+ std::unique_ptr<Expr> &get_expr_ptr ()
{
rust_assert (const_expr != nullptr);
return const_expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (type != nullptr);
+ return *type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (type != nullptr);
return type;
bool has_expr () { return expr != nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_expr ()
+ Expr &get_expr ()
+ {
+ rust_assert (expr != nullptr);
+ return *expr;
+ }
+
+ std::unique_ptr<Expr> &get_expr_ptr ()
{
rust_assert (expr != nullptr);
return expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (type != nullptr);
+ return *type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (type != nullptr);
return type;
bool has_expr () const { return expr != nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_expr ()
+ Expr &get_expr ()
+ {
+ rust_assert (has_expr ());
+ return *expr;
+ }
+
+ std::unique_ptr<Expr> &get_expr_ptr ()
{
rust_assert (has_expr ());
return expr;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (type != nullptr);
+ return *type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (type != nullptr);
return type;
WhereClause &get_where_clause () { return where_clause; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (trait_type != nullptr);
+ return *trait_type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (trait_type != nullptr);
return trait_type;
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (item_type != nullptr);
+ return *item_type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (item_type != nullptr);
return item_type;
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (param_type != nullptr);
+ return *param_type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (param_type != nullptr);
return param_type;
WhereClause &get_where_clause () { return where_clause; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_return_type ()
+ Type &get_return_type ()
+ {
+ rust_assert (has_return_type ());
+ return *return_type;
+ }
+
+ std::unique_ptr<Type> &get_return_type_ptr ()
{
rust_assert (has_return_type ());
return return_type;
std::string as_string () const;
// TODO: is this better? Or is a "vis_pattern" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (type != nullptr);
+ return *type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (type != nullptr);
return type;
switch (get_kind ())
{
case Kind::Const:
- get_expression ()->accept_vis (visitor);
+ get_expression ().accept_vis (visitor);
break;
case Kind::Type:
- get_type ()->accept_vis (visitor);
+ get_type ().accept_vis (visitor);
break;
case Kind::Either:
break;
}
}
- std::unique_ptr<Expr> &get_expression ()
+ Expr &get_expression ()
+ {
+ rust_assert (kind == Kind::Const);
+
+ return *expression;
+ }
+
+ std::unique_ptr<Expr> &get_expression_ptr ()
{
rust_assert (kind == Kind::Const);
return expression;
}
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (kind == Kind::Type);
+
+ return *type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (kind == Kind::Type);
Attribute &get_outer_attribute () { return outer_attr; }
- std::unique_ptr<AST::Type> &get_type ()
+ AST::Type &get_type ()
{
rust_assert (has_type ());
- return type;
+ return *type;
}
GenericArg &get_default_value ()
std::vector<std::unique_ptr<Type> > &get_params () { return inputs; }
// TODO: is this better? Or is a "vis_pattern" better?
- std::unique_ptr<Type> &get_return_type ()
+ Type &get_return_type ()
+ {
+ rust_assert (has_return_type ());
+ return *return_type;
+ }
+
+ std::unique_ptr<Type> &get_return_type_ptr ()
{
rust_assert (has_return_type ());
return return_type;
location_t get_locus () const { return locus; }
// TODO: is this better? Or is a "vis_pattern" better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (type_to_invoke_on != nullptr);
+ return *type_to_invoke_on;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (type_to_invoke_on != nullptr);
return type_to_invoke_on;
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_pattern" better?
- std::unique_ptr<Pattern> &get_pattern_to_bind ()
+ Pattern &get_pattern_to_bind ()
{
rust_assert (has_pattern_to_bind ());
- return to_bind;
+ return *to_bind;
}
Identifier get_ident () const { return variable_ident; }
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? or is a "vis_bound" better?
- std::unique_ptr<RangePatternBound> &get_lower_bound ()
+ RangePatternBound &get_lower_bound ()
{
rust_assert (lower != nullptr);
- return lower;
+ return *lower;
}
- std::unique_ptr<RangePatternBound> &get_upper_bound ()
+ RangePatternBound &get_upper_bound ()
{
rust_assert (upper != nullptr);
- return upper;
+ return *upper;
}
NodeId get_node_id () const override { return node_id; }
void accept_vis (ASTVisitor &vis) override;
// TODO: is this better? Or is a "vis_pattern" better?
- std::unique_ptr<Pattern> &get_referenced_pattern ()
+ Pattern &get_referenced_pattern ()
{
rust_assert (pattern != nullptr);
- return pattern;
+ return *pattern;
}
bool is_double_reference () const { return has_two_amps; }
TupleIndex get_index () { return index; }
// TODO: is this better? Or is a "vis_pattern" better?
- std::unique_ptr<Pattern> &get_index_pattern ()
+ Pattern &get_index_pattern ()
{
rust_assert (tuple_pattern != nullptr);
- return tuple_pattern;
+ return *tuple_pattern;
}
ItemType get_item_type () const override final { return ItemType::TUPLE_PAT; }
const Identifier &get_identifier () const { return ident; }
// TODO: is this better? Or is a "vis_pattern" better?
- std::unique_ptr<Pattern> &get_ident_pattern ()
+ Pattern &get_ident_pattern ()
{
rust_assert (ident_pattern != nullptr);
- return ident_pattern;
+ return *ident_pattern;
}
ItemType get_item_type () const override final { return ItemType::IDENT_PAT; }
void accept_vis (ASTVisitor &vis) override;
- std::unique_ptr<TupleStructItems> &get_items ()
+ TupleStructItems &get_items ()
{
rust_assert (items != nullptr);
- return items;
+ return *items;
}
PathInExpression &get_path () { return path; }
void accept_vis (ASTVisitor &vis) override;
// TODO: seems kinda dodgy. Think of better way.
- std::unique_ptr<TuplePatternItems> &get_items ()
+ TuplePatternItems &get_items ()
{
rust_assert (items != nullptr);
- return items;
+ return *items;
}
NodeId get_node_id () const override { return node_id; }
void accept_vis (ASTVisitor &vis) override;
// TODO: seems kinda dodgy. Think of better way.
- std::unique_ptr<Pattern> &get_pattern_in_parens ()
+ Pattern &get_pattern_in_parens ()
{
rust_assert (pattern_in_parens != nullptr);
- return pattern_in_parens;
+ return *pattern_in_parens;
}
NodeId get_node_id () const override { return node_id; }
#include "rust-ast.h"
#include "rust-path.h"
#include "rust-expr.h"
+#include <memory>
namespace Rust {
namespace AST {
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_init_expr ()
+ Expr &get_init_expr ()
+ {
+ rust_assert (has_init_expr ());
+ return *init_expr;
+ }
+
+ std::unique_ptr<Expr> &get_init_expr_ptr ()
{
rust_assert (has_init_expr ());
return init_expr;
}
- std::unique_ptr<Pattern> &get_pattern ()
+ Pattern &get_pattern ()
{
rust_assert (variables_pattern != nullptr);
- return variables_pattern;
+ return *variables_pattern;
+ }
+
+ Type &get_type ()
+ {
+ rust_assert (has_type ());
+ return *type;
}
- std::unique_ptr<Type> &get_type ()
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (has_type ());
return type;
bool is_marked_for_strip () const override { return expr == nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Expr> &get_expr ()
+ Expr &get_expr ()
+ {
+ rust_assert (expr != nullptr);
+ return *expr;
+ }
+
+ std::unique_ptr<Expr> &get_expr_ptr ()
{
rust_assert (expr != nullptr);
return expr;
}
+ std::unique_ptr<Expr> take_expr ()
+ {
+ rust_assert (expr != nullptr);
+ return std::move (expr);
+ }
+
bool is_semicolon_followed () const { return semicolon_followed; }
protected:
void accept_vis (ASTVisitor &vis) override;
// TODO: would a "vis_type" be better?
- std::unique_ptr<TypeNoBounds> &get_type_pointed_to ()
+ TypeNoBounds &get_type_pointed_to ()
{
rust_assert (type != nullptr);
- return type;
+ return *type;
}
protected:
void accept_vis (ASTVisitor &vis) override;
// TODO: would a "vis_type" be better?
- std::unique_ptr<TypeNoBounds> &get_type_referenced ()
+ TypeNoBounds &get_type_referenced ()
{
rust_assert (type != nullptr);
- return type;
+ return *type;
}
bool get_has_mut () const { return has_mut; }
Lifetime &get_lifetime () { return lifetime; }
- std::unique_ptr<TypeNoBounds> &get_base_type () { return type; }
+ TypeNoBounds &get_base_type () { return *type; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (ASTVisitor &vis) override;
// TODO: would a "vis_type" be better?
- std::unique_ptr<Type> &get_elem_type ()
+ Type &get_elem_type ()
{
rust_assert (elem_type != nullptr);
- return elem_type;
+ return *elem_type;
}
// TODO: would a "vis_expr" be better?
- std::unique_ptr<Expr> &get_size_expr ()
+ Expr &get_size_expr ()
{
rust_assert (size != nullptr);
- return size;
+ return *size;
}
protected:
void accept_vis (ASTVisitor &vis) override;
// TODO: would a "vis_type" be better?
- std::unique_ptr<Type> &get_elem_type ()
+ Type &get_elem_type ()
{
rust_assert (elem_type != nullptr);
- return elem_type;
+ return *elem_type;
}
protected:
const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
// TODO: would a "vis_type" be better?
- std::unique_ptr<Type> &get_type ()
+ Type &get_type ()
+ {
+ rust_assert (param_type != nullptr);
+ return *param_type;
+ }
+
+ std::unique_ptr<Type> &get_type_ptr ()
{
rust_assert (param_type != nullptr);
return param_type;
}
// TODO: would a "vis_type" be better?
- std::unique_ptr<TypeNoBounds> &get_return_type ()
+ TypeNoBounds &get_return_type ()
{
rust_assert (has_return_type ());
- return return_type;
+ return *return_type;
}
FunctionQualifiers &get_function_qualifiers () { return function_qualifiers; }
// if functional parameter
if (!it->get ()->is_self () && !it->get ()->is_variadic ())
{
- auto param = static_cast<AST::FunctionParam *> (it->get ());
- auto kind = param->get_pattern ()->get_pattern_kind ();
+ auto ¶m = static_cast<AST::FunctionParam &> (**it);
+ auto kind = param.get_pattern ().get_pattern_kind ();
if (kind != AST::Pattern::Kind::Identifier
&& kind != AST::Pattern::Kind::Wildcard)
// expand sub-types of type, but can't strip type itself
auto &type = field.get_field_type ();
- type->accept_vis (*this);
+ type.accept_vis (*this);
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (),
- "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
// if nothing else happens, increment
++it;
// expand sub-types of type, but can't strip type itself
auto &type = field.get_field_type ();
- type->accept_vis (*this);
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (),
- "cannot strip type in this position");
+ type.accept_vis (*this);
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
// if nothing else happens, increment
++it;
// TODO: should an unwanted strip lead to break out of loop?
auto &pattern = param->get_pattern ();
- pattern->accept_vis (*this);
- if (pattern->is_marked_for_strip ())
- rust_error_at (pattern->get_locus (),
+ pattern.accept_vis (*this);
+ if (pattern.is_marked_for_strip ())
+ rust_error_at (pattern.get_locus (),
"cannot strip pattern in this position");
auto &type = param->get_type ();
- type->accept_vis (*this);
+ type.accept_vis (*this);
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (),
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (),
"cannot strip type in this position");
}
// increment
{
case AST::GenericArg::Kind::Type: {
auto &type = arg.get_type ();
- type->accept_vis (*this);
+ type.accept_vis (*this);
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (),
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (),
"cannot strip type in this position");
break;
}
case AST::GenericArg::Kind::Const: {
auto &expr = arg.get_expression ();
- expr->accept_vis (*this);
+ expr.accept_vis (*this);
- if (expr->is_marked_for_strip ())
- rust_error_at (expr->get_locus (),
+ if (expr.is_marked_for_strip ())
+ rust_error_at (expr.get_locus (),
"cannot strip expression in this position");
break;
}
for (auto &binding : args.get_binding_args ())
{
auto &type = binding.get_type ();
- type->accept_vis (*this);
+ type.accept_vis (*this);
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (),
- "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
}
}
CfgStrip::maybe_strip_qualified_path_type (AST::QualifiedPathType &path_type)
{
auto &type = path_type.get_type ();
- type->accept_vis (*this);
+ type.accept_vis (*this);
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
if (path_type.has_as_clause ())
{
}
auto &pattern = param.get_pattern ();
- pattern->accept_vis (*this);
- if (pattern->is_marked_for_strip ())
- rust_error_at (pattern->get_locus (),
+ pattern.accept_vis (*this);
+ if (pattern.is_marked_for_strip ())
+ rust_error_at (pattern.get_locus (),
"cannot strip pattern in this position");
if (param.has_type_given ())
{
auto &type = param.get_type ();
- type->accept_vis (*this);
+ type.accept_vis (*this);
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (),
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (),
"cannot strip type in this position");
}
{
auto &return_type = type_path_function.get_return_type ();
- if (return_type->is_marked_for_strip ())
- rust_error_at (return_type->get_locus (),
+ if (return_type.is_marked_for_strip ())
+ rust_error_at (return_type.get_locus (),
"cannot strip type in this position");
}
}
* allowed to have external attributes in this position so can't be
* stripped. */
auto &borrowed_expr = expr.get_borrowed_expr ();
- if (borrowed_expr->is_marked_for_strip ())
- rust_error_at (borrowed_expr->get_locus (),
+ if (borrowed_expr.is_marked_for_strip ())
+ rust_error_at (borrowed_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
* allowed to have external attributes in this position so can't be
* stripped. */
auto &dereferenced_expr = expr.get_dereferenced_expr ();
- dereferenced_expr->accept_vis (*this);
- if (dereferenced_expr->is_marked_for_strip ())
- rust_error_at (dereferenced_expr->get_locus (),
+ dereferenced_expr.accept_vis (*this);
+ if (dereferenced_expr.is_marked_for_strip ())
+ rust_error_at (dereferenced_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
* allowed to have external attributes in this position so can't be
* stripped. */
auto &propagating_expr = expr.get_propagating_expr ();
- if (propagating_expr->is_marked_for_strip ())
- rust_error_at (propagating_expr->get_locus (),
+ if (propagating_expr.is_marked_for_strip ())
+ rust_error_at (propagating_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
* allowed to have external attributes in this position so can't be
* stripped. */
auto &negated_expr = expr.get_negated_expr ();
- if (negated_expr->is_marked_for_strip ())
- rust_error_at (negated_expr->get_locus (),
+ if (negated_expr.is_marked_for_strip ())
+ rust_error_at (negated_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
* two direct descendant expressions, can strip ones below that */
// ensure that they are not marked for strip
- if (expr.get_left_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_left_expr ()->get_locus (),
+ if (expr.get_left_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_left_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes are never allowed "
"before binary op exprs");
- if (expr.get_right_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_right_expr ()->get_locus (),
+ if (expr.get_right_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_right_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
// ensure that they are not marked for strip
- if (expr.get_left_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_left_expr ()->get_locus (),
+ if (expr.get_left_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_left_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes are never allowed "
"before binary op exprs");
- if (expr.get_right_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_right_expr ()->get_locus (),
+ if (expr.get_right_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_right_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
// ensure that they are not marked for strip
- if (expr.get_left_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_left_expr ()->get_locus (),
+ if (expr.get_left_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_left_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes are never allowed "
"before binary op exprs");
- if (expr.get_right_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_right_expr ()->get_locus (),
+ if (expr.get_right_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_right_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
auto &casted_expr = expr.get_casted_expr ();
// ensure that they are not marked for strip
- if (casted_expr->is_marked_for_strip ())
- rust_error_at (casted_expr->get_locus (),
+ if (casted_expr.is_marked_for_strip ())
+ rust_error_at (casted_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes are never allowed before cast exprs");
// TODO: strip sub-types of type
auto &type = expr.get_type_to_cast_to ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
}
void
CfgStrip::visit (AST::AssignmentExpr &expr)
AST::DefaultASTVisitor::visit (expr);
// ensure that they are not marked for strip
- if (expr.get_left_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_left_expr ()->get_locus (),
+ if (expr.get_left_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_left_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes are never allowed "
"before binary op exprs");
- if (expr.get_right_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_right_expr ()->get_locus (),
+ if (expr.get_right_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_right_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
// ensure that they are not marked for strip
- if (expr.get_left_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_left_expr ()->get_locus (),
+ if (expr.get_left_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_left_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes are never allowed "
"before binary op exprs");
- if (expr.get_right_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_right_expr ()->get_locus (),
+ if (expr.get_right_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_right_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
auto &inner_expr = expr.get_expr_in_parens ();
- if (inner_expr->is_marked_for_strip ())
- rust_error_at (inner_expr->get_locus (),
+ if (inner_expr.is_marked_for_strip ())
+ rust_error_at (inner_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
// only intend stripping for internal sub-expressions
auto &copied_expr = elems.get_elem_to_copy ();
- if (copied_expr->is_marked_for_strip ())
- rust_error_at (copied_expr->get_locus (),
+ if (copied_expr.is_marked_for_strip ())
+ rust_error_at (copied_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
auto ©_count = elems.get_num_copies ();
- copy_count->accept_vis (*this);
- if (copy_count->is_marked_for_strip ())
- rust_error_at (copy_count->get_locus (),
+ copy_count.accept_vis (*this);
+ if (copy_count.is_marked_for_strip ())
+ rust_error_at (copy_count.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
const auto &array_expr = expr.get_array_expr ();
- if (array_expr->is_marked_for_strip ())
- rust_error_at (array_expr->get_locus (),
+ if (array_expr.is_marked_for_strip ())
+ rust_error_at (array_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
const auto &index_expr = expr.get_index_expr ();
- if (index_expr->is_marked_for_strip ())
- rust_error_at (index_expr->get_locus (),
+ if (index_expr.is_marked_for_strip ())
+ rust_error_at (index_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
* associated with this level), but any sub-expressions would be
* stripped. Thus, no need to erase when strip check called. */
auto &tuple_expr = expr.get_tuple_expr ();
- if (tuple_expr->is_marked_for_strip ())
- rust_error_at (tuple_expr->get_locus (),
+ if (tuple_expr.is_marked_for_strip ())
+ rust_error_at (tuple_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (field);
auto &value = field.get_value ();
- if (value->is_marked_for_strip ())
- rust_error_at (value->get_locus (),
+ if (value.is_marked_for_strip ())
+ rust_error_at (value.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (field);
auto &value = field.get_value ();
- if (value->is_marked_for_strip ())
- rust_error_at (value->get_locus (),
+ if (value.is_marked_for_strip ())
+ rust_error_at (value.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
if (expr.has_struct_base ())
{
auto &base_struct_expr = expr.get_struct_base ().get_base_struct ();
- base_struct_expr->accept_vis (*this);
- if (base_struct_expr->is_marked_for_strip ())
- rust_error_at (base_struct_expr->get_locus (),
+ base_struct_expr.accept_vis (*this);
+ if (base_struct_expr.is_marked_for_strip ())
+ rust_error_at (base_struct_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
* the expression. as such, can only strip sub-expressions. */
rust_assert (!expr.get_struct_base ().is_invalid ());
auto &base_struct_expr = expr.get_struct_base ().get_base_struct ();
- base_struct_expr->accept_vis (*this);
- if (base_struct_expr->is_marked_for_strip ())
- rust_error_at (base_struct_expr->get_locus (),
+ base_struct_expr.accept_vis (*this);
+ if (base_struct_expr.is_marked_for_strip ())
+ rust_error_at (base_struct_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
auto &function = expr.get_function_expr ();
- if (function->is_marked_for_strip ())
- rust_error_at (function->get_locus (),
+ if (function.is_marked_for_strip ())
+ rust_error_at (function.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
AST::DefaultASTVisitor::visit (expr);
auto &receiver = expr.get_receiver_expr ();
- if (receiver->is_marked_for_strip ())
- rust_error_at (receiver->get_locus (),
+ if (receiver.is_marked_for_strip ())
+ rust_error_at (receiver.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
AST::DefaultASTVisitor::visit (expr);
auto &receiver = expr.get_receiver_expr ();
- if (receiver->is_marked_for_strip ())
- rust_error_at (receiver->get_locus (),
+ if (receiver.is_marked_for_strip ())
+ rust_error_at (receiver.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
// can't strip expression itself, but can strip sub-expressions
auto &definition_expr = expr.get_definition_expr ();
- if (definition_expr->is_marked_for_strip ())
- rust_error_at (definition_expr->get_locus (),
+ if (definition_expr.is_marked_for_strip ())
+ rust_error_at (definition_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
{
auto &tail_expr = expr.get_tail_expr ();
- if (tail_expr->is_marked_for_strip ())
+ if (tail_expr.is_marked_for_strip ())
expr.strip_tail_expr ();
}
}
// can't strip return type, but can strip sub-types
auto &type = expr.get_return_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
// can't strip expression itself, but can strip sub-expressions
auto &definition_block = expr.get_definition_block ();
- definition_block->accept_vis (*this);
- if (definition_block->is_marked_for_strip ())
- rust_error_at (definition_block->get_locus (),
+ definition_block.accept_vis (*this);
+ if (definition_block.is_marked_for_strip ())
+ rust_error_at (definition_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
{
auto &break_expr = expr.get_break_expr ();
- if (break_expr->is_marked_for_strip ())
- rust_error_at (break_expr->get_locus (),
+ if (break_expr.is_marked_for_strip ())
+ rust_error_at (break_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
// ensure that they are not marked for strip
- if (expr.get_from_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_from_expr ()->get_locus (),
+ if (expr.get_from_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_from_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes are never allowed "
"before range exprs");
- if (expr.get_to_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_to_expr ()->get_locus (),
+ if (expr.get_to_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_to_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
/* should have no possibility for outer attrs as would be parsed
* with outer expr */
auto &from_expr = expr.get_from_expr ();
- if (from_expr->is_marked_for_strip ())
- rust_error_at (from_expr->get_locus (),
+ if (from_expr.is_marked_for_strip ())
+ rust_error_at (from_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes are never allowed before range exprs");
}
/* should syntactically not have outer attributes, though this may
* not have worked in practice */
auto &to_expr = expr.get_to_expr ();
- if (to_expr->is_marked_for_strip ())
- rust_error_at (to_expr->get_locus (),
+ if (to_expr.is_marked_for_strip ())
+ rust_error_at (to_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
// ensure that they are not marked for strip
- if (expr.get_from_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_from_expr ()->get_locus (),
+ if (expr.get_from_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_from_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes are never allowed "
"before range exprs");
- if (expr.get_to_expr ()->is_marked_for_strip ())
- rust_error_at (expr.get_to_expr ()->get_locus (),
+ if (expr.get_to_expr ().is_marked_for_strip ())
+ rust_error_at (expr.get_to_expr ().get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
/* should syntactically not have outer attributes, though this may
* not have worked in practice */
auto &to_expr = expr.get_to_expr ();
- if (to_expr->is_marked_for_strip ())
- rust_error_at (to_expr->get_locus (),
+ if (to_expr.is_marked_for_strip ())
+ rust_error_at (to_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
if (expr.has_returned_expr ())
{
auto &returned_expr = expr.get_returned_expr ();
- if (returned_expr->is_marked_for_strip ())
- rust_error_at (returned_expr->get_locus (),
+ if (returned_expr.is_marked_for_strip ())
+ rust_error_at (returned_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
// can't strip block itself, but can strip sub-expressions
auto &block_expr = expr.get_block_expr ();
- if (block_expr->is_marked_for_strip ())
- rust_error_at (block_expr->get_locus (),
+ if (block_expr.is_marked_for_strip ())
+ rust_error_at (block_expr.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
// can't strip block itself, but can strip sub-expressions
auto &loop_block = expr.get_loop_block ();
- if (loop_block->is_marked_for_strip ())
- rust_error_at (loop_block->get_locus (),
+ if (loop_block.is_marked_for_strip ())
+ rust_error_at (loop_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
// can't strip predicate expr itself, but can strip sub-expressions
auto &predicate_expr = expr.get_predicate_expr ();
- if (predicate_expr->is_marked_for_strip ())
- rust_error_at (predicate_expr->get_locus (),
+ if (predicate_expr.is_marked_for_strip ())
+ rust_error_at (predicate_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
// can't strip block itself, but can strip sub-expressions
auto &loop_block = expr.get_loop_block ();
- if (loop_block->is_marked_for_strip ())
- rust_error_at (loop_block->get_locus (),
+ if (loop_block.is_marked_for_strip ())
+ rust_error_at (loop_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
// can't strip scrutinee expr itself, but can strip sub-expressions
auto &scrutinee_expr = expr.get_scrutinee_expr ();
- if (scrutinee_expr->is_marked_for_strip ())
- rust_error_at (scrutinee_expr->get_locus (),
+ if (scrutinee_expr.is_marked_for_strip ())
+ rust_error_at (scrutinee_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
// can't strip block itself, but can strip sub-expressions
auto &loop_block = expr.get_loop_block ();
- if (loop_block->is_marked_for_strip ())
- rust_error_at (loop_block->get_locus (),
+ if (loop_block.is_marked_for_strip ())
+ rust_error_at (loop_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (expr);
// strip sub-patterns of pattern
auto &pattern = expr.get_pattern ();
- if (pattern->is_marked_for_strip ())
- rust_error_at (pattern->get_locus (),
+ if (pattern.is_marked_for_strip ())
+ rust_error_at (pattern.get_locus (),
"cannot strip pattern in this position");
// can't strip scrutinee expr itself, but can strip sub-expressions
auto &iterator_expr = expr.get_iterator_expr ();
- if (iterator_expr->is_marked_for_strip ())
- rust_error_at (iterator_expr->get_locus (),
+ if (iterator_expr.is_marked_for_strip ())
+ rust_error_at (iterator_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
// can't strip block itself, but can strip sub-expressions
auto &loop_block = expr.get_loop_block ();
- if (loop_block->is_marked_for_strip ())
- rust_error_at (loop_block->get_locus (),
+ if (loop_block.is_marked_for_strip ())
+ rust_error_at (loop_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
// can't strip condition expr itself, but can strip sub-expressions
auto &condition_expr = expr.get_condition_expr ();
- if (condition_expr->is_marked_for_strip ())
- rust_error_at (condition_expr->get_locus (),
+ if (condition_expr.is_marked_for_strip ())
+ rust_error_at (condition_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
// can't strip if block itself, but can strip sub-expressions
auto &if_block = expr.get_if_block ();
- if (if_block->is_marked_for_strip ())
- rust_error_at (if_block->get_locus (),
+ if (if_block.is_marked_for_strip ())
+ rust_error_at (if_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
// can't strip condition expr itself, but can strip sub-expressions
auto &condition_expr = expr.get_condition_expr ();
- if (condition_expr->is_marked_for_strip ())
- rust_error_at (condition_expr->get_locus (),
+ if (condition_expr.is_marked_for_strip ())
+ rust_error_at (condition_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
// can't strip if block itself, but can strip sub-expressions
auto &if_block = expr.get_if_block ();
- if (if_block->is_marked_for_strip ())
- rust_error_at (if_block->get_locus (),
+ if (if_block.is_marked_for_strip ())
+ rust_error_at (if_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
// can't strip else block itself, but can strip sub-expressions
auto &else_block = expr.get_else_block ();
- if (else_block->is_marked_for_strip ())
- rust_error_at (else_block->get_locus (),
+ if (else_block.is_marked_for_strip ())
+ rust_error_at (else_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
// can't strip value expr itself, but can strip sub-expressions
auto &value_expr = expr.get_value_expr ();
- if (value_expr->is_marked_for_strip ())
- rust_error_at (value_expr->get_locus (),
+ if (value_expr.is_marked_for_strip ())
+ rust_error_at (value_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
// can't strip if block itself, but can strip sub-expressions
auto &if_block = expr.get_if_block ();
- if (if_block->is_marked_for_strip ())
- rust_error_at (if_block->get_locus (),
+ if (if_block.is_marked_for_strip ())
+ rust_error_at (if_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
// can't strip value expr itself, but can strip sub-expressions
auto &value_expr = expr.get_value_expr ();
- if (value_expr->is_marked_for_strip ())
- rust_error_at (value_expr->get_locus (),
+ if (value_expr.is_marked_for_strip ())
+ rust_error_at (value_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
// can't strip if block itself, but can strip sub-expressions
auto &if_block = expr.get_if_block ();
- if (if_block->is_marked_for_strip ())
- rust_error_at (if_block->get_locus (),
+ if (if_block.is_marked_for_strip ())
+ rust_error_at (if_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
// can't strip else block itself, but can strip sub-expressions
auto &else_block = expr.get_else_block ();
- if (else_block->is_marked_for_strip ())
- rust_error_at (else_block->get_locus (),
+ if (else_block.is_marked_for_strip ())
+ rust_error_at (else_block.get_locus (),
"cannot strip block expression in this position - outer "
"attributes not allowed");
}
// can't strip scrutinee expr itself, but can strip sub-expressions
auto &scrutinee_expr = expr.get_scrutinee_expr ();
- if (scrutinee_expr->is_marked_for_strip ())
- rust_error_at (scrutinee_expr->get_locus (),
+ if (scrutinee_expr.is_marked_for_strip ())
+ rust_error_at (scrutinee_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
if (match_arm.has_match_arm_guard ())
{
auto &guard_expr = match_arm.get_guard_expr ();
- if (guard_expr->is_marked_for_strip ())
- rust_error_at (guard_expr->get_locus (),
+ if (guard_expr.is_marked_for_strip ())
+ rust_error_at (guard_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
// strip sub-expressions from match cases
auto &case_expr = match_case.get_expr ();
- if (case_expr->is_marked_for_strip ())
- rust_error_at (case_expr->get_locus (),
+ if (case_expr.is_marked_for_strip ())
+ rust_error_at (case_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
AST::DefaultASTVisitor::visit (param);
- if (param.has_type () && param.get_type ()->is_marked_for_strip ())
- rust_error_at (param.get_type ()->get_locus (),
+ if (param.has_type () && param.get_type ().is_marked_for_strip ())
+ rust_error_at (param.get_type ().get_locus (),
"cannot strip type in this position");
}
AST::DefaultASTVisitor::visit (item);
auto &type = item.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
}
void
if (function.has_return_type ())
{
auto &return_type = function.get_return_type ();
- if (return_type->is_marked_for_strip ())
- rust_error_at (return_type->get_locus (),
+ if (return_type.is_marked_for_strip ())
+ rust_error_at (return_type.get_locus (),
"cannot strip type in this position");
}
AST::DefaultASTVisitor::visit (type_alias);
auto &type = type_alias.get_type_aliased ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
}
void
* allowed to have external attributes in this position so can't be
* stripped. */
auto &expr = item.get_expr ();
- if (expr->is_marked_for_strip ())
- rust_error_at (expr->get_locus (),
+ if (expr.is_marked_for_strip ())
+ rust_error_at (expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
// strip any sub-types
auto &type = const_item.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
/* strip any internal sub-expressions - expression itself isn't
* allowed to have external attributes in this position so can't be
if (const_item.has_expr ())
{
auto &expr = const_item.get_expr ();
- if (expr->is_marked_for_strip ())
- rust_error_at (expr->get_locus (),
+ if (expr.is_marked_for_strip ())
+ rust_error_at (expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
// strip any sub-types
auto &type = static_item.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
/* strip any internal sub-expressions - expression itself isn't
* allowed to have external attributes in this position so can't be
* stripped. */
auto &expr = static_item.get_expr ();
- if (expr->is_marked_for_strip ())
- rust_error_at (expr->get_locus (),
+ if (expr.is_marked_for_strip ())
+ rust_error_at (expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
// strip any sub-types
auto &type = item.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
/* strip any internal sub-expressions - expression itself isn't
* allowed to have external attributes in this position so can't be
if (item.has_expression ())
{
auto &expr = item.get_expr ();
- if (expr->is_marked_for_strip ())
- rust_error_at (expr->get_locus (),
+ if (expr.is_marked_for_strip ())
+ rust_error_at (expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
auto &type = impl.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
maybe_strip_pointer_allow_strip (impl.get_impl_items ());
}
AST::DefaultASTVisitor::visit (impl);
auto &type = impl.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
auto &trait_path = impl.get_trait_path ();
visit (trait_path);
AST::DefaultASTVisitor::visit (item);
auto &type = item.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (), "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
}
void
AST::DefaultASTVisitor::visit (pattern);
auto &sub_pattern = pattern.get_pattern_to_bind ();
- if (sub_pattern->is_marked_for_strip ())
- rust_error_at (sub_pattern->get_locus (),
+ if (sub_pattern.is_marked_for_strip ())
+ rust_error_at (sub_pattern.get_locus (),
"cannot strip pattern in this position");
}
AST::DefaultASTVisitor::visit (pattern);
auto &sub_pattern = pattern.get_referenced_pattern ();
- if (sub_pattern->is_marked_for_strip ())
- rust_error_at (sub_pattern->get_locus (),
+ if (sub_pattern.is_marked_for_strip ())
+ rust_error_at (sub_pattern.get_locus (),
"cannot strip pattern in this position");
}
void
// strip sub-patterns (can't strip top-level pattern)
auto &sub_pattern = field.get_index_pattern ();
- if (sub_pattern->is_marked_for_strip ())
- rust_error_at (sub_pattern->get_locus (),
+ if (sub_pattern.is_marked_for_strip ())
+ rust_error_at (sub_pattern.get_locus (),
"cannot strip pattern in this position");
}
AST::DefaultASTVisitor::visit (field);
// strip sub-patterns (can't strip top-level pattern)
auto &sub_pattern = field.get_ident_pattern ();
- if (sub_pattern->is_marked_for_strip ())
- rust_error_at (sub_pattern->get_locus (),
+ if (sub_pattern.is_marked_for_strip ())
+ rust_error_at (sub_pattern.get_locus (),
"cannot strip pattern in this position");
}
void
// can't strip inner pattern, only sub-patterns
auto &pattern_in_parens = pattern.get_pattern_in_parens ();
- if (pattern_in_parens->is_marked_for_strip ())
- rust_error_at (pattern_in_parens->get_locus (),
+ if (pattern_in_parens.is_marked_for_strip ())
+ rust_error_at (pattern_in_parens.get_locus (),
"cannot strip pattern in this position");
}
AST::DefaultASTVisitor::visit (stmt);
// can't strip pattern, but call for sub-patterns
auto &pattern = stmt.get_pattern ();
- if (pattern->is_marked_for_strip ())
- rust_error_at (pattern->get_locus (),
+ if (pattern.is_marked_for_strip ())
+ rust_error_at (pattern.get_locus (),
"cannot strip pattern in this position");
// similar for type
{
auto &type = stmt.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (),
- "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
}
/* strip any internal sub-expressions - expression itself isn't
{
auto &init_expr = stmt.get_init_expr ();
- if (init_expr->is_marked_for_strip ())
- rust_error_at (init_expr->get_locus (),
+ if (init_expr.is_marked_for_strip ())
+ rust_error_at (init_expr.get_locus (),
"cannot strip expression in this position - outer "
"attributes not allowed");
}
AST::DefaultASTVisitor::visit (stmt);
// strip if expr is to be stripped
auto &expr = stmt.get_expr ();
- if (expr->is_marked_for_strip ())
+ if (expr.is_marked_for_strip ())
{
stmt.mark_for_strip ();
return;
AST::DefaultASTVisitor::visit (type);
// expand but don't strip type pointed to
auto &pointed_type = type.get_type_pointed_to ();
- if (pointed_type->is_marked_for_strip ())
- rust_error_at (pointed_type->get_locus (),
+ if (pointed_type.is_marked_for_strip ())
+ rust_error_at (pointed_type.get_locus (),
"cannot strip type in this position");
}
AST::DefaultASTVisitor::visit (type);
// expand but don't strip type referenced
auto &referenced_type = type.get_type_referenced ();
- if (referenced_type->is_marked_for_strip ())
- rust_error_at (referenced_type->get_locus (),
+ if (referenced_type.is_marked_for_strip ())
+ rust_error_at (referenced_type.get_locus (),
"cannot strip type in this position");
}
AST::DefaultASTVisitor::visit (type);
// expand but don't strip type referenced
auto &base_type = type.get_elem_type ();
- if (base_type->is_marked_for_strip ())
- rust_error_at (base_type->get_locus (),
+ if (base_type.is_marked_for_strip ())
+ rust_error_at (base_type.get_locus (),
"cannot strip type in this position");
// same for expression
auto &size_expr = type.get_size_expr ();
- if (size_expr->is_marked_for_strip ())
- rust_error_at (size_expr->get_locus (),
+ if (size_expr.is_marked_for_strip ())
+ rust_error_at (size_expr.get_locus (),
"cannot strip expression in this position");
}
void
AST::DefaultASTVisitor::visit (type);
// expand but don't strip elem type
auto &elem_type = type.get_elem_type ();
- if (elem_type->is_marked_for_strip ())
- rust_error_at (elem_type->get_locus (),
+ if (elem_type.is_marked_for_strip ())
+ rust_error_at (elem_type.get_locus (),
"cannot strip type in this position");
}
}
auto &type = param.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (),
- "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
// increment if nothing else happens
++it;
// In that case, we need to handle AST::TypeNoBounds on top of just
// AST::Types
auto &return_type = type.get_return_type ();
- if (return_type->is_marked_for_strip ())
- rust_error_at (return_type->get_locus (),
+ if (return_type.is_marked_for_strip ())
+ rust_error_at (return_type.get_locus (),
"cannot strip type in this position");
}
if (param.has_type ())
{
auto &type = param.get_type ();
- if (type->is_marked_for_strip ())
- rust_error_at (type->get_locus (),
- "cannot strip type in this position");
+ if (type.is_marked_for_strip ())
+ rust_error_at (type.get_locus (), "cannot strip type in this position");
}
/* TODO: maybe check for invariants being violated - e.g. both type and
* lifetime? */
{
for (auto &field : fields)
{
- maybe_expand_type (field.get_field_type ());
+ maybe_expand_type (field.get_field_type_ptr ());
}
}
ExpandVisitor::expand_tuple_fields (std::vector<AST::TupleField> &fields)
{
for (auto &field : fields)
- maybe_expand_type (field.get_field_type ());
+ maybe_expand_type (field.get_field_type_ptr ());
}
// FIXME: This can definitely be refactored with the method above
switch (arg.get_kind ())
{
case AST::GenericArg::Kind::Type:
- maybe_expand_type (arg.get_type ());
+ maybe_expand_type (arg.get_type_ptr ());
break;
case AST::GenericArg::Kind::Const:
- maybe_expand_expr (arg.get_expression ());
+ maybe_expand_expr (arg.get_expression_ptr ());
break;
default:
break;
// expand binding args - strip sub-types only
// FIXME: ARTHUR: This needs a test! Foo<Item = macro!()>
for (auto &binding : args.get_binding_args ())
- maybe_expand_type (binding.get_type ());
+ maybe_expand_type (binding.get_type_ptr ());
}
void
ExpandVisitor::expand_qualified_path_type (AST::QualifiedPathType &path_type)
{
- maybe_expand_type (path_type.get_type ());
+ maybe_expand_type (path_type.get_type_ptr ());
// FIXME: ARTHUR: Can we do macro expansion in there? Needs a test!
if (path_type.has_as_clause ())
for (auto ¶m : params)
{
if (param.has_type_given ())
- maybe_expand_type (param.get_type ());
+ maybe_expand_type (param.get_type_ptr ());
}
}
visit (type);
if (type_path_function.has_return_type ())
- maybe_expand_type (type_path_function.get_return_type ());
+ maybe_expand_type (type_path_function.get_return_type_ptr ());
}
void
void
ExpandVisitor::visit (AST::ArithmeticOrLogicalExpr &expr)
{
- maybe_expand_expr (expr.get_left_expr ());
- maybe_expand_expr (expr.get_right_expr ());
+ maybe_expand_expr (expr.get_left_expr_ptr ());
+ maybe_expand_expr (expr.get_right_expr_ptr ());
}
void
ExpandVisitor::visit (AST::ComparisonExpr &expr)
{
- maybe_expand_expr (expr.get_left_expr ());
- maybe_expand_expr (expr.get_right_expr ());
+ maybe_expand_expr (expr.get_left_expr_ptr ());
+ maybe_expand_expr (expr.get_right_expr_ptr ());
}
void
ExpandVisitor::visit (AST::LazyBooleanExpr &expr)
{
- maybe_expand_expr (expr.get_left_expr ());
- maybe_expand_expr (expr.get_right_expr ());
+ maybe_expand_expr (expr.get_left_expr_ptr ());
+ maybe_expand_expr (expr.get_right_expr_ptr ());
}
void
ExpandVisitor::visit (AST::AssignmentExpr &expr)
{
- maybe_expand_expr (expr.get_left_expr ());
- maybe_expand_expr (expr.get_right_expr ());
+ maybe_expand_expr (expr.get_left_expr_ptr ());
+ maybe_expand_expr (expr.get_right_expr_ptr ());
}
void
ExpandVisitor::visit (AST::CompoundAssignmentExpr &expr)
{
- maybe_expand_expr (expr.get_left_expr ());
- maybe_expand_expr (expr.get_right_expr ());
+ maybe_expand_expr (expr.get_left_expr_ptr ());
+ maybe_expand_expr (expr.get_right_expr_ptr ());
}
void
ExpandVisitor::visit (AST::GroupedExpr &expr)
{
- maybe_expand_expr (expr.get_expr_in_parens ());
+ maybe_expand_expr (expr.get_expr_in_parens_ptr ());
}
void
expand_tail_expr (expr, expander);
if (expr.has_tail_expr ())
- maybe_expand_expr (expr.get_tail_expr ());
+ maybe_expand_expr (expr.get_tail_expr_ptr ());
}
void
{
expand_closure_params (expr.get_params ());
- maybe_expand_type (expr.get_return_type ());
+ maybe_expand_type (expr.get_return_type_ptr ());
visit (expr.get_definition_block ());
}
void
ExpandVisitor::visit (AST::IfExpr &expr)
{
- maybe_expand_expr (expr.get_condition_expr ());
+ maybe_expand_expr (expr.get_condition_expr_ptr ());
visit (expr.get_if_block ());
}
void
ExpandVisitor::visit (AST::IfExprConseqElse &expr)
{
- maybe_expand_expr (expr.get_condition_expr ());
+ maybe_expand_expr (expr.get_condition_expr_ptr ());
visit (expr.get_if_block ());
visit (expr.get_else_block ());
void
ExpandVisitor::visit (AST::IfLetExpr &expr)
{
- maybe_expand_expr (expr.get_value_expr ());
+ maybe_expand_expr (expr.get_value_expr_ptr ());
visit (expr.get_if_block ());
}
void
ExpandVisitor::visit (AST::IfLetExprConseqElse &expr)
{
- maybe_expand_expr (expr.get_value_expr ());
+ maybe_expand_expr (expr.get_value_expr_ptr ());
visit (expr.get_if_block ());
visit (expr.get_else_block ());
visit (pattern);
if (arm.has_match_arm_guard ())
- maybe_expand_expr (arm.get_guard_expr ());
+ maybe_expand_expr (arm.get_guard_expr_ptr ());
- maybe_expand_expr (match_case.get_expr ());
+ maybe_expand_expr (match_case.get_expr_ptr ());
}
}
visit (bound);
if (param.has_type ())
- maybe_expand_type (param.get_type ());
+ maybe_expand_type (param.get_type_ptr ());
}
void
void
ExpandVisitor::visit (AST::TypeBoundWhereClauseItem &item)
{
- maybe_expand_type (item.get_type ());
+ maybe_expand_type (item.get_type_ptr ());
for (auto &bound : item.get_type_param_bounds ())
visit (bound);
expand_function_params (function.get_function_params ());
if (function.has_return_type ())
- maybe_expand_type (function.get_return_type ());
+ maybe_expand_type (function.get_return_type_ptr ());
if (function.has_where_clause ())
expand_where_clause (function.get_where_clause ());
void
ExpandVisitor::visit (AST::EnumItemDiscriminant &item)
{
- maybe_expand_expr (item.get_expr ());
+ maybe_expand_expr (item.get_expr_ptr ());
}
void
void
ExpandVisitor::visit (AST::ConstantItem &const_item)
{
- maybe_expand_type (const_item.get_type ());
+ maybe_expand_type (const_item.get_type_ptr ());
if (const_item.has_expr ())
- maybe_expand_expr (const_item.get_expr ());
+ maybe_expand_expr (const_item.get_expr_ptr ());
}
void
ExpandVisitor::visit (AST::StaticItem &static_item)
{
- maybe_expand_type (static_item.get_type ());
+ maybe_expand_type (static_item.get_type_ptr ());
- maybe_expand_expr (static_item.get_expr ());
+ maybe_expand_expr (static_item.get_expr_ptr ());
}
void
ExpandVisitor::visit (AST::TraitItemConst &const_item)
{
- maybe_expand_type (const_item.get_type ());
+ maybe_expand_type (const_item.get_type_ptr ());
if (const_item.has_expr ())
- maybe_expand_expr (const_item.get_expr ());
+ maybe_expand_expr (const_item.get_expr_ptr ());
}
void
// FIXME: Is that correct? How do we test that?
expander.push_context (MacroExpander::ContextType::ITEM);
- maybe_expand_type (impl.get_type ());
+ maybe_expand_type (impl.get_type_ptr ());
expander.pop_context ();
// FIXME: Is that correct? How do we test that?
expander.push_context (MacroExpander::ContextType::ITEM);
- maybe_expand_type (impl.get_type ());
+ maybe_expand_type (impl.get_type_ptr ());
expander.pop_context ();
void
ExpandVisitor::visit (AST::ExternalStaticItem &static_item)
{
- maybe_expand_type (static_item.get_type ());
+ maybe_expand_type (static_item.get_type_ptr ());
}
void
visit (stmt.get_pattern ());
if (stmt.has_type ())
- maybe_expand_type (stmt.get_type ());
+ maybe_expand_type (stmt.get_type_ptr ());
if (stmt.has_init_expr ())
- maybe_expand_expr (stmt.get_init_expr ());
+ maybe_expand_expr (stmt.get_init_expr_ptr ());
}
void
ExpandVisitor::visit (AST::ExprStmt &stmt)
{
- maybe_expand_expr (stmt.get_expr ());
+ maybe_expand_expr (stmt.get_expr_ptr ());
}
void
{
for (auto ¶m : type.get_function_params ())
{
- maybe_expand_type (param.get_type ());
+ maybe_expand_type (param.get_type_ptr ());
}
if (type.has_return_type ())
void
ExpandVisitor::visit (AST::FunctionParam ¶m)
{
- maybe_expand_type (param.get_type ());
+ maybe_expand_type (param.get_type_ptr ());
}
void
/* TODO: maybe check for invariants being violated - e.g. both type and
* lifetime? */
if (param.has_type ())
- maybe_expand_type (param.get_type ());
+ maybe_expand_type (param.get_type_ptr ());
}
template <typename T>
using AST::DefaultASTVisitor::visit;
- /* Maybe expand a macro invocation in lieu of an expression */
+ /*
+ Maybe expand a macro invocation in lieu of an expression
+ expr : Core guidelines R33, this function reseat the pointer.
+ */
void maybe_expand_expr (std::unique_ptr<AST::Expr> &expr);
- /* Maybe expand a macro invocation in lieu of a type */
+ /*
+ Maybe expand a macro invocation in lieu of a type
+ type : Core guidelines R33, this function reseat the pointer.
+ */
void maybe_expand_type (std::unique_ptr<AST::Type> &type);
/**
std::vector<std::unique_ptr<HIR::GenericParam>> lowered;
for (auto &ast_param : params)
{
- auto hir_param = ASTLowerGenericParam::translate (ast_param.get ());
+ auto hir_param = ASTLowerGenericParam::translate (*ast_param);
lowered.push_back (std::unique_ptr<HIR::GenericParam> (hir_param));
}
HIR::GenericArgsBinding
ASTLoweringBase::lower_binding (AST::GenericArgsBinding &binding)
{
- HIR::Type *lowered_type
- = ASTLoweringType::translate (binding.get_type ().get ());
+ HIR::Type *lowered_type = ASTLoweringType::translate (binding.get_type ());
return HIR::GenericArgsBinding (binding.get_identifier (),
std::unique_ptr<HIR::Type> (lowered_type),
binding.get_locus ());
switch (arg.get_kind ())
{
case AST::GenericArg::Kind::Type: {
- auto type = ASTLoweringType::translate (arg.get_type ().get ());
+ auto type = ASTLoweringType::translate (arg.get_type ());
type_args.emplace_back (std::unique_ptr<HIR::Type> (type));
break;
}
case AST::GenericArg::Kind::Const: {
- auto expr
- = ASTLoweringExpr::translate (arg.get_expression ().get ());
+ auto expr = ASTLoweringExpr::translate (arg.get_expression ());
const_args.emplace_back (
HIR::ConstGenericArg (std::unique_ptr<HIR::Expr> (expr),
expr->get_locus ()));
if (self.has_type ())
{
- HIR::Type *type = ASTLoweringType::translate (self.get_type ().get ());
+ HIR::Type *type = ASTLoweringType::translate (self.get_type ());
return HIR::SelfParam (mapping, std::unique_ptr<HIR::Type> (type),
self.get_is_mut (), self.get_locus ());
}
}
HIR::Type *
-ASTLoweringBase::lower_type_no_bounds (AST::TypeNoBounds *type)
+ASTLoweringBase::lower_type_no_bounds (AST::TypeNoBounds &type)
{
return ASTLoweringType::translate (type);
}
HIR::TypeParamBound *
-ASTLoweringBase::lower_bound (AST::TypeParamBound *bound)
+ASTLoweringBase::lower_bound (AST::TypeParamBound &bound)
{
return ASTLoweringTypeBounds::translate (bound);
}
std::vector<std::unique_ptr<HIR::Pattern>> patterns;
for (auto &p : pattern.get_patterns ())
{
- HIR::Pattern *translated = ASTLoweringPattern::translate (p.get ());
+ HIR::Pattern *translated = ASTLoweringPattern::translate (*p);
patterns.push_back (std::unique_ptr<HIR::Pattern> (translated));
}
for (auto &p : pattern.get_lower_patterns ())
{
- HIR::Pattern *translated = ASTLoweringPattern::translate (p.get ());
+ HIR::Pattern *translated = ASTLoweringPattern::translate (*p);
lower_patterns.push_back (std::unique_ptr<HIR::Pattern> (translated));
}
for (auto &p : pattern.get_upper_patterns ())
{
- HIR::Pattern *translated = ASTLoweringPattern::translate (p.get ());
+ HIR::Pattern *translated = ASTLoweringPattern::translate (*p);
upper_patterns.push_back (std::unique_ptr<HIR::Pattern> (translated));
}
}
std::unique_ptr<HIR::RangePatternBound>
-ASTLoweringBase::lower_range_pattern_bound (AST::RangePatternBound *bound)
+ASTLoweringBase::lower_range_pattern_bound (AST::RangePatternBound &bound)
{
std::unique_ptr<HIR::RangePatternBound> hir_bound = nullptr;
- switch (bound->get_bound_type ())
+ switch (bound.get_bound_type ())
{
case AST::RangePatternBound::RangePatternBoundType::LITERAL: {
AST::RangePatternBoundLiteral &ref
- = *static_cast<AST::RangePatternBoundLiteral *> (bound);
+ = static_cast<AST::RangePatternBoundLiteral &> (bound);
HIR::Literal literal = lower_literal (ref.get_literal ());
}
break;
case AST::RangePatternBound::RangePatternBoundType::PATH: {
- AST::RangePatternBoundPath &ref
- = *static_cast<AST::RangePatternBoundPath *> (bound);
+ auto &ref = static_cast<AST::RangePatternBoundPath &> (bound);
HIR::PathInExpression *path
- = ASTLowerPathInExpression::translate (&ref.get_path ());
+ = ASTLowerPathInExpression::translate (ref.get_path ());
hir_bound = std::unique_ptr<HIR::RangePatternBound> (
new HIR::RangePatternBoundPath (*path));
}
break;
case AST::RangePatternBound::RangePatternBoundType::QUALPATH: {
- AST::RangePatternBoundQualPath &ref
- = *static_cast<AST::RangePatternBoundQualPath *> (bound);
+ auto &ref = static_cast<AST::RangePatternBoundQualPath &> (bound);
HIR::QualifiedPathInExpression *qualpath
- = ASTLowerQualPathInExpression::translate (
- &ref.get_qualified_path ());
+ = ASTLowerQualPathInExpression::translate (ref.get_qualified_path ());
hir_bound = std::unique_ptr<HIR::RangePatternBound> (
new HIR::RangePatternBoundQualPath (*qualpath));
HIR::SelfParam lower_self (AST::Param &self);
- HIR::Type *lower_type_no_bounds (AST::TypeNoBounds *type);
+ HIR::Type *lower_type_no_bounds (AST::TypeNoBounds &type);
- HIR::TypeParamBound *lower_bound (AST::TypeParamBound *bound);
+ HIR::TypeParamBound *lower_bound (AST::TypeParamBound &bound);
HIR::QualifiedPathType
lower_qual_path_type (AST::QualifiedPathType &qual_path_type);
lower_tuple_pattern_ranged (AST::TuplePatternItemsRanged &pattern);
std::unique_ptr<HIR::RangePatternBound>
- lower_range_pattern_bound (AST::RangePatternBound *bound);
+ lower_range_pattern_bound (AST::RangePatternBound &bound);
HIR::Literal lower_literal (const AST::Literal &literal);
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::BlockExpr *translate (AST::BlockExpr *expr, bool *terminated)
+ static HIR::BlockExpr *translate (AST::BlockExpr &expr, bool *terminated)
{
ASTLoweringBlock resolver;
- expr->normalize_tail_expr ();
- expr->accept_vis (resolver);
+ expr.normalize_tail_expr ();
+ expr.accept_vis (resolver);
if (resolver.translated != nullptr)
{
resolver.mappings->insert_hir_expr (resolver.translated);
return resolver.translated;
}
- static HIR::UnsafeBlockExpr *translate (AST::UnsafeBlockExpr *expr,
+ static HIR::UnsafeBlockExpr *translate (AST::UnsafeBlockExpr &expr,
bool *terminated)
{
ASTLoweringBlock resolver;
HIR::BlockExpr *block
- = ASTLoweringBlock::translate (expr->get_block_expr ().get (),
- terminated);
+ = ASTLoweringBlock::translate (expr.get_block_expr (), terminated);
auto crate_num = resolver.mappings->get_current_crate ();
- Analysis::NodeMapping mapping (crate_num, expr->get_node_id (),
+ Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
resolver.mappings->get_next_hir_id (
crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::UnsafeBlockExpr *translated
= new HIR::UnsafeBlockExpr (mapping,
std::unique_ptr<HIR::BlockExpr> (block),
- expr->get_outer_attrs (), expr->get_locus ());
+ expr.get_outer_attrs (), expr.get_locus ());
resolver.mappings->insert_hir_expr (translated);
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::IfExpr *translate (AST::IfExpr *expr, bool *terminated)
+ static HIR::IfExpr *translate (AST::IfExpr &expr, bool *terminated)
{
ASTLoweringIfBlock resolver;
- expr->accept_vis (resolver);
+ expr.accept_vis (resolver);
if (resolver.translated != nullptr)
{
resolver.mappings->insert_hir_expr (resolver.translated);
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::IfLetExpr *translate (AST::IfLetExpr *expr)
+ static HIR::IfLetExpr *translate (AST::IfLetExpr &expr)
{
ASTLoweringIfLetBlock resolver;
- expr->accept_vis (resolver);
+ expr.accept_vis (resolver);
if (resolver.translated != nullptr)
{
resolver.mappings->insert_hir_expr (resolver.translated);
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::ExprWithBlock *translate (AST::ExprWithBlock *expr,
+ static HIR::ExprWithBlock *translate (AST::ExprWithBlock &expr,
bool *terminated)
{
ASTLoweringExprWithBlock resolver;
- expr->accept_vis (resolver);
+ expr.accept_vis (resolver);
if (resolver.translated != nullptr)
{
resolver.mappings->insert_hir_expr (resolver.translated);
void visit (AST::IfExpr &expr) override
{
- translated = ASTLoweringIfBlock::translate (&expr, &terminated);
+ translated = ASTLoweringIfBlock::translate (expr, &terminated);
}
void visit (AST::IfExprConseqElse &expr) override
{
- translated = ASTLoweringIfBlock::translate (&expr, &terminated);
+ translated = ASTLoweringIfBlock::translate (expr, &terminated);
}
void visit (AST::IfLetExpr &expr) override
{
- translated = ASTLoweringIfLetBlock::translate (&expr);
+ translated = ASTLoweringIfLetBlock::translate (expr);
}
void visit (AST::IfLetExprConseqElse &expr) override
{
- translated = ASTLoweringIfLetBlock::translate (&expr);
+ translated = ASTLoweringIfLetBlock::translate (expr);
}
void visit (AST::BlockExpr &expr) override
{
- translated = ASTLoweringBlock::translate (&expr, &terminated);
+ translated = ASTLoweringBlock::translate (expr, &terminated);
}
void visit (AST::UnsafeBlockExpr &expr) override
{
- translated = ASTLoweringBlock::translate (&expr, &terminated);
+ translated = ASTLoweringBlock::translate (expr, &terminated);
}
void visit (AST::LoopExpr &expr) override
{
HIR::BlockExpr *loop_block
- = ASTLoweringBlock::translate (expr.get_loop_block ().get (),
- &terminated);
+ = ASTLoweringBlock::translate (expr.get_loop_block (), &terminated);
HIR::LoopLabel loop_label = lower_loop_label (expr.get_loop_label ());
for (auto &field : item.get_tuple_fields ())
{
HIR::Visibility vis = translate_visibility (field.get_visibility ());
- HIR::Type *type
- = ASTLoweringType::translate (field.get_field_type ().get ());
+ HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping field_mapping (
for (auto &field : item.get_struct_fields ())
{
HIR::Visibility vis = translate_visibility (field.get_visibility ());
- HIR::Type *type
- = ASTLoweringType::translate (field.get_field_type ().get ());
+ HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping field_mapping (
"visibility qualifier %qs not allowed on enum item",
item.get_visibility ().as_string ().c_str ());
- HIR::Expr *expr = ASTLoweringExpr::translate (item.get_expr ().get ());
+ HIR::Expr *expr = ASTLoweringExpr::translate (item.get_expr ());
translated
= new HIR::EnumItemDiscriminant (mapping, item.get_identifier (),
std::unique_ptr<HIR::Expr> (expr),
{}
HIR::Expr *
-ASTLoweringExpr::translate (AST::Expr *expr, bool *terminated)
+ASTLoweringExpr::translate (AST::Expr &expr, bool *terminated)
{
ASTLoweringExpr resolver;
- expr->accept_vis (resolver);
+ expr.accept_vis (resolver);
if (resolver.translated == nullptr)
{
- rust_fatal_error (expr->get_locus (), "Failed to lower expr: [%s]",
- expr->as_string ().c_str ());
+ rust_fatal_error (expr.get_locus (), "Failed to lower expr: [%s]",
+ expr.as_string ().c_str ());
return nullptr;
}
resolver.mappings->insert_hir_expr (resolver.translated);
resolver.mappings->insert_location (
- resolver.translated->get_mappings ().get_hirid (), expr->get_locus ());
+ resolver.translated->get_mappings ().get_hirid (), expr.get_locus ());
if (terminated != nullptr)
*terminated = resolver.terminated;
ASTLoweringExpr::visit (AST::TupleIndexExpr &expr)
{
HIR::Expr *tuple_expr
- = ASTLoweringExpr::translate (expr.get_tuple_expr ().get (), &terminated);
+ = ASTLoweringExpr::translate (expr.get_tuple_expr (), &terminated);
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
std::vector<std::unique_ptr<HIR::Expr> > tuple_elements;
for (auto &e : expr.get_tuple_elems ())
{
- HIR::Expr *t = ASTLoweringExpr::translate (e.get ());
+ HIR::Expr *t = ASTLoweringExpr::translate (*e);
tuple_elements.push_back (std::unique_ptr<HIR::Expr> (t));
}
void
ASTLoweringExpr::visit (AST::IfExpr &expr)
{
- translated = ASTLoweringIfBlock::translate (&expr, &terminated);
+ translated = ASTLoweringIfBlock::translate (expr, &terminated);
}
void
ASTLoweringExpr::visit (AST::IfExprConseqElse &expr)
{
- translated = ASTLoweringIfBlock::translate (&expr, &terminated);
+ translated = ASTLoweringIfBlock::translate (expr, &terminated);
}
void
ASTLoweringExpr::visit (AST::IfLetExpr &expr)
{
- translated = ASTLoweringIfLetBlock::translate (&expr);
+ translated = ASTLoweringIfLetBlock::translate (expr);
}
void
ASTLoweringExpr::visit (AST::IfLetExprConseqElse &expr)
{
- translated = ASTLoweringIfLetBlock::translate (&expr);
+ translated = ASTLoweringIfLetBlock::translate (expr);
}
void
ASTLoweringExpr::visit (AST::BlockExpr &expr)
{
- translated = ASTLoweringBlock::translate (&expr, &terminated);
+ translated = ASTLoweringBlock::translate (expr, &terminated);
}
void
ASTLoweringExpr::visit (AST::UnsafeBlockExpr &expr)
{
- translated = ASTLoweringBlock::translate (&expr, &terminated);
+ translated = ASTLoweringBlock::translate (expr, &terminated);
}
void
ASTLoweringExpr::visit (AST::PathInExpression &expr)
{
- translated = ASTLowerPathInExpression::translate (&expr);
+ translated = ASTLowerPathInExpression::translate (expr);
}
void
ASTLoweringExpr::visit (AST::QualifiedPathInExpression &expr)
{
- translated = ASTLowerQualPathInExpression::translate (&expr);
+ translated = ASTLowerQualPathInExpression::translate (expr);
}
void
terminated = true;
HIR::Expr *return_expr
= expr.has_returned_expr ()
- ? ASTLoweringExpr::translate (expr.get_returned_expr ().get ())
+ ? ASTLoweringExpr::translate (expr.get_returned_expr ())
: nullptr;
auto crate_num = mappings->get_current_crate ();
void
ASTLoweringExpr::visit (AST::CallExpr &expr)
{
- HIR::Expr *func
- = ASTLoweringExpr::translate (expr.get_function_expr ().get ());
+ HIR::Expr *func = ASTLoweringExpr::translate (expr.get_function_expr ());
auto const &in_params = expr.get_params ();
std::vector<std::unique_ptr<HIR::Expr> > params;
for (auto ¶m : in_params)
{
- auto trans = ASTLoweringExpr::translate (param.get ());
+ auto trans = ASTLoweringExpr::translate (*param);
params.push_back (std::unique_ptr<HIR::Expr> (trans));
}
HIR::PathExprSegment method_path
= lower_path_expr_seg (expr.get_method_name ());
- HIR::Expr *receiver
- = ASTLoweringExpr::translate (expr.get_receiver_expr ().get ());
+ HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
auto const &in_params = expr.get_params ();
std::vector<std::unique_ptr<HIR::Expr> > params;
for (auto ¶m : in_params)
{
- auto trans = ASTLoweringExpr::translate (param.get ());
+ auto trans = ASTLoweringExpr::translate (*param);
params.push_back (std::unique_ptr<HIR::Expr> (trans));
}
void
ASTLoweringExpr::visit (AST::AssignmentExpr &expr)
{
- HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ().get ());
- HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ().get ());
+ HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
+ HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
void
ASTLoweringExpr::visit (AST::ArrayIndexExpr &expr)
{
- HIR::Expr *array_expr
- = ASTLoweringExpr::translate (expr.get_array_expr ().get ());
+ HIR::Expr *array_expr = ASTLoweringExpr::translate (expr.get_array_expr ());
HIR::Expr *array_index_expr
- = ASTLoweringExpr::translate (expr.get_index_expr ().get ());
+ = ASTLoweringExpr::translate (expr.get_index_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
std::vector<std::unique_ptr<HIR::Expr> > elements;
for (auto &elem : elems.get_values ())
{
- HIR::Expr *translated_elem = ASTLoweringExpr::translate (elem.get ());
+ HIR::Expr *translated_elem = ASTLoweringExpr::translate (*elem);
elements.push_back (std::unique_ptr<HIR::Expr> (translated_elem));
}
void
ASTLoweringExpr::visit (AST::ArrayElemsCopied &elems)
{
- HIR::Expr *element
- = ASTLoweringExpr::translate (elems.get_elem_to_copy ().get ());
- HIR::Expr *num_copies
- = ASTLoweringExpr::translate (elems.get_num_copies ().get ());
+ HIR::Expr *element = ASTLoweringExpr::translate (elems.get_elem_to_copy ());
+ HIR::Expr *num_copies = ASTLoweringExpr::translate (elems.get_num_copies ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (mappings->get_current_crate (),
void
ASTLoweringExpr::visit (AST::ArithmeticOrLogicalExpr &expr)
{
- HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ().get ());
+ HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
rust_assert (lhs != nullptr);
- HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ().get ());
+ HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
rust_assert (rhs != nullptr);
auto crate_num = mappings->get_current_crate ();
void
ASTLoweringExpr::visit (AST::ComparisonExpr &expr)
{
- HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ().get ());
+ HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
rust_assert (lhs != nullptr);
- HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ().get ());
+ HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
rust_assert (rhs != nullptr);
auto crate_num = mappings->get_current_crate ();
void
ASTLoweringExpr::visit (AST::LazyBooleanExpr &expr)
{
- HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ().get ());
+ HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
rust_assert (lhs != nullptr);
- HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ().get ());
+ HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
rust_assert (rhs != nullptr);
auto crate_num = mappings->get_current_crate ();
ASTLoweringExpr::visit (AST::NegationExpr &expr)
{
HIR::Expr *negated_value
- = ASTLoweringExpr::translate (expr.get_negated_expr ().get ());
+ = ASTLoweringExpr::translate (expr.get_negated_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
ASTLoweringExpr::visit (AST::TypeCastExpr &expr)
{
HIR::Expr *expr_to_cast_to
- = ASTLoweringExpr::translate (expr.get_casted_expr ().get ());
+ = ASTLoweringExpr::translate (expr.get_casted_expr ());
HIR::Type *type_to_cast_to
- = lower_type_no_bounds (expr.get_type_to_cast_to ().get ());
+ = lower_type_no_bounds (expr.get_type_to_cast_to ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
rust_unreachable ();
}
- HIR::Expr *asignee_expr
- = ASTLoweringExpr::translate (expr.get_left_expr ().get ());
- HIR::Expr *value = ASTLoweringExpr::translate (expr.get_right_expr ().get ());
+ HIR::Expr *asignee_expr = ASTLoweringExpr::translate (expr.get_left_expr ());
+ HIR::Expr *value = ASTLoweringExpr::translate (expr.get_right_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
ASTLoweringExpr::visit (AST::StructExprStruct &struct_expr)
{
HIR::PathInExpression *path
- = ASTLowerPathInExpression::translate (&struct_expr.get_struct_name ());
+ = ASTLowerPathInExpression::translate (struct_expr.get_struct_name ());
HIR::PathInExpression copied_path (*path);
delete path;
{
// bit of a hack for now
HIR::PathInExpression *path
- = ASTLowerPathInExpression::translate (&struct_expr.get_struct_name ());
+ = ASTLowerPathInExpression::translate (struct_expr.get_struct_name ());
HIR::PathInExpression copied_path (*path);
delete path;
if (struct_expr.has_struct_base ())
{
HIR::Expr *translated_base = ASTLoweringExpr::translate (
- struct_expr.get_struct_base ().get_base_struct ().get ());
+ struct_expr.get_struct_base ().get_base_struct ());
base = new HIR::StructBase (std::unique_ptr<HIR::Expr> (translated_base));
}
for (auto &field : in_fields)
{
HIR::StructExprField *translated
- = ASTLowerStructExprField::translate (field.get ());
+ = ASTLowerStructExprField::translate (*field);
fields.push_back (std::unique_ptr<HIR::StructExprField> (translated));
}
ASTLoweringExpr::visit (AST::GroupedExpr &expr)
{
HIR::Expr *paren_expr
- = ASTLoweringExpr::translate (expr.get_expr_in_parens ().get ());
+ = ASTLoweringExpr::translate (expr.get_expr_in_parens ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
void
ASTLoweringExpr::visit (AST::FieldAccessExpr &expr)
{
- HIR::Expr *receiver
- = ASTLoweringExpr::translate (expr.get_receiver_expr ().get ());
+ HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
void
ASTLoweringExpr::visit (AST::LoopExpr &expr)
{
- translated = ASTLoweringExprWithBlock::translate (&expr, &terminated);
+ translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
}
void
ASTLoweringExpr::visit (AST::WhileLoopExpr &expr)
{
- translated = ASTLoweringExprWithBlock::translate (&expr, &terminated);
+ translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
}
void
ASTLoweringExpr::visit (AST::ForLoopExpr &expr)
{
- translated = ASTLoweringExprWithBlock::translate (&expr, &terminated);
+ translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
}
void
= lower_lifetime (expr.get_label ().get_lifetime ());
HIR::Expr *break_expr
= expr.has_break_expr ()
- ? ASTLoweringExpr::translate (expr.get_break_expr ().get ())
+ ? ASTLoweringExpr::translate (expr.get_break_expr ())
: nullptr;
auto crate_num = mappings->get_current_crate ();
ASTLoweringExpr::visit (AST::BorrowExpr &expr)
{
HIR::Expr *borrow_lvalue
- = ASTLoweringExpr::translate (expr.get_borrowed_expr ().get ());
+ = ASTLoweringExpr::translate (expr.get_borrowed_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
ASTLoweringExpr::visit (AST::DereferenceExpr &expr)
{
HIR::Expr *dref_lvalue
- = ASTLoweringExpr::translate (expr.get_dereferenced_expr ().get ());
+ = ASTLoweringExpr::translate (expr.get_dereferenced_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
ASTLoweringExpr::visit (AST::ErrorPropagationExpr &expr)
{
HIR::Expr *propagating_expr
- = ASTLoweringExpr::translate (expr.get_propagating_expr ().get ());
+ = ASTLoweringExpr::translate (expr.get_propagating_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
void
ASTLoweringExpr::visit (AST::MatchExpr &expr)
{
- translated = ASTLoweringExprWithBlock::translate (&expr, &terminated);
+ translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
}
void
mappings->get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- HIR::Expr *range_from
- = ASTLoweringExpr::translate (expr.get_from_expr ().get ());
- HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ().get ());
+ HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
+ HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
translated
= new HIR::RangeFromToExpr (mapping,
mappings->get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- HIR::Expr *range_from
- = ASTLoweringExpr::translate (expr.get_from_expr ().get ());
+ HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
translated
= new HIR::RangeFromExpr (mapping, std::unique_ptr<HIR::Expr> (range_from),
mappings->get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ().get ());
+ HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
translated
= new HIR::RangeToExpr (mapping, std::unique_ptr<HIR::Expr> (range_to),
mappings->get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- HIR::Expr *range_from
- = ASTLoweringExpr::translate (expr.get_from_expr ().get ());
- HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ().get ());
+ HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
+ HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
translated
= new HIR::RangeFromToInclExpr (mapping,
ASTLoweringExpr::visit (AST::ClosureExprInner &expr)
{
HIR::Expr *closure_expr
- = ASTLoweringExpr::translate (expr.get_definition_expr ().get ());
+ = ASTLoweringExpr::translate (expr.get_definition_expr ());
std::vector<HIR::ClosureParam> closure_params;
for (auto ¶m : expr.get_params ())
{
HIR::Type *closure_return_type = nullptr;
HIR::Expr *closure_expr
- = ASTLoweringExpr::translate (expr.get_definition_block ().get ());
+ = ASTLoweringExpr::translate (expr.get_definition_block ());
std::vector<HIR::ClosureParam> closure_params;
for (auto ¶m : expr.get_params ())
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::PathInExpression *translate (AST::PathInExpression *expr)
+ static HIR::PathInExpression *translate (AST::PathInExpression &expr)
{
ASTLowerPathInExpression compiler;
- expr->accept_vis (compiler);
+ expr.accept_vis (compiler);
rust_assert (compiler.translated);
return compiler.translated;
}
public:
static HIR::QualifiedPathInExpression *
- translate (AST::QualifiedPathInExpression *expr)
+ translate (AST::QualifiedPathInExpression &expr)
{
ASTLowerQualPathInExpression compiler;
- expr->accept_vis (compiler);
+ expr.accept_vis (compiler);
rust_assert (compiler.translated);
return compiler.translated;
}
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::Expr *translate (AST::Expr *expr, bool *terminated = nullptr);
+ static HIR::Expr *translate (AST::Expr &expr, bool *terminated = nullptr);
void visit (AST::TupleIndexExpr &expr) override;
void visit (AST::TupleExpr &expr) override;
void visit (AST::ExternalStaticItem &item) override
{
HIR::Visibility vis = translate_visibility (item.get_visibility ());
- HIR::Type *static_type
- = ASTLoweringType::translate (item.get_type ().get ());
+ HIR::Type *static_type = ASTLoweringType::translate (item.get_type ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
HIR::Type *return_type
= function.has_return_type ()
- ? ASTLoweringType::translate (function.get_return_type ().get ())
+ ? ASTLoweringType::translate (function.get_return_type ())
: nullptr;
bool is_variadic = function.is_variadic ();
std::vector<HIR::NamedFunctionParam> function_params;
for (auto it = begin; it != end; it++)
{
- auto param = static_cast<AST::FunctionParam *> (it->get ());
+ auto ¶m = static_cast<AST::FunctionParam &> (**it);
- if (param->is_variadic () || param->is_self ())
+ if (param.is_variadic () || param.is_self ())
continue;
- auto param_kind = param->get_pattern ()->get_pattern_kind ();
+ auto param_kind = param.get_pattern ().get_pattern_kind ();
rust_assert (param_kind == AST::Pattern::Kind::Identifier
|| param_kind == AST::Pattern::Kind::Wildcard);
- auto param_ident = static_cast<AST::IdentifierPattern *> (
- param->get_pattern ().get ());
+ auto ¶m_ident
+ = static_cast<AST::IdentifierPattern &> (param.get_pattern ());
Identifier param_name = param_kind == AST::Pattern::Kind::Identifier
- ? param_ident->get_ident ()
+ ? param_ident.get_ident ()
: std::string ("_");
- HIR::Type *param_type
- = ASTLoweringType::translate (param->get_type ().get ());
+ HIR::Type *param_type = ASTLoweringType::translate (param.get_type ());
auto crate_num = mappings->get_current_crate ();
- Analysis::NodeMapping mapping (crate_num, param->get_node_id (),
+ Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
mappings->get_next_hir_id (crate_num),
mappings->get_next_localdef_id (
crate_num));
namespace HIR {
HIR::ImplItem *
-ASTLowerImplItem::translate (AST::AssociatedItem *item, HirId parent_impl_id)
+ASTLowerImplItem::translate (AST::AssociatedItem &item, HirId parent_impl_id)
{
ASTLowerImplItem resolver;
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
if (resolver.translated != nullptr)
{
generic_params = lower_generic_params (alias.get_generic_params ());
HIR::Type *existing_type
- = ASTLoweringType::translate (alias.get_type_aliased ().get ());
+ = ASTLoweringType::translate (alias.get_type_aliased ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, alias.get_node_id (),
{
HIR::Visibility vis = translate_visibility (constant.get_visibility ());
- HIR::Type *type
- = ASTLoweringType::translate (constant.get_type ().get (), true);
- HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ().get ());
+ HIR::Type *type = ASTLoweringType::translate (constant.get_type (), true);
+ HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, constant.get_node_id (),
std::unique_ptr<HIR::Type> return_type
= function.has_return_type () ? std::unique_ptr<HIR::Type> (
- ASTLoweringType::translate (function.get_return_type ().get ()))
+ ASTLoweringType::translate (function.get_return_type ()))
: nullptr;
std::vector<HIR::FunctionParam> function_params;
{
if (p->is_self () || p->is_variadic ())
continue;
- auto param = static_cast<AST::FunctionParam *> (p.get ());
+ auto param = static_cast<AST::FunctionParam &> (*p);
auto translated_pattern = std::unique_ptr<HIR::Pattern> (
- ASTLoweringPattern::translate (param->get_pattern ().get ()));
+ ASTLoweringPattern::translate (param.get_pattern ()));
auto translated_type = std::unique_ptr<HIR::Type> (
- ASTLoweringType::translate (param->get_type ().get ()));
+ ASTLoweringType::translate (param.get_type ()));
auto crate_num = mappings->get_current_crate ();
- Analysis::NodeMapping mapping (crate_num, param->get_node_id (),
+ Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
mappings->get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
auto hir_param
= HIR::FunctionParam (mapping, std::move (translated_pattern),
- std::move (translated_type), param->get_locus ());
+ std::move (translated_type), param.get_locus ());
function_params.push_back (std::move (hir_param));
}
bool terminated = false;
std::unique_ptr<HIR::BlockExpr> function_body
= std::unique_ptr<HIR::BlockExpr> (
- ASTLoweringBlock::translate (function.get_definition ()->get (),
+ ASTLoweringBlock::translate (*function.get_definition ().value (),
&terminated));
auto crate_num = mappings->get_current_crate ();
}
HIR::TraitItem *
-ASTLowerTraitItem::translate (AST::AssociatedItem *item)
+ASTLowerTraitItem::translate (AST::AssociatedItem &item)
{
ASTLowerTraitItem resolver;
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
if (resolver.translated != nullptr)
{
std::unique_ptr<HIR::Type> return_type
= func.has_return_type () ? std::unique_ptr<HIR::Type> (
- ASTLoweringType::translate (func.get_return_type ().get ()))
+ ASTLoweringType::translate (func.get_return_type ()))
: nullptr;
// set self parameter to error if this is a method
if (p->is_variadic () || p->is_self ())
continue;
- auto param = static_cast<AST::FunctionParam *> (p.get ());
+ auto param = static_cast<AST::FunctionParam &> (*p);
auto translated_pattern = std::unique_ptr<HIR::Pattern> (
- ASTLoweringPattern::translate (param->get_pattern ().get ()));
+ ASTLoweringPattern::translate (param.get_pattern ()));
auto translated_type = std::unique_ptr<HIR::Type> (
- ASTLoweringType::translate (param->get_type ().get ()));
+ ASTLoweringType::translate (param.get_type ()));
auto crate_num = mappings->get_current_crate ();
- Analysis::NodeMapping mapping (crate_num, param->get_node_id (),
+ Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
mappings->get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
auto hir_param
= HIR::FunctionParam (mapping, std::move (translated_pattern),
- std::move (translated_type), param->get_locus ());
+ std::move (translated_type), param.get_locus ());
function_params.push_back (hir_param);
}
bool terminated = false;
std::unique_ptr<HIR::BlockExpr> block_expr
= func.has_body () ? std::unique_ptr<HIR::BlockExpr> (
- ASTLoweringBlock::translate (func.get_definition ()->get (),
+ ASTLoweringBlock::translate (*func.get_definition ().value (),
&terminated))
: nullptr;
void
ASTLowerTraitItem::visit (AST::TraitItemConst &constant)
{
- HIR::Type *type = ASTLoweringType::translate (constant.get_type ().get ());
+ HIR::Type *type = ASTLoweringType::translate (constant.get_type ());
HIR::Expr *expr = constant.has_expression ()
- ? ASTLoweringExpr::translate (constant.get_expr ().get ())
+ ? ASTLoweringExpr::translate (constant.get_expr ())
: nullptr;
auto crate_num = mappings->get_current_crate ();
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::ImplItem *translate (AST::AssociatedItem *item,
+ static HIR::ImplItem *translate (AST::AssociatedItem &item,
HirId parent_impl_id);
void visit (AST::TypeAlias &alias) override;
void visit (AST::ConstantItem &constant) override;
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::TraitItem *translate (AST::AssociatedItem *item);
+ static HIR::TraitItem *translate (AST::AssociatedItem &item);
void visit (AST::Function &func) override;
void visit (AST::TraitItemConst &constant) override;
void visit (AST::TraitItemType &type) override;
namespace HIR {
HIR::Item *
-ASTLoweringItem::translate (AST::Item *item)
+ASTLoweringItem::translate (AST::Item &item)
{
ASTLoweringItem resolver;
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
if (resolver.translated != nullptr)
{
auto locus = resolver.translated->get_locus ();
resolver.handle_outer_attributes (*resolver.translated);
- resolver.mappings->insert_ast_item (item);
+ resolver.mappings->insert_ast_item (&item);
resolver.mappings->insert_hir_item (resolver.translated);
resolver.mappings->insert_location (id, locus);
resolver.mappings->insert_defid_mapping (defid, resolver.translated);
for (auto &item : module.get_items ())
{
- auto transitem = translate (item.get ());
+ auto transitem = translate (*item);
// The item may be null if it doesn't need to live in the HIR - for
// example, macro rules definitions
if (transitem)
generic_params = lower_generic_params (alias.get_generic_params ());
HIR::Type *existing_type
- = ASTLoweringType::translate (alias.get_type_aliased ().get ());
+ = ASTLoweringType::translate (alias.get_type_aliased ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, alias.get_node_id (),
std::vector<HIR::TupleField> fields;
for (AST::TupleField &field : struct_decl.get_fields ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
// FIXME: How do we get the visibility from here?
HIR::Visibility vis = translate_visibility (field.get_visibility ());
- HIR::Type *type
- = ASTLoweringType::translate (field.get_field_type ().get ());
+ HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
std::vector<HIR::StructField> fields;
for (AST::StructField &field : struct_decl.get_fields ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
HIR::Visibility vis = translate_visibility (field.get_visibility ());
- HIR::Type *type
- = ASTLoweringType::translate (field.get_field_type ().get ());
+ HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
std::vector<HIR::StructField> variants;
for (AST::StructField &variant : union_decl.get_variants ())
{
- if (variant.get_field_type ()->is_marked_for_strip ())
+ if (variant.get_field_type ().is_marked_for_strip ())
continue;
// FIXME: Does visibility apply here?
HIR::Visibility vis = translate_visibility (variant.get_visibility ());
- HIR::Type *type
- = ASTLoweringType::translate (variant.get_field_type ().get ());
+ HIR::Type *type = ASTLoweringType::translate (variant.get_field_type ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, variant.get_node_id (),
{
HIR::Visibility vis = translate_visibility (var.get_visibility ());
- HIR::Type *type = ASTLoweringType::translate (var.get_type ().get (), true);
- HIR::Expr *expr = ASTLoweringExpr::translate (var.get_expr ().get ());
+ HIR::Type *type = ASTLoweringType::translate (var.get_type (), true);
+ HIR::Expr *expr = ASTLoweringExpr::translate (var.get_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, var.get_node_id (),
{
HIR::Visibility vis = translate_visibility (constant.get_visibility ());
- HIR::Type *type
- = ASTLoweringType::translate (constant.get_type ().get (), true);
- HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ().get ());
+ HIR::Type *type = ASTLoweringType::translate (constant.get_type (), true);
+ HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, constant.get_node_id (),
std::unique_ptr<HIR::Type> return_type
= function.has_return_type () ? std::unique_ptr<HIR::Type> (
- ASTLoweringType::translate (function.get_return_type ().get ()))
+ ASTLoweringType::translate (function.get_return_type ()))
: nullptr;
std::vector<HIR::FunctionParam> function_params;
{
if (p->is_variadic () || p->is_self ())
continue;
- auto param = static_cast<AST::FunctionParam *> (p.get ());
+ auto param = static_cast<AST::FunctionParam &> (*p);
auto translated_pattern = std::unique_ptr<HIR::Pattern> (
- ASTLoweringPattern::translate (param->get_pattern ().get ()));
+ ASTLoweringPattern::translate (param.get_pattern ()));
auto translated_type = std::unique_ptr<HIR::Type> (
- ASTLoweringType::translate (param->get_type ().get ()));
+ ASTLoweringType::translate (param.get_type ()));
auto crate_num = mappings->get_current_crate ();
- Analysis::NodeMapping mapping (crate_num, param->get_node_id (),
+ Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
mappings->get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
auto hir_param
= HIR::FunctionParam (mapping, std::move (translated_pattern),
- std::move (translated_type), param->get_locus ());
+ std::move (translated_type), param.get_locus ());
function_params.push_back (std::move (hir_param));
}
bool terminated = false;
std::unique_ptr<HIR::BlockExpr> function_body
= std::unique_ptr<HIR::BlockExpr> (
- ASTLoweringBlock::translate (function.get_definition ()->get (),
+ ASTLoweringBlock::translate (*function.get_definition ().value (),
&terminated));
auto crate_num = mappings->get_current_crate ();
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
for (auto &item : impl_block.get_where_clause ().get_items ())
{
- HIR::WhereClauseItem *i
- = ASTLowerWhereClauseItem::translate (*item.get ());
+ HIR::WhereClauseItem *i = ASTLowerWhereClauseItem::translate (*item);
where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
}
}
}
- HIR::Type *impl_type
- = ASTLoweringType::translate (impl_block.get_type ().get ());
+ HIR::Type *impl_type = ASTLoweringType::translate (impl_block.get_type ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, impl_block.get_node_id (),
continue;
HIR::ImplItem *lowered
- = ASTLowerImplItem::translate (impl_item.get (), mapping.get_hirid ());
+ = ASTLowerImplItem::translate (*impl_item, mapping.get_hirid ());
rust_assert (lowered != nullptr);
impl_items.push_back (std::unique_ptr<HIR::ImplItem> (lowered));
impl_item_ids.push_back (lowered->get_impl_mappings ().get_hirid ());
{
for (auto &bound : trait.get_type_param_bounds ())
{
- HIR::TypeParamBound *b = lower_bound (bound.get ());
+ HIR::TypeParamBound *b = lower_bound (*bound);
type_param_bounds.push_back (
std::unique_ptr<HIR::TypeParamBound> (b));
}
if (item->is_marked_for_strip ())
continue;
- HIR::TraitItem *lowered = ASTLowerTraitItem::translate (item.get ());
+ HIR::TraitItem *lowered = ASTLowerTraitItem::translate (*item);
trait_items.push_back (std::unique_ptr<HIR::TraitItem> (lowered));
trait_item_ids.push_back (lowered->get_mappings ().get_hirid ());
}
std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
for (auto &item : impl_block.get_where_clause ().get_items ())
{
- HIR::WhereClauseItem *i
- = ASTLowerWhereClauseItem::translate (*item.get ());
+ HIR::WhereClauseItem *i = ASTLowerWhereClauseItem::translate (*item);
where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
}
HIR::WhereClause where_clause (std::move (where_clause_items));
}
}
- HIR::Type *impl_type
- = ASTLoweringType::translate (impl_block.get_type ().get ());
+ HIR::Type *impl_type = ASTLoweringType::translate (impl_block.get_type ());
HIR::TypePath *trait_ref
= ASTLowerTypePath::translate (impl_block.get_trait_path ());
continue;
HIR::ImplItem *lowered
- = ASTLowerImplItem::translate (impl_item.get (), mapping.get_hirid ());
+ = ASTLowerImplItem::translate (*impl_item, mapping.get_hirid ());
rust_assert (lowered != nullptr);
impl_items.push_back (std::unique_ptr<HIR::ImplItem> (lowered));
impl_item_ids.push_back (lowered->get_impl_mappings ().get_hirid ());
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::Item *translate (AST::Item *item);
+ static HIR::Item *translate (AST::Item &item);
void visit (AST::Module &module) override;
void visit (AST::TypeAlias &alias) override;
ASTLoweringPattern::ASTLoweringPattern () : translated (nullptr) {}
HIR::Pattern *
-ASTLoweringPattern::translate (AST::Pattern *pattern, bool is_let_top_level)
+ASTLoweringPattern::translate (AST::Pattern &pattern, bool is_let_top_level)
{
ASTLoweringPattern resolver;
resolver.is_let_top_level = is_let_top_level;
- pattern->accept_vis (resolver);
+ pattern.accept_vis (resolver);
rust_assert (resolver.translated != nullptr);
resolver.mappings->insert_hir_pattern (resolver.translated);
resolver.mappings->insert_location (
- resolver.translated->get_mappings ().get_hirid (), pattern->get_locus ());
+ resolver.translated->get_mappings ().get_hirid (), pattern.get_locus ());
return resolver.translated;
}
void
ASTLoweringPattern::visit (AST::PathInExpression &pattern)
{
- translated = ASTLowerPathInExpression::translate (&pattern);
+ translated = ASTLowerPathInExpression::translate (pattern);
}
void
ASTLoweringPattern::visit (AST::TupleStructPattern &pattern)
{
HIR::PathInExpression *path
- = ASTLowerPathInExpression::translate (&pattern.get_path ());
+ = ASTLowerPathInExpression::translate (pattern.get_path ());
TupleStructItems *lowered = nullptr;
auto &items = pattern.get_items ();
- switch (items->get_item_type ())
+ switch (items.get_item_type ())
{
case AST::TupleStructItems::RANGE: {
// TODO
case AST::TupleStructItems::NO_RANGE: {
AST::TupleStructItemsNoRange &items_no_range
- = static_cast<AST::TupleStructItemsNoRange &> (*items.get ());
+ = static_cast<AST::TupleStructItemsNoRange &> (items);
std::vector<std::unique_ptr<HIR::Pattern>> patterns;
for (auto &inner_pattern : items_no_range.get_patterns ())
{
- HIR::Pattern *p
- = ASTLoweringPattern::translate (inner_pattern.get ());
+ HIR::Pattern *p = ASTLoweringPattern::translate (*inner_pattern);
patterns.push_back (std::unique_ptr<HIR::Pattern> (p));
}
ASTLoweringPattern::visit (AST::StructPattern &pattern)
{
HIR::PathInExpression *path
- = ASTLowerPathInExpression::translate (&pattern.get_path ());
+ = ASTLowerPathInExpression::translate (pattern.get_path ());
auto &raw_elems = pattern.get_struct_pattern_elems ();
rust_assert (!raw_elems.has_etc ());
switch (field->get_item_type ())
{
case AST::StructPatternField::ItemType::TUPLE_PAT: {
- AST::StructPatternFieldTuplePat &tuple
+ auto &tuple
= static_cast<AST::StructPatternFieldTuplePat &> (*field);
auto crate_num = mappings->get_current_crate ();
crate_num),
UNKNOWN_LOCAL_DEFID);
- std::unique_ptr<HIR::Pattern> pat (ASTLoweringPattern::translate (
- tuple.get_index_pattern ().get ()));
+ std::unique_ptr<HIR::Pattern> pat (
+ ASTLoweringPattern::translate (tuple.get_index_pattern ()));
f = new HIR::StructPatternFieldTuplePat (mapping,
tuple.get_index (),
crate_num),
UNKNOWN_LOCAL_DEFID);
- std::unique_ptr<HIR::Pattern> pat (ASTLoweringPattern::translate (
- ident.get_ident_pattern ().get ()));
+ std::unique_ptr<HIR::Pattern> pat (
+ ASTLoweringPattern::translate (ident.get_ident_pattern ()));
f = new HIR::StructPatternFieldIdentPat (mapping,
ident.get_identifier (),
ASTLoweringPattern::visit (AST::TuplePattern &pattern)
{
std::unique_ptr<HIR::TuplePatternItems> items;
- switch (pattern.get_items ()->get_pattern_type ())
+ switch (pattern.get_items ().get_pattern_type ())
{
case AST::TuplePatternItems::TuplePatternItemType::MULTIPLE: {
AST::TuplePatternItemsMultiple &ref
- = *static_cast<AST::TuplePatternItemsMultiple *> (
- pattern.get_items ().get ());
+ = static_cast<AST::TuplePatternItemsMultiple &> (
+ pattern.get_items ());
items = lower_tuple_pattern_multiple (ref);
}
break;
case AST::TuplePatternItems::TuplePatternItemType::RANGED: {
AST::TuplePatternItemsRanged &ref
- = *static_cast<AST::TuplePatternItemsRanged *> (
- pattern.get_items ().get ());
+ = static_cast<AST::TuplePatternItemsRanged &> (pattern.get_items ());
items = lower_tuple_pattern_ranged (ref);
}
break;
void
ASTLoweringPattern::visit (AST::RangePattern &pattern)
{
- auto upper_bound
- = lower_range_pattern_bound (pattern.get_upper_bound ().get ());
- auto lower_bound
- = lower_range_pattern_bound (pattern.get_lower_bound ().get ());
+ auto upper_bound = lower_range_pattern_bound (pattern.get_upper_bound ());
+ auto lower_bound = lower_range_pattern_bound (pattern.get_lower_bound ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
ASTLoweringPattern::visit (AST::GroupedPattern &pattern)
{
is_let_top_level = false;
- pattern.get_pattern_in_parens ()->accept_vis (*this);
+ pattern.get_pattern_in_parens ().accept_vis (*this);
}
void
UNKNOWN_LOCAL_DEFID);
HIR::Pattern *inner
- = ASTLoweringPattern::translate (pattern.get_referenced_pattern ().get ());
+ = ASTLoweringPattern::translate (pattern.get_referenced_pattern ());
translated
= new HIR::ReferencePattern (mapping, std::unique_ptr<HIR::Pattern> (inner),
std::vector<std::unique_ptr<HIR::Pattern>> items;
for (auto &p : pattern.get_items ())
{
- HIR::Pattern *item = ASTLoweringPattern::translate (p.get ());
+ HIR::Pattern *item = ASTLoweringPattern::translate (*p);
items.push_back (std::unique_ptr<HIR::Pattern> (item));
}
for (auto &alt : pattern.get_alts ())
{
- alts.push_back (std::unique_ptr<HIR::Pattern> (
- ASTLoweringPattern::translate (alt.get ())));
+ alts.push_back (
+ std::unique_ptr<HIR::Pattern> (ASTLoweringPattern::translate (*alt)));
}
translated
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::Pattern *translate (AST::Pattern *pattern,
+ static HIR::Pattern *translate (AST::Pattern &pattern,
bool is_let_top_level = false);
void visit (AST::IdentifierPattern &pattern) override;
void
ASTLoweringStmt::visit (AST::ExprStmt &stmt)
{
- HIR::Expr *expr
- = ASTLoweringExpr::translate (stmt.get_expr ().get (), &terminated);
+ HIR::Expr *expr = ASTLoweringExpr::translate (stmt.get_expr (), &terminated);
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
void
ASTLoweringStmt::visit (AST::ConstantItem &constant)
{
- translated = ASTLoweringItem::translate (&constant);
+ translated = ASTLoweringItem::translate (constant);
}
void
ASTLoweringStmt::visit (AST::LetStmt &stmt)
{
HIR::Pattern *variables
- = ASTLoweringPattern::translate (stmt.get_pattern ().get (), true);
+ = ASTLoweringPattern::translate (stmt.get_pattern (), true);
HIR::Type *type = stmt.has_type ()
- ? ASTLoweringType::translate (stmt.get_type ().get ())
+ ? ASTLoweringType::translate (stmt.get_type ())
: nullptr;
HIR::Expr *init_expression
- = stmt.has_init_expr ()
- ? ASTLoweringExpr::translate (stmt.get_init_expr ().get ())
- : nullptr;
+ = stmt.has_init_expr () ? ASTLoweringExpr::translate (stmt.get_init_expr ())
+ : nullptr;
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
void
ASTLoweringStmt::visit (AST::TupleStruct &struct_decl)
{
- translated = ASTLoweringItem::translate (&struct_decl);
+ translated = ASTLoweringItem::translate (struct_decl);
}
void
ASTLoweringStmt::visit (AST::StructStruct &struct_decl)
{
- translated = ASTLoweringItem::translate (&struct_decl);
+ translated = ASTLoweringItem::translate (struct_decl);
}
void
ASTLoweringStmt::visit (AST::Union &union_decl)
{
- translated = ASTLoweringItem::translate (&union_decl);
+ translated = ASTLoweringItem::translate (union_decl);
}
void
ASTLoweringStmt::visit (AST::Enum &enum_decl)
{
- translated = ASTLoweringItem::translate (&enum_decl);
+ translated = ASTLoweringItem::translate (enum_decl);
}
void
void
ASTLoweringStmt::visit (AST::Function &function)
{
- translated = ASTLoweringItem::translate (&function);
+ translated = ASTLoweringItem::translate (function);
}
void
void
ASTLoweringStmt::visit (AST::Trait &trait)
{
- translated = ASTLoweringItem::translate (&trait);
+ translated = ASTLoweringItem::translate (trait);
}
void
ASTLoweringStmt::visit (AST::InherentImpl &impl_block)
{
- translated = ASTLoweringItem::translate (&impl_block);
+ translated = ASTLoweringItem::translate (impl_block);
}
void
ASTLoweringStmt::visit (AST::TraitImpl &impl_block)
{
- translated = ASTLoweringItem::translate (&impl_block);
+ translated = ASTLoweringItem::translate (impl_block);
}
} // namespace HIR
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::StructExprField *translate (AST::StructExprField *field)
+ static HIR::StructExprField *translate (AST::StructExprField &field)
{
ASTLowerStructExprField compiler;
- field->accept_vis (compiler);
+ field.accept_vis (compiler);
rust_assert (compiler.translated != nullptr);
compiler.mappings->insert_hir_struct_field (compiler.translated);
compiler.mappings->insert_location (
- compiler.translated->get_mappings ().get_hirid (), field->get_locus ());
+ compiler.translated->get_mappings ().get_hirid (), field.get_locus ());
return compiler.translated;
}
std::vector<std::unique_ptr<HIR::Type>> inputs;
for (auto ¶m : fn.get_params ())
{
- HIR::Type *hir_type = ASTLoweringType::translate (param.get ());
+ HIR::Type *hir_type = ASTLoweringType::translate (*param);
inputs.push_back (std::unique_ptr<HIR::Type> (hir_type));
}
HIR::Type *result_type
- = fn.has_return_type ()
- ? ASTLoweringType::translate (fn.get_return_type ().get ())
- : nullptr;
+ = fn.has_return_type () ? ASTLoweringType::translate (fn.get_return_type ())
+ : nullptr;
HIR::TypePathFunction function_path (std::move (inputs),
std::unique_ptr<HIR::Type> (
crate_num, path.get_qualified_path_type ().get_node_id (), hirid,
UNKNOWN_LOCAL_DEFID);
- HIR::Type *qual_type = ASTLoweringType::translate (
- path.get_qualified_path_type ().get_type ().get ());
+ HIR::Type *qual_type
+ = ASTLoweringType::translate (path.get_qualified_path_type ().get_type ());
HIR::TypePath *qual_trait = ASTLowerTypePath::translate (
path.get_qualified_path_type ().get_as_type_path ());
}
HIR::Type *
-ASTLoweringType::translate (AST::Type *type, bool default_to_static_lifetime)
+ASTLoweringType::translate (AST::Type &type, bool default_to_static_lifetime)
{
ASTLoweringType resolver (default_to_static_lifetime);
- type->accept_vis (resolver);
+ type.accept_vis (resolver);
rust_assert (resolver.translated != nullptr);
resolver.mappings->insert_hir_type (resolver.translated);
std::vector<HIR::LifetimeParam> lifetime_params;
for (auto &lifetime_param : fntype.get_for_lifetimes ())
{
- auto generic_param = ASTLowerGenericParam::translate (&lifetime_param);
+ auto generic_param = ASTLowerGenericParam::translate (lifetime_param);
lifetime_params.push_back (
*static_cast<HIR::LifetimeParam *> (generic_param));
}
}
HIR::Type *param_type
- = ASTLoweringType::translate (param.get_type ().get (),
+ = ASTLoweringType::translate (param.get_type (),
default_to_static_lifetime);
HIR::MaybeNamedParam p (param.get_name (), kind,
HIR::Type *return_type = nullptr;
if (fntype.has_return_type ())
{
- return_type
- = ASTLoweringType::translate (fntype.get_return_type ().get (),
- default_to_static_lifetime);
+ return_type = ASTLoweringType::translate (fntype.get_return_type (),
+ default_to_static_lifetime);
}
auto crate_num = mappings->get_current_crate ();
for (auto &e : tuple.get_elems ())
{
HIR::Type *t
- = ASTLoweringType::translate (e.get (), default_to_static_lifetime);
+ = ASTLoweringType::translate (*e, default_to_static_lifetime);
elems.push_back (std::unique_ptr<HIR::Type> (t));
}
ASTLoweringType::visit (AST::ArrayType &type)
{
HIR::Type *translated_type
- = ASTLoweringType::translate (type.get_elem_type ().get (),
+ = ASTLoweringType::translate (type.get_elem_type (),
default_to_static_lifetime);
- HIR::Expr *array_size
- = ASTLoweringExpr::translate (type.get_size_expr ().get ());
+ HIR::Expr *array_size = ASTLoweringExpr::translate (type.get_size_expr ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
= lower_lifetime (type.get_lifetime (), default_to_static_lifetime);
HIR::Type *base_type
- = ASTLoweringType::translate (type.get_base_type ().get (),
+ = ASTLoweringType::translate (type.get_base_type (),
default_to_static_lifetime);
auto crate_num = mappings->get_current_crate ();
ASTLoweringType::visit (AST::RawPointerType &type)
{
HIR::Type *base_type
- = ASTLoweringType::translate (type.get_type_pointed_to ().get (),
+ = ASTLoweringType::translate (type.get_type_pointed_to (),
default_to_static_lifetime);
auto crate_num = mappings->get_current_crate ();
ASTLoweringType::visit (AST::SliceType &type)
{
HIR::Type *base_type
- = ASTLoweringType::translate (type.get_elem_type ().get (),
+ = ASTLoweringType::translate (type.get_elem_type (),
default_to_static_lifetime);
auto crate_num = mappings->get_current_crate ();
{
std::vector<std::unique_ptr<HIR::TypeParamBound>> bounds;
HIR::TypeParamBound *translated_bound
- = ASTLoweringTypeBounds::translate (&type.get_trait_bound ());
+ = ASTLoweringTypeBounds::translate (type.get_trait_bound ());
bounds.push_back (std::unique_ptr<HIR::TypeParamBound> (translated_bound));
auto crate_num = mappings->get_current_crate ();
for (auto &bound : type.get_type_param_bounds ())
{
HIR::TypeParamBound *translated_bound
- = ASTLoweringTypeBounds::translate (bound.get ());
+ = ASTLoweringTypeBounds::translate (*bound);
bounds.push_back (
std::unique_ptr<HIR::TypeParamBound> (translated_bound));
}
}
HIR::GenericParam *
-ASTLowerGenericParam::translate (AST::GenericParam *param)
+ASTLowerGenericParam::translate (AST::GenericParam ¶m)
{
ASTLowerGenericParam resolver;
- param->accept_vis (resolver);
+ param.accept_vis (resolver);
rust_assert (resolver.translated != nullptr);
resolver.mappings->insert_location (
- resolver.translated->get_mappings ().get_hirid (), param->get_locus ());
+ resolver.translated->get_mappings ().get_hirid (), param.get_locus ());
resolver.mappings->insert_hir_generic_param (resolver.translated);
return resolver.translated;
mappings->get_next_hir_id (crate_num),
mappings->get_next_localdef_id (crate_num));
- auto type = ASTLoweringType::translate (param.get_type ().get ());
+ auto type = ASTLoweringType::translate (param.get_type ());
HIR::Expr *default_expr = nullptr;
if (param.has_default_value ())
default_expr = ASTLoweringExpr::translate (
- param.get_default_value ().get_expression ().get ());
+ param.get_default_value ().get_expression ());
translated = new HIR::ConstGenericParam (param.get_name ().as_string (),
std::unique_ptr<Type> (type),
{
for (auto &bound : param.get_type_param_bounds ())
{
- HIR::TypeParamBound *lowered_bound = lower_bound (bound.get ());
+ HIR::TypeParamBound *lowered_bound = lower_bound (*bound);
type_param_bounds.push_back (
std::unique_ptr<HIR::TypeParamBound> (lowered_bound));
}
}
HIR::Type *type = param.has_type ()
- ? ASTLoweringType::translate (param.get_type ().get ())
+ ? ASTLoweringType::translate (param.get_type ())
: nullptr;
auto crate_num = mappings->get_current_crate ();
}
HIR::TypeParamBound *
-ASTLoweringTypeBounds::translate (AST::TypeParamBound *type)
+ASTLoweringTypeBounds::translate (AST::TypeParamBound &type)
{
ASTLoweringTypeBounds resolver;
- type->accept_vis (resolver);
+ type.accept_vis (resolver);
rust_assert (resolver.translated != nullptr);
resolver.mappings->insert_location (
std::vector<HIR::LifetimeParam> for_lifetimes;
for (auto &lifetime_param : bound.get_for_lifetimes ())
{
- auto generic_param = ASTLowerGenericParam::translate (&lifetime_param);
+ auto generic_param = ASTLowerGenericParam::translate (lifetime_param);
for_lifetimes.push_back (
*static_cast<HIR::LifetimeParam *> (generic_param));
}
for (auto &lifetime_param : item.get_for_lifetimes ())
{
- auto generic_param = ASTLowerGenericParam::translate (&lifetime_param);
+ auto generic_param = ASTLowerGenericParam::translate (lifetime_param);
for_lifetimes.push_back (
*static_cast<HIR::LifetimeParam *> (generic_param));
}
std::unique_ptr<HIR::Type> bound_type = std::unique_ptr<HIR::Type> (
- ASTLoweringType::translate (item.get_type ().get ()));
+ ASTLoweringType::translate (item.get_type ()));
std::vector<std::unique_ptr<HIR::TypeParamBound>> type_param_bounds;
for (auto &bound : item.get_type_param_bounds ())
{
- HIR::TypeParamBound *b = ASTLoweringTypeBounds::translate (bound.get ());
+ HIR::TypeParamBound *b = ASTLoweringTypeBounds::translate (*bound);
type_param_bounds.push_back (std::unique_ptr<HIR::TypeParamBound> (b));
}
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::Type *translate (AST::Type *type,
+ static HIR::Type *translate (AST::Type &type,
bool default_to_static_lifetime = false);
void visit (AST::BareFunctionType &fntype) override;
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::GenericParam *translate (AST::GenericParam *param);
+ static HIR::GenericParam *translate (AST::GenericParam ¶m);
void visit (AST::LifetimeParam ¶m) override;
void visit (AST::ConstGenericParam ¶m) override;
using Rust::HIR::ASTLoweringBase::visit;
public:
- static HIR::TypeParamBound *translate (AST::TypeParamBound *type);
+ static HIR::TypeParamBound *translate (AST::TypeParamBound &type);
void visit (AST::TraitBound &bound) override;
void visit (AST::Lifetime &bound) override;
{
std::vector<std::unique_ptr<HIR::Item>> items;
- for (auto it = astCrate.items.begin (); it != astCrate.items.end (); it++)
+ for (auto &item : astCrate.items)
{
- auto translated = ASTLoweringItem::translate (it->get ());
+ auto translated = ASTLoweringItem::translate (*item);
if (translated != nullptr)
items.push_back (std::unique_ptr<HIR::Item> (translated));
}
if (expr.has_tail_expr () && block_did_terminate)
{
// warning unreachable tail expressions
- rust_warning_at (expr.get_tail_expr ()->get_locus (), 0,
+ rust_warning_at (expr.get_tail_expr ().get_locus (), 0,
"unreachable expression");
}
{
bool terminated = false;
tail_expr = (HIR::ExprWithoutBlock *)
- ASTLoweringExpr::translate (expr.get_tail_expr ().get (), &terminated);
+ ASTLoweringExpr::translate (expr.get_tail_expr (), &terminated);
block_did_terminate |= terminated;
}
ASTLoweringIfBlock::visit (AST::IfExpr &expr)
{
bool ignored_terminated = false;
- HIR::Expr *condition
- = ASTLoweringExpr::translate (expr.get_condition_expr ().get (),
- &ignored_terminated);
+ HIR::Expr *condition = ASTLoweringExpr::translate (expr.get_condition_expr (),
+ &ignored_terminated);
HIR::BlockExpr *block
- = ASTLoweringBlock::translate (expr.get_if_block ().get (),
- &ignored_terminated);
+ = ASTLoweringBlock::translate (expr.get_if_block (), &ignored_terminated);
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
ASTLoweringIfBlock::visit (AST::IfExprConseqElse &expr)
{
HIR::Expr *condition
- = ASTLoweringExpr::translate (expr.get_condition_expr ().get ());
+ = ASTLoweringExpr::translate (expr.get_condition_expr ());
bool if_block_terminated = false;
bool else_block_termianted = false;
HIR::BlockExpr *if_block
- = ASTLoweringBlock::translate (expr.get_if_block ().get (),
- &if_block_terminated);
+ = ASTLoweringBlock::translate (expr.get_if_block (), &if_block_terminated);
HIR::ExprWithBlock *else_block
- = ASTLoweringExprWithBlock::translate (expr.get_else_block ().get (),
+ = ASTLoweringExprWithBlock::translate (expr.get_else_block (),
&else_block_termianted);
terminated = if_block_terminated && else_block_termianted;
std::vector<std::unique_ptr<HIR::Pattern>> patterns;
for (auto &pattern : expr.get_patterns ())
{
- HIR::Pattern *ptrn = ASTLoweringPattern::translate (pattern.get ());
+ HIR::Pattern *ptrn = ASTLoweringPattern::translate (*pattern);
patterns.push_back (std::unique_ptr<HIR::Pattern> (ptrn));
}
- HIR::Expr *value_ptr
- = ASTLoweringExpr::translate (expr.get_value_expr ().get ());
+ HIR::Expr *value_ptr = ASTLoweringExpr::translate (expr.get_value_expr ());
bool ignored_terminated = false;
HIR::BlockExpr *block
- = ASTLoweringBlock::translate (expr.get_if_block ().get (),
- &ignored_terminated);
+ = ASTLoweringBlock::translate (expr.get_if_block (), &ignored_terminated);
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
std::vector<std::unique_ptr<HIR::Pattern>> patterns;
for (auto &pattern : expr.get_patterns ())
{
- HIR::Pattern *ptrn = ASTLoweringPattern::translate (pattern.get ());
+ HIR::Pattern *ptrn = ASTLoweringPattern::translate (*pattern);
patterns.push_back (std::unique_ptr<HIR::Pattern> (ptrn));
}
- HIR::Expr *value_ptr
- = ASTLoweringExpr::translate (expr.get_value_expr ().get ());
+ HIR::Expr *value_ptr = ASTLoweringExpr::translate (expr.get_value_expr ());
bool ignored_terminated = false;
HIR::BlockExpr *block
- = ASTLoweringBlock::translate (expr.get_if_block ().get (),
- &ignored_terminated);
+ = ASTLoweringBlock::translate (expr.get_if_block (), &ignored_terminated);
HIR::ExprWithBlock *else_block
- = ASTLoweringExprWithBlock::translate (expr.get_else_block ().get (),
+ = ASTLoweringExprWithBlock::translate (expr.get_else_block (),
&ignored_terminated);
rust_assert (else_block);
void
ASTLowerStructExprField::visit (AST::StructExprFieldIdentifierValue &field)
{
- HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ().get ());
+ HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
void
ASTLowerStructExprField::visit (AST::StructExprFieldIndexValue &field)
{
- HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ().get ());
+ HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ());
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
ASTLoweringExprWithBlock::visit (AST::WhileLoopExpr &expr)
{
HIR::BlockExpr *loop_block
- = ASTLoweringBlock::translate (expr.get_loop_block ().get (), &terminated);
+ = ASTLoweringBlock::translate (expr.get_loop_block (), &terminated);
HIR::LoopLabel loop_label = lower_loop_label (expr.get_loop_label ());
HIR::Expr *loop_condition
- = ASTLoweringExpr::translate (expr.get_predicate_expr ().get (),
- &terminated);
+ = ASTLoweringExpr::translate (expr.get_predicate_expr (), &terminated);
auto crate_num = mappings->get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
ASTLoweringExprWithBlock::visit (AST::MatchExpr &expr)
{
HIR::Expr *branch_value
- = ASTLoweringExpr::translate (expr.get_scrutinee_expr ().get ());
+ = ASTLoweringExpr::translate (expr.get_scrutinee_expr ());
std::vector<HIR::MatchCase> match_arms;
for (auto &match_case : expr.get_match_cases ())
{
HIR::Expr *kase_expr
- = ASTLoweringExpr::translate (match_case.get_expr ().get ());
+ = ASTLoweringExpr::translate (match_case.get_expr ());
HIR::Expr *kase_guard_expr = nullptr;
if (match_case.get_arm ().has_match_arm_guard ())
{
kase_guard_expr = ASTLoweringExpr::translate (
- match_case.get_arm ().get_guard_expr ().get ());
+ match_case.get_arm ().get_guard_expr ());
}
std::vector<std::unique_ptr<HIR::Pattern>> match_arm_patterns;
for (auto &pattern : match_case.get_arm ().get_patterns ())
{
- HIR::Pattern *ptrn = ASTLoweringPattern::translate (pattern.get ());
+ HIR::Pattern *ptrn = ASTLoweringPattern::translate (*pattern);
match_arm_patterns.push_back (std::unique_ptr<HIR::Pattern> (ptrn));
}
HIR::QualifiedPathType
ASTLoweringBase::lower_qual_path_type (AST::QualifiedPathType &qualified_type)
{
- HIR::Type *type
- = ASTLoweringType::translate (qualified_type.get_type ().get ());
+ HIR::Type *type = ASTLoweringType::translate (qualified_type.get_type ());
HIR::TypePath *trait
= qualified_type.has_as_clause ()
? ASTLowerTypePath::translate (qualified_type.get_as_type_path ())
ASTLoweringBase::lower_closure_param (AST::ClosureParam ¶m)
{
HIR::Pattern *param_pattern
- = ASTLoweringPattern::translate (param.get_pattern ().get ());
+ = ASTLoweringPattern::translate (param.get_pattern ());
- HIR::Type *param_type
- = param.has_type_given ()
- ? ASTLoweringType::translate (param.get_type ().get ())
- : nullptr;
+ HIR::Type *param_type = param.has_type_given ()
+ ? ASTLoweringType::translate (param.get_type ())
+ : nullptr;
return HIR::ClosureParam (std::unique_ptr<HIR::Pattern> (param_pattern),
param.get_locus (),
if (vis.has_path ())
{
auto path = vis.get_path ();
- ResolvePath::go (&path);
+ ResolvePath::go (path);
// Do we need to lookup something here?
// Is it just about resolving the names correctly so we can look them up
namespace Resolver {
void
-ResolveExpr::go (AST::Expr *expr, const CanonicalPath &prefix,
+ResolveExpr::go (AST::Expr &expr, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix, bool funny_error)
{
ResolveExpr resolver (prefix, canonical_prefix, funny_error);
- expr->accept_vis (resolver);
+ expr.accept_vis (resolver);
}
void
ResolveExpr::visit (AST::TupleIndexExpr &expr)
{
- ResolveExpr::go (expr.get_tuple_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_tuple_expr (), prefix, canonical_prefix);
}
void
return;
for (auto &elem : expr.get_tuple_elems ())
- ResolveExpr::go (elem.get (), prefix, canonical_prefix);
+ ResolveExpr::go (*elem, prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::PathInExpression &expr)
{
- ResolvePath::go (&expr);
+ ResolvePath::go (expr);
}
void
ResolveExpr::visit (AST::QualifiedPathInExpression &expr)
{
- ResolvePath::go (&expr);
+ ResolvePath::go (expr);
}
void
ResolveExpr::visit (AST::ReturnExpr &expr)
{
if (expr.has_returned_expr ())
- ResolveExpr::go (expr.get_returned_expr ().get (), prefix,
- canonical_prefix);
+ ResolveExpr::go (expr.get_returned_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::CallExpr &expr)
{
- ResolveExpr::go (expr.get_function_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_function_expr (), prefix, canonical_prefix);
for (auto ¶m : expr.get_params ())
- ResolveExpr::go (param.get (), prefix, canonical_prefix);
+ ResolveExpr::go (*param, prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::MethodCallExpr &expr)
{
- ResolveExpr::go (expr.get_receiver_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_receiver_expr (), prefix, canonical_prefix);
if (expr.get_method_name ().has_generic_args ())
{
auto const &in_params = expr.get_params ();
for (auto ¶m : in_params)
- ResolveExpr::go (param.get (), prefix, canonical_prefix);
+ ResolveExpr::go (*param, prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::AssignmentExpr &expr)
{
- ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_left_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_right_expr (), prefix, canonical_prefix);
}
/* The "break rust" Easter egg.
void
ResolveExpr::visit (AST::ArithmeticOrLogicalExpr &expr)
{
- ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_left_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_right_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::CompoundAssignmentExpr &expr)
{
- ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_left_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_right_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::ComparisonExpr &expr)
{
- ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_left_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_right_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::LazyBooleanExpr &expr)
{
- ResolveExpr::go (expr.get_left_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_right_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_left_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_right_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::NegationExpr &expr)
{
- ResolveExpr::go (expr.get_negated_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_negated_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::TypeCastExpr &expr)
{
- ResolveType::go (expr.get_type_to_cast_to ().get ());
- ResolveExpr::go (expr.get_casted_expr ().get (), prefix, canonical_prefix);
+ ResolveType::go (expr.get_type_to_cast_to ());
+ ResolveExpr::go (expr.get_casted_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::IfExpr &expr)
{
- ResolveExpr::go (expr.get_condition_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_condition_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_if_block (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::IfExprConseqElse &expr)
{
- ResolveExpr::go (expr.get_condition_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_else_block ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_condition_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_if_block (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_else_block (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::IfLetExpr &expr)
{
- ResolveExpr::go (expr.get_value_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_value_expr (), prefix, canonical_prefix);
NodeId scope_node_id = expr.get_node_id ();
resolver->get_name_scope ().push (scope_node_id);
for (auto &pattern : expr.get_patterns ())
{
- PatternDeclaration::go (pattern.get (), Rib::ItemType::Var, bindings);
+ PatternDeclaration::go (*pattern, Rib::ItemType::Var, bindings);
}
- ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_if_block (), prefix, canonical_prefix);
resolver->get_name_scope ().pop ();
resolver->get_type_scope ().pop ();
void
ResolveExpr::visit (AST::IfLetExprConseqElse &expr)
{
- ResolveExpr::go (expr.get_value_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_value_expr (), prefix, canonical_prefix);
NodeId scope_node_id = expr.get_node_id ();
resolver->get_name_scope ().push (scope_node_id);
for (auto &pattern : expr.get_patterns ())
{
- PatternDeclaration::go (pattern.get (), Rib::ItemType::Var, bindings);
+ PatternDeclaration::go (*pattern, Rib::ItemType::Var, bindings);
}
- ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_else_block ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_if_block (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_else_block (), prefix, canonical_prefix);
resolver->get_name_scope ().pop ();
resolver->get_type_scope ().pop ();
for (auto &s : expr.get_statements ())
{
if (s->is_item ())
- ResolveStmt::go (s.get (), prefix, canonical_prefix,
+ ResolveStmt::go (*s, prefix, canonical_prefix,
CanonicalPath::create_empty ());
}
for (auto &s : expr.get_statements ())
{
if (!s->is_item ())
- ResolveStmt::go (s.get (), prefix, canonical_prefix,
+ ResolveStmt::go (*s, prefix, canonical_prefix,
CanonicalPath::create_empty ());
}
if (expr.has_tail_expr ())
- ResolveExpr::go (expr.get_tail_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_tail_expr (), prefix, canonical_prefix);
resolver->get_name_scope ().pop ();
resolver->get_type_scope ().pop ();
void
ResolveExpr::visit (AST::UnsafeBlockExpr &expr)
{
- expr.get_block_expr ()->accept_vis (*this);
+ expr.get_block_expr ().accept_vis (*this);
}
void
ResolveExpr::visit (AST::ArrayElemsValues &elems)
{
for (auto &elem : elems.get_values ())
- ResolveExpr::go (elem.get (), prefix, canonical_prefix);
+ ResolveExpr::go (*elem, prefix, canonical_prefix);
}
void
void
ResolveExpr::visit (AST::ArrayIndexExpr &expr)
{
- ResolveExpr::go (expr.get_array_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_index_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_array_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_index_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::ArrayElemsCopied &expr)
{
- ResolveExpr::go (expr.get_num_copies ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_elem_to_copy ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_num_copies (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_elem_to_copy (), prefix, canonical_prefix);
}
// this this an empty struct constructor like 'S {}'
void
ResolveExpr::visit (AST::StructExprStruct &struct_expr)
{
- ResolveExpr::go (&struct_expr.get_struct_name (), prefix, canonical_prefix);
+ ResolveExpr::go (struct_expr.get_struct_name (), prefix, canonical_prefix);
}
// this this a struct constructor with fields
void
ResolveExpr::visit (AST::StructExprStructFields &struct_expr)
{
- ResolveExpr::go (&struct_expr.get_struct_name (), prefix, canonical_prefix);
+ ResolveExpr::go (struct_expr.get_struct_name (), prefix, canonical_prefix);
if (struct_expr.has_struct_base ())
{
AST::StructBase &base = struct_expr.get_struct_base ();
- ResolveExpr::go (base.get_base_struct ().get (), prefix,
- canonical_prefix);
+ ResolveExpr::go (base.get_base_struct (), prefix, canonical_prefix);
}
auto const &struct_fields = struct_expr.get_fields ();
for (auto &struct_field : struct_fields)
{
- ResolveStructExprField::go (struct_field.get (), prefix,
- canonical_prefix);
+ ResolveStructExprField::go (*struct_field, prefix, canonical_prefix);
}
}
void
ResolveExpr::visit (AST::GroupedExpr &expr)
{
- ResolveExpr::go (expr.get_expr_in_parens ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_expr_in_parens (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::FieldAccessExpr &expr)
{
- ResolveExpr::go (expr.get_receiver_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_receiver_expr (), prefix, canonical_prefix);
}
void
rust_error_at (locus, "was defined here");
});
}
- ResolveExpr::go (expr.get_loop_block ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_loop_block (), prefix, canonical_prefix);
}
void
if (expr.has_break_expr ())
{
bool funny_error = false;
- AST::Expr &break_expr = *expr.get_break_expr ().get ();
+ auto &break_expr = expr.get_break_expr ();
if (break_expr.get_ast_kind () == AST::Kind::IDENTIFIER)
{
/* This is a break with an expression, and the expression is just a
if (ident == "rust" || ident == "gcc")
funny_error = true;
}
- ResolveExpr::go (&break_expr, prefix, canonical_prefix, funny_error);
+ ResolveExpr::go (break_expr, prefix, canonical_prefix, funny_error);
}
}
});
}
- ResolveExpr::go (expr.get_predicate_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_loop_block ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_predicate_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_loop_block (), prefix, canonical_prefix);
}
void
resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
// resolve the expression
- PatternDeclaration::go (expr.get_pattern ().get (), Rib::ItemType::Var);
- ResolveExpr::go (expr.get_iterator_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_loop_block ().get (), prefix, canonical_prefix);
+ PatternDeclaration::go (expr.get_pattern (), Rib::ItemType::Var);
+ ResolveExpr::go (expr.get_iterator_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_loop_block (), prefix, canonical_prefix);
// done
resolver->get_name_scope ().pop ();
void
ResolveExpr::visit (AST::BorrowExpr &expr)
{
- ResolveExpr::go (expr.get_borrowed_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_borrowed_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::DereferenceExpr &expr)
{
- ResolveExpr::go (expr.get_dereferenced_expr ().get (), prefix,
- canonical_prefix);
+ ResolveExpr::go (expr.get_dereferenced_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::MatchExpr &expr)
{
- ResolveExpr::go (expr.get_scrutinee_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_scrutinee_expr (), prefix, canonical_prefix);
for (auto &match_case : expr.get_match_cases ())
{
// each arm is in its own scope
// resolve
AST::MatchArm &arm = match_case.get_arm ();
if (arm.has_match_arm_guard ())
- ResolveExpr::go (arm.get_guard_expr ().get (), prefix,
- canonical_prefix);
+ ResolveExpr::go (arm.get_guard_expr (), prefix, canonical_prefix);
// We know expr.get_patterns () has one pattern at most
// so there's no reason to handle it like an AltPattern.
// insert any possible new patterns
for (auto &pattern : arm.get_patterns ())
{
- PatternDeclaration::go (pattern.get (), Rib::ItemType::Var, bindings);
+ PatternDeclaration::go (*pattern, Rib::ItemType::Var, bindings);
}
// resolve the body
- ResolveExpr::go (match_case.get_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (match_case.get_expr (), prefix, canonical_prefix);
// done
resolver->get_name_scope ().pop ();
void
ResolveExpr::visit (AST::RangeFromToExpr &expr)
{
- ResolveExpr::go (expr.get_from_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_to_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_from_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_to_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::RangeFromExpr &expr)
{
- ResolveExpr::go (expr.get_from_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_from_expr (), prefix, canonical_prefix);
}
void
ResolveExpr::visit (AST::RangeToExpr &expr)
{
- ResolveExpr::go (expr.get_to_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_to_expr (), prefix, canonical_prefix);
}
void
void
ResolveExpr::visit (AST::RangeFromToInclExpr &expr)
{
- ResolveExpr::go (expr.get_from_expr ().get (), prefix, canonical_prefix);
- ResolveExpr::go (expr.get_to_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_from_expr (), prefix, canonical_prefix);
+ ResolveExpr::go (expr.get_to_expr (), prefix, canonical_prefix);
}
void
resolver->push_closure_context (expr.get_node_id ());
- ResolveExpr::go (expr.get_definition_expr ().get (), prefix,
- canonical_prefix);
+ ResolveExpr::go (expr.get_definition_expr (), prefix, canonical_prefix);
resolver->pop_closure_context ();
resolve_closure_param (p, bindings);
}
- ResolveType::go (expr.get_return_type ().get ());
+ ResolveType::go (expr.get_return_type ());
resolver->push_closure_context (expr.get_node_id ());
- ResolveExpr::go (expr.get_definition_block ().get (), prefix,
- canonical_prefix);
+ ResolveExpr::go (expr.get_definition_block (), prefix, canonical_prefix);
resolver->pop_closure_context ();
ResolveExpr::resolve_closure_param (AST::ClosureParam ¶m,
std::vector<PatternBinding> &bindings)
{
- PatternDeclaration::go (param.get_pattern ().get (), Rib::ItemType::Param,
- bindings);
+ PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param, bindings);
if (param.has_type_given ())
- ResolveType::go (param.get_type ().get ());
+ ResolveType::go (param.get_type ());
}
ResolveExpr::ResolveExpr (const CanonicalPath &prefix,
using Rust::Resolver::ResolverBase::visit;
public:
- static void go (AST::Expr *expr, const CanonicalPath &prefix,
+ static void go (AST::Expr &expr, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix,
bool funny_error = false);
using Rust::Resolver::ResolverBase::visit;
public:
- static void go (AST::AssociatedItem *item, const CanonicalPath &prefix)
+ static void go (AST::AssociatedItem &item, const CanonicalPath &prefix)
{
- if (item->is_marked_for_strip ())
+ if (item.is_marked_for_strip ())
return;
ResolveToplevelImplItem resolver (prefix);
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
}
void visit (AST::TypeAlias &type) override
using Rust::Resolver::ResolverBase::visit;
public:
- static void go (AST::ExternalItem *item, const CanonicalPath &prefix)
+ static void go (AST::ExternalItem &item, const CanonicalPath &prefix)
{
ResolveToplevelExternItem resolver (prefix);
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
};
void visit (AST::Function &function) override
if (function.has_generics ())
for (auto &generic : function.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
if (function.has_return_type ())
- ResolveType::go (function.get_return_type ().get ());
+ ResolveType::go (function.get_return_type ());
// self turns into (self: Self) as a function param
std::vector<PatternBinding> bindings
{
if (p->is_variadic ())
{
- auto param = static_cast<AST::VariadicParam *> (p.get ());
- PatternDeclaration::go (param->get_pattern ().get (),
- Rib::ItemType::Param, bindings);
+ auto param = static_cast<AST::VariadicParam &> (*p);
+ PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param,
+ bindings);
}
else if (p->is_self ())
{
- auto param = static_cast<AST::SelfParam *> (p.get ());
+ auto ¶m = static_cast<AST::SelfParam &> (*p);
// FIXME: which location should be used for Rust::Identifier `self`?
AST::IdentifierPattern self_pattern (
- param->get_node_id (), {"self"}, param->get_locus (),
- param->get_has_ref (), param->get_is_mut (),
+ param.get_node_id (), {"self"}, param.get_locus (),
+ param.get_has_ref (), param.get_is_mut (),
std::unique_ptr<AST::Pattern> (nullptr));
- PatternDeclaration::go (&self_pattern, Rib::ItemType::Param);
+ PatternDeclaration::go (self_pattern, Rib::ItemType::Param);
- if (param->has_type ())
+ if (param.has_type ())
{
// This shouldn't happen the parser should already error for this
- rust_assert (!param->get_has_ref ());
- ResolveType::go (param->get_type ().get ());
+ rust_assert (!param.get_has_ref ());
+ ResolveType::go (param.get_type ());
}
else
{
// here we implicitly make self have a type path of Self
std::vector<std::unique_ptr<AST::TypePathSegment>> segments;
segments.push_back (std::unique_ptr<AST::TypePathSegment> (
- new AST::TypePathSegment ("Self", false, param->get_locus ())));
+ new AST::TypePathSegment ("Self", false, param.get_locus ())));
AST::TypePath self_type_path (std::move (segments),
- param->get_locus ());
- ResolveType::go (&self_type_path);
+ param.get_locus ());
+ ResolveType::go (self_type_path);
}
}
else
{
- auto param = static_cast<AST::FunctionParam *> (p.get ());
- ResolveType::go (param->get_type ().get ());
- PatternDeclaration::go (param->get_pattern ().get (),
- Rib::ItemType::Param, bindings);
+ auto ¶m = static_cast<AST::FunctionParam &> (*p);
+ ResolveType::go (param.get_type ());
+ PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param,
+ bindings);
}
}
// trait items have an optional body
if (function.has_body ())
- ResolveExpr::go (function.get_definition ()->get (), path, cpath);
+ ResolveExpr::go (*function.get_definition ().value (), path, cpath);
resolver->get_name_scope ().pop ();
resolver->get_type_scope ().pop ();
mappings->insert_canonical_path (type.get_node_id (), cpath);
for (auto &bound : type.get_type_param_bounds ())
- ResolveTypeBound::go (bound.get ());
+ ResolveTypeBound::go (*bound);
}
void
auto cpath = canonical_prefix.append (decl);
mappings->insert_canonical_path (constant.get_node_id (), cpath);
- ResolveType::go (constant.get_type ().get ());
+ ResolveType::go (constant.get_type ());
if (constant.has_expr ())
- ResolveExpr::go (constant.get_expr ().get (), path, cpath);
+ ResolveExpr::go (constant.get_expr (), path, cpath);
}
ResolveItem::ResolveItem (const CanonicalPath &prefix,
{}
void
-ResolveItem::go (AST::Item *item, const CanonicalPath &prefix,
+ResolveItem::go (AST::Item &item, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix)
{
ResolveItem resolver (prefix, canonical_prefix);
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
}
void
if (alias.has_generics ())
for (auto &generic : alias.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
if (alias.has_where_clause ())
ResolveWhereClause::Resolve (alias.get_where_clause ());
- ResolveType::go (alias.get_type_aliased ().get ());
+ ResolveType::go (alias.get_type_aliased ());
resolver->get_type_scope ().pop ();
}
// FIXME: Should we reinsert a child here? Any reason we ResolveTopLevel::go
// in ResolveTopLevel::visit (AST::Module) as well as here?
for (auto &item : module.get_items ())
- ResolveTopLevel::go (item.get (), CanonicalPath::create_empty (), cpath);
+ ResolveTopLevel::go (*item, CanonicalPath::create_empty (), cpath);
resolver->push_new_module_scope (module.get_node_id ());
for (auto &item : module.get_items ())
- ResolveItem::go (item.get (), path, cpath);
+ ResolveItem::go (*item, path, cpath);
resolver->pop_module_scope ();
if (struct_decl.has_generics ())
for (auto &generic : struct_decl.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
if (struct_decl.has_where_clause ())
ResolveWhereClause::Resolve (struct_decl.get_where_clause ());
for (AST::TupleField &field : struct_decl.get_fields ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
resolve_visibility (field.get_visibility ());
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
}
resolver->get_type_scope ().pop ();
if (enum_decl.has_generics ())
for (auto &generic : enum_decl.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, cpath);
+ ResolveGenericParam::go (*generic, prefix, cpath);
if (enum_decl.has_where_clause ())
ResolveWhereClause::Resolve (enum_decl.get_where_clause ());
/* The actual fields are inside the variants. */
for (auto &variant : enum_decl.get_variants ())
- ResolveItem::go (variant.get (), path, cpath);
+ ResolveItem::go (*variant, path, cpath);
resolver->get_type_scope ().pop ();
}
for (auto &field : item.get_tuple_fields ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
}
}
for (auto &field : item.get_struct_fields ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
}
}
if (struct_decl.has_generics ())
for (auto &generic : struct_decl.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
if (struct_decl.has_where_clause ())
ResolveWhereClause::Resolve (struct_decl.get_where_clause ());
for (AST::StructField &field : struct_decl.get_fields ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
resolve_visibility (field.get_visibility ());
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
}
resolver->get_type_scope ().pop ();
if (union_decl.has_generics ())
for (auto &generic : union_decl.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
if (union_decl.has_where_clause ())
ResolveWhereClause::Resolve (union_decl.get_where_clause ());
for (AST::StructField &field : union_decl.get_variants ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
}
resolver->get_type_scope ().pop ();
auto cpath = canonical_prefix.append (decl);
mappings->insert_canonical_path (var.get_node_id (), cpath);
- ResolveType::go (var.get_type ().get ());
- ResolveExpr::go (var.get_expr ().get (), path, cpath);
+ ResolveType::go (var.get_type ());
+ ResolveExpr::go (var.get_expr (), path, cpath);
}
void
resolve_visibility (constant.get_visibility ());
- ResolveType::go (constant.get_type ().get ());
- ResolveExpr::go (constant.get_expr ().get (), path, cpath);
+ ResolveType::go (constant.get_type ());
+ ResolveExpr::go (constant.get_expr (), path, cpath);
}
void
if (function.has_generics ())
for (auto &generic : function.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
// resolve any where clause items
if (function.has_where_clause ())
ResolveWhereClause::Resolve (function.get_where_clause ());
if (function.has_return_type ())
- ResolveType::go (function.get_return_type ().get ());
+ ResolveType::go (function.get_return_type ());
if (function.has_self_param ())
{
self_param.get_node_id (), {"self"}, self_param.get_locus (),
self_param.get_has_ref (), self_param.get_is_mut (),
std::unique_ptr<AST::Pattern> (nullptr));
- PatternDeclaration::go (&self_pattern, Rib::ItemType::Param);
+ PatternDeclaration::go (self_pattern, Rib::ItemType::Param);
if (self_param.has_type ())
{
// This shouldn't happen the parser should already error for this
rust_assert (!self_param.get_has_ref ());
- ResolveType::go (self_param.get_type ().get ());
+ ResolveType::go (self_param.get_type ());
}
else
{
AST::TypePath self_type_path (std::move (segments),
self_param.get_locus ());
- ResolveType::go (&self_type_path);
+ ResolveType::go (self_type_path);
}
}
{
if (p->is_variadic ())
{
- auto param = static_cast<AST::VariadicParam *> (p.get ());
- if (param->has_pattern ())
- PatternDeclaration::go (param->get_pattern ().get (),
- Rib::ItemType::Param, bindings);
+ auto ¶m = static_cast<AST::VariadicParam &> (*p);
+ if (param.has_pattern ())
+ PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param,
+ bindings);
}
else if (p->is_self ())
{
- auto param = static_cast<AST::SelfParam *> (p.get ());
- if (param->has_type ())
- ResolveType::go (param->get_type ().get ());
+ auto ¶m = static_cast<AST::SelfParam &> (*p);
+ if (param.has_type ())
+ ResolveType::go (param.get_type ());
}
else
{
- auto param = static_cast<AST::FunctionParam *> (p.get ());
- ResolveType::go (param->get_type ().get ());
- PatternDeclaration::go (param->get_pattern ().get (),
- Rib::ItemType::Param, bindings);
+ auto ¶m = static_cast<AST::FunctionParam &> (*p);
+ ResolveType::go (param.get_type ());
+ PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param,
+ bindings);
}
}
// resolve the function body
- ResolveExpr::go (function.get_definition ()->get (), path, cpath);
+ ResolveExpr::go (*function.get_definition ().value (), path, cpath);
resolver->get_name_scope ().pop ();
resolver->get_type_scope ().pop ();
if (impl_block.has_generics ())
for (auto &generic : impl_block.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
// resolve any where clause items
if (impl_block.has_where_clause ())
// FIXME this needs to be protected behind nominal type-checks see:
// rustc --explain E0118
// issue #2634
- ResolveType::go (impl_block.get_type ().get ());
+ ResolveType::go (impl_block.get_type ());
// Setup paths
CanonicalPath self_cpath = CanonicalPath::create_empty ();
- bool ok = ResolveTypeToCanonicalPath::go (impl_block.get_type ().get (),
- self_cpath);
+ bool ok = ResolveTypeToCanonicalPath::go (impl_block.get_type (), self_cpath);
rust_assert (ok);
rust_debug ("AST::InherentImpl resolve Self: {%s}",
self_cpath.get ().c_str ());
// done setup paths
auto Self
- = CanonicalPath::get_big_self (impl_block.get_type ()->get_node_id ());
+ = CanonicalPath::get_big_self (impl_block.get_type ().get_node_id ());
resolver->get_type_scope ().insert (Self,
- impl_block.get_type ()->get_node_id (),
- impl_block.get_type ()->get_locus ());
+ impl_block.get_type ().get_node_id (),
+ impl_block.get_type ().get_locus ());
for (auto &impl_item : impl_block.get_impl_items ())
{
rust_debug (
"AST::InherentImpl resolve_impl_item: impl_prefix={%s} cpath={%s}",
impl_prefix.get ().c_str (), cpath.get ().c_str ());
- resolve_impl_item (impl_item.get (), impl_prefix, cpath);
+ resolve_impl_item (*impl_item, impl_prefix, cpath);
}
resolver->get_type_scope ().peek ()->clear_name (
- Self, impl_block.get_type ()->get_node_id ());
+ Self, impl_block.get_type ().get_node_id ());
resolver->get_type_scope ().pop ();
resolver->get_name_scope ().pop ();
if (impl_block.has_generics ())
for (auto &generic : impl_block.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
// resolve any where clause items
if (impl_block.has_where_clause ())
ResolveWhereClause::Resolve (impl_block.get_where_clause ());
// CanonicalPath canonical_trait_type = CanonicalPath::create_empty ();
- NodeId trait_resolved_node = ResolveType::go (&impl_block.get_trait_path ());
+ NodeId trait_resolved_node = ResolveType::go (impl_block.get_trait_path ());
if (trait_resolved_node == UNKNOWN_NODEID)
{
resolver->get_name_scope ().pop ();
}
// CanonicalPath canonical_impl_type = CanonicalPath::create_empty ();
- NodeId type_resolved_node = ResolveType::go (impl_block.get_type ().get ());
+ NodeId type_resolved_node = ResolveType::go (impl_block.get_type ());
if (type_resolved_node == UNKNOWN_NODEID)
{
resolver->get_name_scope ().pop ();
bool ok;
// setup paths
CanonicalPath canonical_trait_type = CanonicalPath::create_empty ();
- ok = ResolveTypeToCanonicalPath::go (&impl_block.get_trait_path (),
+ ok = ResolveTypeToCanonicalPath::go (impl_block.get_trait_path (),
canonical_trait_type);
rust_assert (ok);
canonical_trait_type.get ().c_str ());
CanonicalPath canonical_impl_type = CanonicalPath::create_empty ();
- ok = ResolveTypeToCanonicalPath::go (impl_block.get_type ().get (),
+ ok = ResolveTypeToCanonicalPath::go (impl_block.get_type (),
canonical_impl_type);
rust_assert (ok);
// DONE setup canonical-path
auto Self
- = CanonicalPath::get_big_self (impl_block.get_type ()->get_node_id ());
+ = CanonicalPath::get_big_self (impl_block.get_type ().get_node_id ());
resolver->get_type_scope ().insert (Self,
- impl_block.get_type ()->get_node_id (),
- impl_block.get_type ()->get_locus ());
+ impl_block.get_type ().get_node_id (),
+ impl_block.get_type ().get_locus ());
for (auto &impl_item : impl_block.get_impl_items ())
{
rust_debug (
"AST::TraitImpl resolve_impl_item: impl_prefix={%s} cpath={%s}",
impl_prefix.get ().c_str (), cpath.get ().c_str ());
- resolve_impl_item (impl_item.get (), impl_prefix, cpath);
+ resolve_impl_item (*impl_item, impl_prefix, cpath);
}
Rib *r = resolver->get_type_scope ().peek ();
- r->clear_name (Self, impl_block.get_type ()->get_node_id ());
+ r->clear_name (Self, impl_block.get_type ().get_node_id ());
resolver->get_name_scope ().pop ();
resolver->get_type_scope ().pop ();
CanonicalPath Self = CanonicalPath::get_big_self (trait.get_node_id ());
for (auto &generic : trait.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
// Self is an implicit TypeParam so lets mark it as such
resolver->get_type_scope ().append_reference_for_def (
{
for (auto &bound : trait.get_type_param_bounds ())
{
- ResolveTypeBound::go (bound.get ());
+ ResolveTypeBound::go (*bound);
}
}
for (auto &item : extern_block.get_extern_items ())
{
- resolve_extern_item (item.get ());
+ resolve_extern_item (*item);
}
}
void
-ResolveItem::resolve_impl_item (AST::AssociatedItem *item,
+ResolveItem::resolve_impl_item (AST::AssociatedItem &item,
const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix)
{
}
void
-ResolveItem::resolve_extern_item (AST::ExternalItem *item)
+ResolveItem::resolve_extern_item (AST::ExternalItem &item)
{
ResolveExternItem::go (item, prefix, canonical_prefix);
}
auto &path = import.get_path ();
rust_debug ("resolving use-decl path: [%s]", path.as_string ().c_str ());
- NodeId resolved_node_id = ResolvePath::go (&path);
+ NodeId resolved_node_id = ResolvePath::go (path);
bool ok = resolved_node_id != UNKNOWN_NODEID;
if (!ok)
continue;
{}
void
-ResolveImplItems::go (AST::AssociatedItem *item, const CanonicalPath &prefix,
+ResolveImplItems::go (AST::AssociatedItem &item, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix)
{
- if (item->is_marked_for_strip ())
+ if (item.is_marked_for_strip ())
return;
ResolveImplItems resolver (prefix, canonical_prefix);
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
}
void
}
void
-ResolveExternItem::go (AST::ExternalItem *item, const CanonicalPath &prefix,
+ResolveExternItem::go (AST::ExternalItem &item, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix)
{
ResolveExternItem resolver (prefix, canonical_prefix);
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
}
void
// resolve the generics
if (function.has_generics ())
for (auto &generic : function.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
if (function.has_return_type ())
- ResolveType::go (function.get_return_type ().get ());
+ ResolveType::go (function.get_return_type ());
// we make a new scope so the names of parameters are resolved and shadowed
// correctly
- for (auto &it : function.get_function_params ())
- if (!it->is_variadic ())
+ for (auto ¶m : function.get_function_params ())
+ if (!param->is_variadic ())
{
- auto param = static_cast<AST::FunctionParam *> (it.get ());
- ResolveType::go (param->get_type ().get ());
+ auto &p = static_cast<AST::FunctionParam &> (*param);
+ ResolveType::go (p.get_type ());
}
// done
{
resolve_visibility (item.get_visibility ());
- ResolveType::go (item.get_type ().get ());
+ ResolveType::go (item.get_type ());
}
} // namespace Resolver
public:
using Rust::Resolver::ResolverBase::visit;
- static void go (AST::Item *item, const CanonicalPath &prefix,
+ static void go (AST::Item &item, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix);
void visit (AST::TypeAlias &alias) override;
void visit (AST::UseDeclaration &) override;
protected:
- void resolve_impl_item (AST::AssociatedItem *item,
+ void resolve_impl_item (AST::AssociatedItem &item,
const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix);
- void resolve_extern_item (AST::ExternalItem *item);
+ void resolve_extern_item (AST::ExternalItem &item);
ResolveItem (const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix);
using Rust::Resolver::ResolveItem::visit;
public:
- static void go (AST::AssociatedItem *item, const CanonicalPath &prefix,
+ static void go (AST::AssociatedItem &item, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix);
void visit (AST::TypeAlias &alias) override;
using Rust::Resolver::ResolverBase::visit;
public:
- static void go (AST::ExternalItem *item, const CanonicalPath &prefix,
+ static void go (AST::ExternalItem &item, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix);
void visit (AST::Function &function) override;
ResolvePath::ResolvePath () : ResolverBase () {}
NodeId
-ResolvePath::go (AST::PathInExpression *expr)
+ResolvePath::go (AST::PathInExpression &expr)
{
ResolvePath resolver;
return resolver.resolve_path (expr);
}
NodeId
-ResolvePath::go (AST::QualifiedPathInExpression *expr)
+ResolvePath::go (AST::QualifiedPathInExpression &expr)
{
ResolvePath resolver;
return resolver.resolve_path (expr);
}
NodeId
-ResolvePath::go (AST::SimplePath *expr)
+ResolvePath::go (AST::SimplePath &expr)
{
ResolvePath resolver;
return resolver.resolve_path (expr);
}
NodeId
-ResolvePath::resolve_path (AST::PathInExpression *expr)
+ResolvePath::resolve_path (AST::PathInExpression &expr)
{
NodeId resolved_node_id = UNKNOWN_NODEID;
NodeId module_scope_id = resolver->peek_current_module_scope ();
NodeId previous_resolved_node_id = module_scope_id;
- for (size_t i = 0; i < expr->get_segments ().size (); i++)
+ for (size_t i = 0; i < expr.get_segments ().size (); i++)
{
- auto &segment = expr->get_segments ().at (i);
+ auto &segment = expr.get_segments ().at (i);
const AST::PathIdentSegment &ident_seg = segment.get_ident_segment ();
bool is_first_segment = i == 0;
resolved_node_id = UNKNOWN_NODEID;
// name scope first
if (resolver->get_name_scope ().decl_was_declared_here (resolved_node_id))
{
- resolver->insert_resolved_name (expr->get_node_id (),
+ resolver->insert_resolved_name (expr.get_node_id (),
resolved_node_id);
}
// check the type scope
else if (resolver->get_type_scope ().decl_was_declared_here (
resolved_node_id))
{
- resolver->insert_resolved_type (expr->get_node_id (),
+ resolver->insert_resolved_type (expr.get_node_id (),
resolved_node_id);
}
else
}
NodeId
-ResolvePath::resolve_path (AST::QualifiedPathInExpression *expr)
+ResolvePath::resolve_path (AST::QualifiedPathInExpression &expr)
{
- AST::QualifiedPathType &root_segment = expr->get_qualified_path_type ();
- ResolveType::go (root_segment.get_type ().get ());
+ auto &root_segment = expr.get_qualified_path_type ();
+ ResolveType::go (root_segment.get_type ());
if (root_segment.has_as_clause ())
- ResolveType::go (&root_segment.get_as_type_path ());
+ ResolveType::go (root_segment.get_as_type_path ());
- for (auto &segment : expr->get_segments ())
+ for (auto &segment : expr.get_segments ())
{
// we cant actually do anything with the segment itself since this is all
// the job of the type system to figure it out but we can resolve any
}
NodeId
-ResolvePath::resolve_path (AST::SimplePath *expr)
+ResolvePath::resolve_path (AST::SimplePath &expr)
{
NodeId crate_scope_id = resolver->peek_crate_module_scope ();
NodeId module_scope_id = resolver->peek_current_module_scope ();
NodeId previous_resolved_node_id = UNKNOWN_NODEID;
NodeId resolved_node_id = UNKNOWN_NODEID;
- for (size_t i = 0; i < expr->get_segments ().size (); i++)
+ for (size_t i = 0; i < expr.get_segments ().size (); i++)
{
- AST::SimplePathSegment &segment = expr->get_segments ().at (i);
+ AST::SimplePathSegment &segment = expr.get_segments ().at (i);
bool is_first_segment = i == 0;
- bool is_final_segment = i >= (expr->get_segments ().size () - 1);
+ bool is_final_segment = i >= (expr.get_segments ().size () - 1);
resolved_node_id = UNKNOWN_NODEID;
if (segment.is_crate_path_seg ())
// name scope first
if (resolver->get_name_scope ().decl_was_declared_here (resolved_node_id))
{
- resolver->insert_resolved_name (expr->get_node_id (),
+ resolver->insert_resolved_name (expr.get_node_id (),
resolved_node_id);
}
// check the type scope
else if (resolver->get_type_scope ().decl_was_declared_here (
resolved_node_id))
{
- resolver->insert_resolved_type (expr->get_node_id (),
+ resolver->insert_resolved_type (expr.get_node_id (),
resolved_node_id);
}
else
using Rust::Resolver::ResolverBase::visit;
public:
- static NodeId go (AST::PathInExpression *expr);
- static NodeId go (AST::QualifiedPathInExpression *expr);
- static NodeId go (AST::SimplePath *expr);
+ static NodeId go (AST::PathInExpression &expr);
+ static NodeId go (AST::QualifiedPathInExpression &expr);
+ static NodeId go (AST::SimplePath &expr);
private:
ResolvePath ();
- NodeId resolve_path (AST::PathInExpression *expr);
- NodeId resolve_path (AST::QualifiedPathInExpression *expr);
- NodeId resolve_path (AST::SimplePath *expr);
+ NodeId resolve_path (AST::PathInExpression &expr);
+ NodeId resolve_path (AST::QualifiedPathInExpression &expr);
+ NodeId resolve_path (AST::SimplePath &expr);
void
resolve_simple_path_segments (CanonicalPath prefix, size_t offs,
namespace Resolver {
void
-PatternDeclaration::go (AST::Pattern *pattern, Rib::ItemType type)
+PatternDeclaration::go (AST::Pattern &pattern, Rib::ItemType type)
{
std::vector<PatternBinding> bindings
= {PatternBinding (PatternBoundCtx::Product, std::set<Identifier> ())};
}
void
-PatternDeclaration::go (AST::Pattern *pattern, Rib::ItemType type,
+PatternDeclaration::go (AST::Pattern &pattern, Rib::ItemType type,
std::vector<PatternBinding> &bindings)
{
PatternDeclaration resolver (bindings, type);
- pattern->accept_vis (resolver);
+ pattern.accept_vis (resolver);
for (auto &map_entry : resolver.missing_bindings)
{
void
PatternDeclaration::visit (AST::GroupedPattern &pattern)
{
- pattern.get_pattern_in_parens ()->accept_vis (*this);
+ pattern.get_pattern_in_parens ().accept_vis (*this);
}
void
PatternDeclaration::visit (AST::ReferencePattern &pattern)
{
- pattern.get_referenced_pattern ()->accept_vis (*this);
+ pattern.get_referenced_pattern ().accept_vis (*this);
}
void
PatternDeclaration::visit (AST::PathInExpression &pattern)
{
- ResolvePath::go (&pattern);
+ ResolvePath::go (pattern);
}
void
PatternDeclaration::visit (AST::TupleStructPattern &pattern)
{
- ResolvePath::go (&pattern.get_path ());
+ ResolvePath::go (pattern.get_path ());
- std::unique_ptr<AST::TupleStructItems> &items = pattern.get_items ();
- switch (items->get_item_type ())
+ AST::TupleStructItems &items = pattern.get_items ();
+ switch (items.get_item_type ())
{
case AST::TupleStructItems::RANGE: {
// TODO
break;
case AST::TupleStructItems::NO_RANGE: {
- AST::TupleStructItemsNoRange &items_no_range
- = static_cast<AST::TupleStructItemsNoRange &> (*items.get ());
+ auto &items_no_range
+ = static_cast<AST::TupleStructItemsNoRange &> (items);
for (auto &inner_pattern : items_no_range.get_patterns ())
{
- inner_pattern.get ()->accept_vis (*this);
+ inner_pattern->accept_vis (*this);
}
}
break;
void
PatternDeclaration::visit (AST::StructPattern &pattern)
{
- ResolvePath::go (&pattern.get_path ());
+ ResolvePath::go (pattern.get_path ());
auto &struct_pattern_elems = pattern.get_struct_pattern_elems ();
for (auto &field : struct_pattern_elems.get_struct_pattern_fields ())
AST::StructPatternFieldTuplePat &tuple
= static_cast<AST::StructPatternFieldTuplePat &> (*field);
- tuple.get_index_pattern ()->accept_vis (*this);
+ tuple.get_index_pattern ().accept_vis (*this);
}
break;
AST::StructPatternFieldIdentPat &ident
= static_cast<AST::StructPatternFieldIdentPat &> (*field);
- ident.get_ident_pattern ()->accept_vis (*this);
+ ident.get_ident_pattern ().accept_vis (*this);
}
break;
case AST::StructPatternField::ItemType::IDENT: {
- AST::StructPatternFieldIdent &ident
- = static_cast<AST::StructPatternFieldIdent &> (*field.get ());
+ auto &ident = static_cast<AST::StructPatternFieldIdent &> (*field);
Mutability mut
= ident.is_mut () ? Mutability::Mut : Mutability::Imm;
void
PatternDeclaration::visit (AST::TuplePattern &pattern)
{
- std::unique_ptr<AST::TuplePatternItems> &items = pattern.get_items ();
- switch (items->get_pattern_type ())
+ auto &items = pattern.get_items ();
+ switch (items.get_pattern_type ())
{
case AST::TuplePatternItems::TuplePatternItemType::MULTIPLE: {
- AST::TuplePatternItemsMultiple &ref
- = *static_cast<AST::TuplePatternItemsMultiple *> (
- pattern.get_items ().get ());
+ auto &ref = static_cast<AST::TuplePatternItemsMultiple &> (
+ pattern.get_items ());
for (auto &p : ref.get_patterns ())
p->accept_vis (*this);
break;
case AST::TuplePatternItems::TuplePatternItemType::RANGED: {
- AST::TuplePatternItemsRanged &ref
- = *static_cast<AST::TuplePatternItemsRanged *> (
- pattern.get_items ().get ());
+ auto &ref
+ = static_cast<AST::TuplePatternItemsRanged &> (pattern.get_items ());
for (auto &p : ref.get_lower_patterns ())
p->accept_vis (*this);
}
static void
-resolve_range_pattern_bound (AST::RangePatternBound *bound)
+resolve_range_pattern_bound (AST::RangePatternBound &bound)
{
- switch (bound->get_bound_type ())
+ switch (bound.get_bound_type ())
{
case AST::RangePatternBound::RangePatternBoundType::LITERAL:
// Nothing to resolve for a literal.
break;
case AST::RangePatternBound::RangePatternBoundType::PATH: {
- AST::RangePatternBoundPath &ref
- = *static_cast<AST::RangePatternBoundPath *> (bound);
+ auto &ref = static_cast<AST::RangePatternBoundPath &> (bound);
- ResolvePath::go (&ref.get_path ());
+ ResolvePath::go (ref.get_path ());
}
break;
case AST::RangePatternBound::RangePatternBoundType::QUALPATH: {
- AST::RangePatternBoundQualPath &ref
- = *static_cast<AST::RangePatternBoundQualPath *> (bound);
+ auto &ref = static_cast<AST::RangePatternBoundQualPath &> (bound);
- ResolvePath::go (&ref.get_qualified_path ());
+ ResolvePath::go (ref.get_qualified_path ());
}
break;
}
void
PatternDeclaration::visit (AST::RangePattern &pattern)
{
- resolve_range_pattern_bound (pattern.get_upper_bound ().get ());
- resolve_range_pattern_bound (pattern.get_lower_bound ().get ());
+ resolve_range_pattern_bound (pattern.get_upper_bound ());
+ resolve_range_pattern_bound (pattern.get_lower_bound ());
}
void
using Rust::Resolver::ResolverBase::visit;
public:
- static void go (AST::Pattern *pattern, Rib::ItemType type);
- static void go (AST::Pattern *pattern, Rib::ItemType type,
+ static void go (AST::Pattern &pattern, Rib::ItemType type);
+ static void go (AST::Pattern &pattern, Rib::ItemType type,
std::vector<PatternBinding> &bindings);
void visit (AST::IdentifierPattern &pattern) override;
resolve_visibility (extern_block.get_visibility ());
for (auto &item : extern_block.get_extern_items ())
{
- ResolveToplevelExternItem::go (item.get (),
- CanonicalPath::create_empty ());
- ResolveExternItem::go (item.get (), prefix, canonical_prefix);
+ ResolveToplevelExternItem::go (*item, CanonicalPath::create_empty ());
+ ResolveExternItem::go (*item, prefix, canonical_prefix);
}
}
void
ResolveStmt::visit (AST::Trait &trait)
{
- ResolveTopLevel::go (&trait, prefix, canonical_prefix);
- ResolveItem::go (&trait, prefix, canonical_prefix);
+ ResolveTopLevel::go (trait, prefix, canonical_prefix);
+ ResolveItem::go (trait, prefix, canonical_prefix);
}
void
ResolveStmt::visit (AST::InherentImpl &impl_block)
{
- ResolveTopLevel::go (&impl_block, prefix, canonical_prefix);
- ResolveItem::go (&impl_block, prefix, canonical_prefix);
+ ResolveTopLevel::go (impl_block, prefix, canonical_prefix);
+ ResolveItem::go (impl_block, prefix, canonical_prefix);
}
void
ResolveStmt::visit (AST::TraitImpl &impl_block)
{
- ResolveTopLevel::go (&impl_block, prefix, canonical_prefix);
- ResolveItem::go (&impl_block, prefix, canonical_prefix);
+ ResolveTopLevel::go (impl_block, prefix, canonical_prefix);
+ ResolveItem::go (impl_block, prefix, canonical_prefix);
}
} // namespace Resolver
using Rust::Resolver::ResolverBase::visit;
public:
- static void go (AST::Stmt *stmt, const CanonicalPath &prefix,
+ static void go (AST::Stmt &stmt, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix,
const CanonicalPath &enum_prefix)
{
- if (stmt->is_marked_for_strip ())
+ if (stmt.is_marked_for_strip ())
return;
ResolveStmt resolver (prefix, canonical_prefix, enum_prefix);
- stmt->accept_vis (resolver);
+ stmt.accept_vis (resolver);
}
void visit (AST::ExprStmt &stmt) override
{
- ResolveExpr::go (stmt.get_expr ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (stmt.get_expr (), prefix, canonical_prefix);
}
void visit (AST::ConstantItem &constant) override
rust_error_at (r, "redefined multiple times");
});
- ResolveType::go (constant.get_type ().get ());
- ResolveExpr::go (constant.get_expr ().get (), prefix, canonical_prefix);
+ ResolveType::go (constant.get_type ());
+ ResolveExpr::go (constant.get_expr (), prefix, canonical_prefix);
}
void visit (AST::LetStmt &stmt) override
{
if (stmt.has_init_expr ())
{
- ResolveExpr::go (stmt.get_init_expr ().get (), prefix,
- canonical_prefix);
+ ResolveExpr::go (stmt.get_init_expr (), prefix, canonical_prefix);
}
- PatternDeclaration::go (stmt.get_pattern ().get (), Rib::ItemType::Var);
+ PatternDeclaration::go (stmt.get_pattern (), Rib::ItemType::Var);
if (stmt.has_type ())
- ResolveType::go (stmt.get_type ().get ());
+ ResolveType::go (stmt.get_type ());
}
void visit (AST::TupleStruct &struct_decl) override
if (struct_decl.has_generics ())
{
for (auto &generic : struct_decl.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
}
for (AST::TupleField &field : struct_decl.get_fields ())
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
resolver->get_type_scope ().pop ();
}
if (enum_decl.has_generics ())
{
for (auto &generic : enum_decl.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
}
for (auto &variant : enum_decl.get_variants ())
- ResolveStmt::go (variant.get (), path, canonical_prefix, path);
+ ResolveStmt::go (*variant, path, canonical_prefix, path);
resolver->get_type_scope ().pop ();
}
for (auto &field : item.get_tuple_fields ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
}
}
for (auto &field : item.get_struct_fields ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
}
}
if (struct_decl.has_generics ())
{
for (auto &generic : struct_decl.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
}
for (AST::StructField &field : struct_decl.get_fields ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
}
resolver->get_type_scope ().pop ();
if (union_decl.has_generics ())
for (auto &generic : union_decl.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
for (AST::StructField &field : union_decl.get_variants ())
{
- if (field.get_field_type ()->is_marked_for_strip ())
+ if (field.get_field_type ().is_marked_for_strip ())
continue;
- ResolveType::go (field.get_field_type ().get ());
+ ResolveType::go (field.get_field_type ());
}
resolver->get_type_scope ().pop ();
if (function.has_generics ())
for (auto &generic : function.get_generic_params ())
- ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+ ResolveGenericParam::go (*generic, prefix, canonical_prefix);
if (function.has_return_type ())
- ResolveType::go (function.get_return_type ().get ());
+ ResolveType::go (function.get_return_type ());
std::vector<PatternBinding> bindings
= {PatternBinding (PatternBoundCtx::Product, std::set<Identifier> ())};
{
if (p->is_variadic ())
{
- auto param = static_cast<AST::VariadicParam *> (p.get ());
- PatternDeclaration::go (param->get_pattern ().get (),
- Rib::ItemType::Param, bindings);
+ auto ¶m = static_cast<AST::VariadicParam &> (*p);
+ PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param,
+ bindings);
}
else if (p->is_self ())
{
- auto param = static_cast<AST::SelfParam *> (p.get ());
- ResolveType::go (param->get_type ().get ());
+ auto ¶m = static_cast<AST::SelfParam &> (*p);
+ ResolveType::go (param.get_type ());
}
else
{
- auto param = static_cast<AST::FunctionParam *> (p.get ());
+ auto ¶m = static_cast<AST::FunctionParam &> (*p);
- ResolveType::go (param->get_type ().get ());
- PatternDeclaration::go (param->get_pattern ().get (),
- Rib::ItemType::Param, bindings);
+ ResolveType::go (param.get_type ());
+ PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param,
+ bindings);
}
}
// resolve the function body
- ResolveExpr::go (function.get_definition ()->get (), path, cpath);
+ ResolveExpr::go (*function.get_definition ().value (), path, cpath);
resolver->get_name_scope ().pop ();
resolver->get_type_scope ().pop ();
namespace Resolver {
void
-ResolveStructExprField::go (AST::StructExprField *field,
+ResolveStructExprField::go (AST::StructExprField &field,
const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix)
{
ResolveStructExprField resolver (prefix, canonical_prefix);
- field->accept_vis (resolver);
+ field.accept_vis (resolver);
}
ResolveStructExprField::ResolveStructExprField (
void
ResolveStructExprField::visit (AST::StructExprFieldIdentifierValue &field)
{
- ResolveExpr::go (field.get_value ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (field.get_value (), prefix, canonical_prefix);
}
void
ResolveStructExprField::visit (AST::StructExprFieldIndexValue &field)
{
- ResolveExpr::go (field.get_value ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (field.get_value (), prefix, canonical_prefix);
}
void
AST::IdentifierExpr expr (field.get_field_name (), {}, field.get_locus ());
expr.set_node_id (field.get_node_id ());
- ResolveExpr::go (&expr, prefix, canonical_prefix);
+ ResolveExpr::go (expr, prefix, canonical_prefix);
}
} // namespace Resolver
using Rust::Resolver::ResolverBase::visit;
public:
- static void go (AST::StructExprField *field, const CanonicalPath &prefix,
+ static void go (AST::StructExprField &field, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix);
void visit (AST::StructExprFieldIdentifierValue &field) override;
using Rust::Resolver::ResolverBase::visit;
public:
- static void go (AST::Item *item, const CanonicalPath &prefix,
+ static void go (AST::Item &item, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix)
{
- if (item->is_marked_for_strip ())
+ if (item.is_marked_for_strip ())
return;
ResolveTopLevel resolver (prefix, canonical_prefix);
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
NodeId current_module = resolver.resolver->peek_current_module_scope ();
resolver.mappings->insert_child_item_to_parent_module_mapping (
- item->get_node_id (), current_module);
+ item.get_node_id (), current_module);
}
void visit (AST::Module &module) override
resolver->push_new_module_scope (module.get_node_id ());
for (auto &item : module.get_items ())
- ResolveTopLevel::go (item.get (), path, cpath);
+ ResolveTopLevel::go (*item, path, cpath);
resolver->pop_module_scope ();
resolver->push_new_module_scope (enum_decl.get_node_id ());
for (auto &variant : enum_decl.get_variants ())
- ResolveTopLevel::go (variant.get (), path, cpath);
+ ResolveTopLevel::go (*variant, path, cpath);
resolver->pop_module_scope ();
void visit (AST::InherentImpl &impl_block) override
{
- std::string raw_impl_type_path = impl_block.get_type ()->as_string ();
+ std::string raw_impl_type_path = impl_block.get_type ().as_string ();
CanonicalPath impl_type_seg
- = CanonicalPath::new_seg (impl_block.get_type ()->get_node_id (),
+ = CanonicalPath::new_seg (impl_block.get_type ().get_node_id (),
raw_impl_type_path);
CanonicalPath impl_type
CanonicalPath impl_prefix = prefix.append (impl_type_seg);
for (auto &impl_item : impl_block.get_impl_items ())
- ResolveToplevelImplItem::go (impl_item.get (), impl_prefix);
+ ResolveToplevelImplItem::go (*impl_item, impl_prefix);
}
void visit (AST::TraitImpl &impl_block) override
{
- std::string raw_impl_type_path = impl_block.get_type ()->as_string ();
+ std::string raw_impl_type_path = impl_block.get_type ().as_string ();
CanonicalPath impl_type_seg
- = CanonicalPath::new_seg (impl_block.get_type ()->get_node_id (),
+ = CanonicalPath::new_seg (impl_block.get_type ().get_node_id (),
raw_impl_type_path);
std::string raw_trait_type_path = impl_block.get_trait_path ().as_string ();
});
for (auto &impl_item : impl_block.get_impl_items ())
- ResolveToplevelImplItem::go (impl_item.get (), impl_prefix);
+ ResolveToplevelImplItem::go (*impl_item, impl_prefix);
}
void visit (AST::Trait &trait) override
{
for (auto &item : extern_block.get_extern_items ())
{
- ResolveToplevelExternItem::go (item.get (), prefix);
+ ResolveToplevelExternItem::go (*item, prefix);
}
}
void
ResolveType::visit (AST::ArrayType &type)
{
- type.get_elem_type ()->accept_vis (*this);
- ResolveExpr::go (type.get_size_expr ().get (), CanonicalPath::create_empty (),
+ type.get_elem_type ().accept_vis (*this);
+ ResolveExpr::go (type.get_size_expr (), CanonicalPath::create_empty (),
CanonicalPath::create_empty ());
}
void
ResolveType::visit (AST::TraitObjectTypeOneBound &type)
{
- ResolveTypeBound::go (&type.get_trait_bound ());
+ ResolveTypeBound::go (type.get_trait_bound ());
}
void
for (auto &bound : type.get_type_param_bounds ())
{
/* NodeId bound_resolved_id = */
- ResolveTypeBound::go (bound.get ());
+ ResolveTypeBound::go (*bound);
}
}
void
ResolveType::visit (AST::ReferenceType &type)
{
- resolved_node = ResolveType::go (type.get_type_referenced ().get ());
+ resolved_node = ResolveType::go (type.get_type_referenced ());
}
void
ResolveType::visit (AST::RawPointerType &type)
{
- resolved_node = ResolveType::go (type.get_type_pointed_to ().get ());
+ resolved_node = ResolveType::go (type.get_type_pointed_to ());
}
void
void
ResolveType::visit (AST::SliceType &type)
{
- resolved_node = ResolveType::go (type.get_elem_type ().get ());
+ resolved_node = ResolveType::go (type.get_elem_type ());
}
// resolve relative type-paths
AST::TypePathFunction &fn = fnseg->get_type_path_function ();
for (auto ¶m : fn.get_params ())
{
- ResolveType::go (param.get ());
+ ResolveType::go (*param);
}
if (fn.has_return_type ())
{
- ResolveType::go (fn.get_return_type ().get ());
+ ResolveType::go (fn.get_return_type ());
}
break;
return false;
}
- auto type = seg.get_type ().get ();
+ auto &type = seg.get_type ();
ResolveType::go (type);
if (seg.has_as_clause ())
- ResolveType::go (&seg.get_as_type_path ());
+ ResolveType::go (seg.get_as_type_path ());
return true;
}
// resolve to canonical path
bool
-ResolveTypeToCanonicalPath::go (AST::Type *type, CanonicalPath &result)
+ResolveTypeToCanonicalPath::go (AST::Type &type, CanonicalPath &result)
{
ResolveTypeToCanonicalPath resolver;
- type->accept_vis (resolver);
+ type.accept_vis (resolver);
result = resolver.result;
return !resolver.result.is_empty ();
}
if (generic.get_kind () == AST::GenericArg::Kind::Type)
{
CanonicalPath arg = CanonicalPath::create_empty ();
- bool ok = ResolveTypeToCanonicalPath::go (
- generic.get_type ().get (), arg);
+ bool ok
+ = ResolveTypeToCanonicalPath::go (generic.get_type (),
+ arg);
if (ok)
args.push_back (std::move (arg));
}
ResolveTypeToCanonicalPath::visit (AST::ReferenceType &type)
{
CanonicalPath path = CanonicalPath::create_empty ();
- bool ok
- = ResolveTypeToCanonicalPath::go (type.get_type_referenced ().get (), path);
+ bool ok = ResolveTypeToCanonicalPath::go (type.get_type_referenced (), path);
if (ok)
{
std::string ref_type_str = type.is_mut () ? "mut" : "";
ResolveTypeToCanonicalPath::visit (AST::RawPointerType &type)
{
CanonicalPath path = CanonicalPath::create_empty ();
- bool ok
- = ResolveTypeToCanonicalPath::go (type.get_type_pointed_to ().get (), path);
+ bool ok = ResolveTypeToCanonicalPath::go (type.get_type_pointed_to (), path);
if (ok)
{
std::string ptr_type_str
ResolveTypeToCanonicalPath::visit (AST::SliceType &type)
{
CanonicalPath path = CanonicalPath::create_empty ();
- bool ok = ResolveTypeToCanonicalPath::go (type.get_elem_type ().get (), path);
+ bool ok = ResolveTypeToCanonicalPath::go (type.get_elem_type (), path);
if (ok)
{
std::string slice_path = "[" + path.get () + "]";
{
CanonicalPath path = CanonicalPath::create_empty ();
bool ok
- = ResolveTypeToCanonicalPath::go (&type.get_trait_bound ().get_type_path (),
+ = ResolveTypeToCanonicalPath::go (type.get_trait_bound ().get_type_path (),
path);
if (ok)
{
switch (arg.get_kind ())
{
case AST::GenericArg::Kind::Const:
- ResolveExpr::go (arg.get_expression ().get (), prefix, canonical_prefix);
+ ResolveExpr::go (arg.get_expression (), prefix, canonical_prefix);
break;
case AST::GenericArg::Kind::Type:
- ResolveType::go (arg.get_type ().get ());
+ ResolveType::go (arg.get_type ());
break;
default:
rust_unreachable ();
for (auto &binding : generic_args.get_binding_args ())
{
- ResolveType::go (binding.get_type ().get ());
+ ResolveType::go (binding.get_type ());
}
}
using Rust::Resolver::ResolverBase::visit;
public:
- static NodeId go (AST::Type *type)
+ static NodeId go (AST::Type &type)
{
ResolveType resolver;
- type->accept_vis (resolver);
+ type.accept_vis (resolver);
return resolver.resolved_node;
}
void visit (AST::BareFunctionType &fntype) override
{
for (auto ¶m : fntype.get_function_params ())
- ResolveType::go (param.get_type ().get ());
+ ResolveType::go (param.get_type ());
if (fntype.has_return_type ())
- ResolveType::go (fntype.get_return_type ().get ());
+ ResolveType::go (fntype.get_return_type ());
}
void visit (AST::TupleType &tuple) override
}
for (auto &elem : tuple.get_elems ())
- ResolveType::go (elem.get ());
+ ResolveType::go (*elem);
}
void visit (AST::TypePath &path) override
using Rust::Resolver::ResolverBase::visit;
public:
- static NodeId go (AST::TypeParamBound *type)
+ static NodeId go (AST::TypeParamBound &type)
{
ResolveTypeBound resolver;
- type->accept_vis (resolver);
+ type.accept_vis (resolver);
return resolver.resolved_node;
};
void visit (AST::TraitBound &bound) override
{
- resolved_node = ResolveType::go (&bound.get_type_path ());
+ resolved_node = ResolveType::go (bound.get_type_path ());
}
private:
using Rust::Resolver::ResolverBase::visit;
public:
- static NodeId go (AST::GenericParam *param, const CanonicalPath &prefix,
+ static NodeId go (AST::GenericParam ¶m, const CanonicalPath &prefix,
const CanonicalPath &canonical_prefix)
{
ResolveGenericParam resolver (prefix, canonical_prefix);
- param->accept_vis (resolver);
+ param.accept_vis (resolver);
return resolver.resolved_node;
}
void visit (AST::ConstGenericParam ¶m) override
{
- ResolveType::go (param.get_type ().get ());
+ ResolveType::go (param.get_type ());
if (param.has_default_value ())
- ResolveExpr::go (param.get_default_value ().get_expression ().get (),
- prefix, canonical_prefix);
+ ResolveExpr::go (param.get_default_value ().get_expression (), prefix,
+ canonical_prefix);
ok = true;
}
{
// if it has a type lets resolve it
if (param.has_type ())
- ResolveType::go (param.get_type ().get ());
+ ResolveType::go (param.get_type ());
if (param.has_type_param_bounds ())
{
for (auto &bound : param.get_type_param_bounds ())
{
- ResolveTypeBound::go (bound.get ());
+ ResolveTypeBound::go (*bound);
}
}
void visit (AST::TypeBoundWhereClauseItem &item) override
{
- ResolveType::go (item.get_type ().get ());
+ ResolveType::go (item.get_type ());
if (item.has_type_param_bounds ())
{
for (auto &bound : item.get_type_param_bounds ())
{
- ResolveTypeBound::go (bound.get ());
+ ResolveTypeBound::go (*bound);
}
}
}
using Rust::Resolver::ResolverBase::visit;
public:
- static bool go (AST::Type *type, CanonicalPath &result);
+ static bool go (AST::Type &type, CanonicalPath &result);
void visit (AST::TypePath &path) override;
// first gather the top-level namespace names then we drill down so this
// allows for resolving forward declarations since an impl block might have
// a Self type Foo which is defined after the impl block for example.
- for (auto it = crate.items.begin (); it != crate.items.end (); it++)
- ResolveTopLevel::go (it->get (), CanonicalPath::create_empty (),
- crate_prefix);
+ for (auto &item : crate.items)
+ ResolveTopLevel::go (*item, CanonicalPath::create_empty (), crate_prefix);
// FIXME remove this
if (saw_errors ())
}
// next we can drill down into the items and their scopes
- for (auto it = crate.items.begin (); it != crate.items.end (); it++)
- ResolveItem::go (it->get (), CanonicalPath::create_empty (), crate_prefix);
+ for (auto &item : crate.items)
+ ResolveItem::go (*item, CanonicalPath::create_empty (), crate_prefix);
// done
resolver->pop_module_scope ();
stmt->accept_vis (*this);
if (expr.has_tail_expr ())
- expr.get_tail_expr ()->accept_vis (*this);
+ expr.get_tail_expr ().accept_vis (*this);
};
ctx.scoped (Rib::Kind::Normal, expr.get_node_id (), inner_fn);
{
if (p->is_variadic ())
{
- auto param = static_cast<AST::VariadicParam *> (p.get ());
- if (param->has_pattern ())
- param->get_pattern ()->accept_vis (*this);
+ auto ¶m = static_cast<AST::VariadicParam &> (*p);
+ if (param.has_pattern ())
+ param.get_pattern ().accept_vis (*this);
}
else if (p->is_self ())
{
- auto param = static_cast<AST::SelfParam *> (p.get ());
- param->get_type ()->accept_vis (*this);
- param->get_lifetime ().accept_vis (*this);
+ auto ¶m = static_cast<AST::SelfParam &> (*p);
+ param.get_type ().accept_vis (*this);
+ param.get_lifetime ().accept_vis (*this);
}
else
{
- auto param = static_cast<AST::FunctionParam *> (p.get ());
- param->get_pattern ()->accept_vis (*this);
- param->get_type ()->accept_vis (*this);
+ auto ¶m = static_cast<AST::FunctionParam &> (*p);
+ param.get_pattern ().accept_vis (*this);
+ param.get_type ().accept_vis (*this);
}
}
DefaultResolver::visit (AST::ForLoopExpr &expr)
{
ctx.scoped (Rib::Kind::Normal, expr.get_node_id (), [this, &expr] () {
- expr.get_pattern ()->accept_vis (*this);
- expr.get_iterator_expr ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_pattern ().accept_vis (*this);
+ expr.get_iterator_expr ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
});
}
if (param.is_error ())
continue;
- param.get_pattern ()->accept_vis (*this);
+ param.get_pattern ().accept_vis (*this);
if (param.has_type_given ())
- param.get_type ()->accept_vis (*this);
+ param.get_type ().accept_vis (*this);
}
- expr.get_definition_expr ()->accept_vis (*this);
+ expr.get_definition_expr ().accept_vis (*this);
}
void
if (param.is_error ())
continue;
- param.get_pattern ()->accept_vis (*this);
+ param.get_pattern ().accept_vis (*this);
if (param.has_type_given ())
- param.get_type ()->accept_vis (*this);
+ param.get_type ().accept_vis (*this);
}
- expr.get_definition_block ()->accept_vis (*this);
- expr.get_return_type ()->accept_vis (*this);
+ expr.get_definition_block ().accept_vis (*this);
+ expr.get_return_type ().accept_vis (*this);
}
void
void
DefaultResolver::visit (AST::IfExpr &expr)
{
- expr.get_condition_expr ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
+ expr.get_condition_expr ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
}
void
DefaultResolver::visit (AST::IfExprConseqElse &expr)
{
- expr.get_condition_expr ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
- expr.get_else_block ()->accept_vis (*this);
+ expr.get_condition_expr ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
+ expr.get_else_block ().accept_vis (*this);
}
void
if (expr.is_marked_for_strip ())
return;
- expr.get_scrutinee_expr ()->accept_vis (*this);
+ expr.get_scrutinee_expr ().accept_vis (*this);
for (auto &arm : expr.get_match_cases ())
{
- arm.get_expr ()->accept_vis (*this);
+ arm.get_expr ().accept_vis (*this);
for (auto &pat : arm.get_arm ().get_patterns ())
pat->accept_vis (*this);
if (arm.get_arm ().has_match_arm_guard ())
- arm.get_arm ().get_guard_expr ()->accept_vis (*this);
+ arm.get_arm ().get_guard_expr ().accept_vis (*this);
}
}
arg.accept_vis (*this);
for (auto &arg : args.get_binding_args ())
if (!arg.is_error ())
- arg.get_type ()->accept_vis (*this);
+ arg.get_type ().accept_vis (*this);
for (auto &arg : args.get_lifetime_args ())
arg.accept_vis (*this);
}
DefaultResolver::visit (AST::EnumItemTuple &item)
{
for (auto &field : item.get_tuple_fields ())
- field.get_field_type ()->accept_vis (*this);
+ field.get_field_type ().accept_vis (*this);
}
void
DefaultResolver::visit (AST::EnumItemStruct &item)
{
for (auto &field : item.get_struct_fields ())
- field.get_field_type ()->accept_vis (*this);
+ field.get_field_type ().accept_vis (*this);
}
void
DefaultResolver::visit (AST::EnumItemDiscriminant &item)
{
if (item.has_expr ())
- item.get_expr ()->accept_vis (*this);
+ item.get_expr ().accept_vis (*this);
}
void
DefaultResolver::visit (AST::ConstantItem &item)
{
- auto expr_vis = [this, &item] () { item.get_expr ()->accept_vis (*this); };
+ auto expr_vis = [this, &item] () { item.get_expr ().accept_vis (*this); };
// FIXME: Why do we need a Rib here?
ctx.scoped (Rib::Kind::Item, item.get_node_id (), expr_vis);
void
DefaultResolver::visit (AST::StaticItem &item)
{
- auto expr_vis = [this, &item] () { item.get_expr ()->accept_vis (*this); };
+ auto expr_vis = [this, &item] () { item.get_expr ().accept_vis (*this); };
// FIXME: Why do we need a Rib here?
ctx.scoped (Rib::Kind::ConstantItem, item.get_node_id (), expr_vis);
arg.accept_vis (*this);
for (auto &arg : generic_args.get_binding_args ())
- arg.get_type ()->accept_vis (*this);
+ arg.get_type ().accept_vis (*this);
}
void
EarlyNameResolver::resolve_qualified_path_type (AST::QualifiedPathType &path)
{
- path.get_type ()->accept_vis (*this);
+ path.get_type ().accept_vis (*this);
if (path.has_as_clause ())
path.get_as_type_path ().accept_vis (*this);
stmt->accept_vis (*this);
if (expr.has_tail_expr ())
- expr.get_tail_expr ()->accept_vis (*this);
+ expr.get_tail_expr ().accept_vis (*this);
});
}
EarlyNameResolver::visit (AST::ForLoopExpr &expr)
{
scoped (expr.get_node_id (), [&expr, this] () {
- expr.get_pattern ()->accept_vis (*this);
- expr.get_iterator_expr ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_pattern ().accept_vis (*this);
+ expr.get_iterator_expr ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
});
}
void
EarlyNameResolver::visit (AST::IfLetExpr &expr)
{
- expr.get_value_expr ()->accept_vis (*this);
+ expr.get_value_expr ().accept_vis (*this);
scoped (expr.get_node_id (),
- [&expr, this] () { expr.get_if_block ()->accept_vis (*this); });
+ [&expr, this] () { expr.get_if_block ().accept_vis (*this); });
}
void
EarlyNameResolver::visit (AST::MatchExpr &expr)
{
- expr.get_scrutinee_expr ()->accept_vis (*this);
+ expr.get_scrutinee_expr ().accept_vis (*this);
scoped (expr.get_node_id (), [&expr, this] () {
for (auto &arm : expr.get_match_cases ())
{
scoped (arm.get_node_id (), [&arm, this] () {
if (arm.get_arm ().has_match_arm_guard ())
- arm.get_arm ().get_guard_expr ()->accept_vis (*this);
+ arm.get_arm ().get_guard_expr ().accept_vis (*this);
for (auto &pattern : arm.get_arm ().get_patterns ())
pattern->accept_vis (*this);
- arm.get_expr ()->accept_vis (*this);
+ arm.get_expr ().accept_vis (*this);
});
}
});
void
EarlyNameResolver::visit (AST::InherentImpl &impl)
{
- impl.get_type ()->accept_vis (*this);
+ impl.get_type ().accept_vis (*this);
for (auto &generic : impl.get_generic_params ())
generic->accept_vis (*this);
void
EarlyNameResolver::visit (AST::TraitImpl &impl)
{
- impl.get_type ()->accept_vis (*this);
+ impl.get_type ().accept_vis (*this);
for (auto &generic : impl.get_generic_params ())
generic->accept_vis (*this);
void
EarlyNameResolver::visit (AST::TupleStructPattern &pattern)
{
- pattern.get_items ()->accept_vis (*this);
+ pattern.get_items ().accept_vis (*this);
}
void
stmt->accept_vis (*this);
if (expr.has_tail_expr ())
- expr.get_tail_expr ()->accept_vis (*this);
+ expr.get_tail_expr ().accept_vis (*this);
};
ctx.scoped (Rib::Kind::Normal, expr.get_node_id (), sub_vis);
TopLevel::visit (AST::StaticItem &static_item)
{
auto sub_vis
- = [this, &static_item] () { static_item.get_expr ()->accept_vis (*this); };
+ = [this, &static_item] () { static_item.get_expr ().accept_vis (*this); };
ctx.scoped (Rib::Kind::Item, static_item.get_node_id (), sub_vis);
}
TopLevel::visit (AST::ConstantItem &const_item)
{
auto expr_vis
- = [this, &const_item] () { const_item.get_expr ()->accept_vis (*this); };
+ = [this, &const_item] () { const_item.get_expr ().accept_vis (*this); };
ctx.scoped (Rib::Kind::ConstantItem, const_item.get_node_id (), expr_vis);
}
projects / thirdparty / gcc.git / commitdiff
