procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

gccrs: Replace unique_ptr references with references

Browse source 
This kind of double indirection is pointless and prone to error. This
commit change the api of all getters from the AST to use references
directly instead of references to unique pointers.

gcc/rust/ChangeLog:

	* ast/rust-ast-collector.cc (TokenCollector::visit): Remove reference
	to unique pointer and replace it with a direct reference to the wrapped
	data.
	* ast/rust-ast.cc (VariadicParam::as_string): Likewise.
	(BlockExpr::normalize_tail_expr): Likewise.
	* ast/rust-expr.h: Likewise and add pointer getter in order to allow
	pointer reseat.
	* ast/rust-item.h: Likewise and add pointer getter for reseat.
	* ast/rust-path.h: Likewise.
	* ast/rust-pattern.h: Likewise.
	* ast/rust-stmt.h: Likewise.
	* ast/rust-type.h: Likewise.
	* expand/rust-cfg-strip.cc (CfgStrip::maybe_strip_struct_fields):
	Remove references to unique pointers and replace it with direct
	references to the wrapped object.
	(CfgStrip::maybe_strip_tuple_fields): Likewise.
	(CfgStrip::maybe_strip_generic_args): Likewise.
	(CfgStrip::maybe_strip_qualified_path_type): Likewise.
	(CfgStrip::visit): Likewise.
	* expand/rust-expand-visitor.cc (ExpandVisitor::maybe_expand_expr):
	Likewise.
	(ExpandVisitor::maybe_expand_type): Likewise.
	(ExpandVisitor::visit): Likewise.
	* expand/rust-expand-visitor.h: Likewise.
	* hir/rust-ast-lower-base.cc (ASTLoweringBase::lower_binding):
	Likewise.
	(ASTLoweringBase::lower_generic_args): Likewise.
	(ASTLoweringBase::lower_self): Likewise.
	(ASTLoweringBase::lower_type_no_bounds): Likewise.
	(ASTLoweringBase::lower_bound): Likewise.
	(ASTLoweringBase::lower_range_pattern_bound): Likewise.
	* hir/rust-ast-lower-base.h: Likewise.
	* hir/rust-ast-lower-block.h: Likewise.
	* hir/rust-ast-lower-enumitem.h: Likewise.
	* hir/rust-ast-lower-expr.cc (ASTLoweringExpr::translate): Likewise.
	(ASTLoweringExpr::visit): Likewise.
	* hir/rust-ast-lower-expr.h: Likewise.
	* hir/rust-ast-lower-extern.h: Likewise.
	* hir/rust-ast-lower-implitem.cc (ASTLowerImplItem::translate):
	Likewise.
	(ASTLowerImplItem::visit): Likewise.
	(ASTLowerTraitItem::translate): Likewise.
	(ASTLowerTraitItem::visit): Likewise.
	* hir/rust-ast-lower-implitem.h: Likewise.
	* hir/rust-ast-lower-item.cc (ASTLoweringItem::translate): Likewise.
	(ASTLoweringItem::visit): Likewise.
	* hir/rust-ast-lower-item.h: Likewise.
	* hir/rust-ast-lower-pattern.cc (ASTLoweringPattern::translate):
	Likewise.
	(ASTLoweringPattern::visit): Likewise.
	* hir/rust-ast-lower-pattern.h: Likewise.
	* hir/rust-ast-lower-stmt.cc (ASTLoweringStmt::visit): Likewise.
	* hir/rust-ast-lower-struct-field-expr.h: Likewise.
	* hir/rust-ast-lower-type.cc (ASTLowerTypePath::visit): Likewise.
	(ASTLowerQualifiedPathInType::visit): Likewise.
	(ASTLoweringType::translate): Likewise.
	(ASTLoweringType::visit): Likewise.
	(ASTLowerGenericParam::translate): Likewise.
	(ASTLowerGenericParam::visit): Likewise.
	(ASTLoweringTypeBounds::translate): Likewise.
	(ASTLoweringTypeBounds::visit): Likewise.
	(ASTLowerWhereClauseItem::visit): Likewise.
	* hir/rust-ast-lower-type.h: Likewise.
	* hir/rust-ast-lower.cc (ASTLowering::go): Likewise.
	(ASTLoweringBlock::visit): Likewise.
	(ASTLoweringIfBlock::visit): Likewise.
	(ASTLoweringIfLetBlock::visit): Likewise.
	(ASTLowerStructExprField::visit): Likewise.
	(ASTLoweringExprWithBlock::visit): Likewise.
	(ASTLoweringBase::lower_qual_path_type): Likewise.
	(ASTLoweringBase::lower_closure_param): Likewise.
	* resolve/rust-ast-resolve-base.cc (ResolverBase::resolve_visibility):
	Likewise.
	* resolve/rust-ast-resolve-expr.cc (ResolveExpr::go): Likewise.
	(ResolveExpr::visit): Likewise.
	(ResolveExpr::resolve_closure_param): Likewise.
	* resolve/rust-ast-resolve-expr.h: Likewise.
	* resolve/rust-ast-resolve-implitem.h: Likewise.
	* resolve/rust-ast-resolve-item.cc (ResolveTraitItems::visit):
	Likewise.
	(ResolveItem::go): Likewise.
	(ResolveItem::visit): Likewise.
	(ResolveItem::resolve_impl_item): Likewise.
	(ResolveItem::resolve_extern_item): Likewise.
	(ResolveImplItems::go): Likewise.
	(ResolveExternItem::go): Likewise.
	(ResolveExternItem::visit): Likewise.
	* resolve/rust-ast-resolve-item.h: Likewise.
	* resolve/rust-ast-resolve-path.cc (ResolvePath::go): Likewise.
	(ResolvePath::resolve_path): Likewise.
	* resolve/rust-ast-resolve-path.h: Likewise.
	* resolve/rust-ast-resolve-pattern.cc (PatternDeclaration::go):
	Likewise.
	(PatternDeclaration::visit): Likewise.
	(resolve_range_pattern_bound): Likewise.
	* resolve/rust-ast-resolve-pattern.h: Likewise.
	* resolve/rust-ast-resolve-stmt.cc (ResolveStmt::visit): Likewise.
	* resolve/rust-ast-resolve-stmt.h: Likewise.
	* resolve/rust-ast-resolve-struct-expr-field.cc (ResolveStructExprField::go):
	Likewise.
	(ResolveStructExprField::visit): Likewise.
	* resolve/rust-ast-resolve-struct-expr-field.h: Likewise.
	* resolve/rust-ast-resolve-toplevel.h: Likewise.
	* resolve/rust-ast-resolve-type.cc (ResolveType::visit): Likewise.
	(ResolveRelativeTypePath::go): Likewise.
	(ResolveRelativeQualTypePath::resolve_qual_seg): Likewise.
	(ResolveTypeToCanonicalPath::go): Likewise.
	(ResolveTypeToCanonicalPath::visit): Likewise.
	(ResolveGenericArgs::resolve_disambiguated_generic): Likewise.
	(ResolveGenericArgs::go): Likewise.
	* resolve/rust-ast-resolve-type.h: Likewise.
	* resolve/rust-ast-resolve.cc (NameResolution::go): Likewise.
	* resolve/rust-default-resolver.cc (DefaultResolver::visit): Likewise.
	* resolve/rust-early-name-resolver.cc (EarlyNameResolver::resolve_qualified_path_type):
	Likewise.
	(EarlyNameResolver::visit): Likewise.
	* resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit):
	Likewise.
	* checks/errors/rust-ast-validation.cc: Likewise.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
This commit is contained in:
Pierre-Emmanuel Patry 2024-02-22 18:55:53 +01:00 • committed by Arthur Cohen
parent 68ec9f41ae
commit e01c9f40c1
51 changed files with 1418 additions and 1207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
gcc/rust/ast/rust-ast-collector.cc
View file

@ -2546,8 +2546,7 @@ TokenCollector::visit (LetStmt &stmt)
{
push (Rust::Token::make (LET, stmt.get_locus ()));
auto &pattern = stmt.get_pattern ();
if (pattern)
visit (pattern);
visit (pattern);
if (stmt.has_type ())
{

4
gcc/rust/ast/rust-ast.cc
View file

@ -2291,7 +2291,7 @@ std::string
VariadicParam::as_string () const
{
if (has_pattern ())
return get_pattern ()->as_string () + " : ...";
return get_pattern ().as_string () + " : ...";
else
return "...";
}
@ -4258,7 +4258,7 @@ BlockExpr::normalize_tail_expr ()
if (!stmt.is_semicolon_followed ())
{
expr = std::move (stmt.get_expr ());
expr = std::move (stmt.take_expr ());
statements.pop_back ();
}
}

302
gcc/rust/ast/rust-expr.h
View file

@ -387,10 +387,10 @@ public:
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; }
@ -421,10 +421,10 @@ public:
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:
@ -452,10 +452,10 @@ public:
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:
@ -495,10 +495,10 @@ public:
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:
@ -561,14 +561,26 @@ public:
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;
@ -637,14 +649,26 @@ public:
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;
@ -713,14 +737,26 @@ public:
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;
@ -777,17 +813,17 @@ public:
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:
@ -843,19 +879,31 @@ public:
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 */
@ -917,14 +965,26 @@ public:
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;
@ -1012,7 +1072,13 @@ public:
}
// 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;
@ -1147,17 +1213,17 @@ public:
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:
@ -1331,17 +1397,17 @@ public:
}
// 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; }
@ -1521,10 +1587,10 @@ public:
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; }
@ -1664,10 +1730,10 @@ public:
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;
}
};
@ -1763,10 +1829,10 @@ public:
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;
}
};
@ -2021,10 +2087,10 @@ public:
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; }
@ -2121,10 +2187,10 @@ public:
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; }
@ -2207,10 +2273,10 @@ public:
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; }
@ -2304,13 +2370,19 @@ public:
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;
@ -2411,10 +2483,10 @@ public:
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:
@ -2532,7 +2604,13 @@ public:
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;
@ -2651,14 +2729,20 @@ public:
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;
@ -2794,10 +2878,10 @@ public:
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; }
@ -2906,17 +2990,17 @@ public:
}
// 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:
@ -2974,10 +3058,10 @@ public:
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:
@ -3036,10 +3120,10 @@ public:
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:
@ -3142,17 +3226,17 @@ public:
}
// 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:
@ -3211,10 +3295,10 @@ public:
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:
@ -3290,10 +3374,10 @@ public:
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; }
@ -3372,10 +3456,10 @@ public:
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; }
@ -3461,10 +3545,10 @@ public:
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; }
@ -3544,10 +3628,10 @@ public:
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:
@ -3617,10 +3701,10 @@ public:
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.
@ -3689,17 +3773,17 @@ public:
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:
@ -3786,17 +3870,23 @@ public:
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.
@ -3874,10 +3964,10 @@ public:
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:
@ -3975,17 +4065,23 @@ public:
}
// 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.
@ -4067,10 +4163,10 @@ public:
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:
@ -4159,7 +4255,13 @@ public:
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;
@ -4220,7 +4322,13 @@ public:
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;
@ -4315,10 +4423,10 @@ public:
}
// 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; }

160
gcc/rust/ast/rust-item.h
View file

@ -141,7 +141,13 @@ public:
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;
@ -288,7 +294,13 @@ public:
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;
@ -516,7 +528,13 @@ public:
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;
@ -611,16 +629,16 @@ public:
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; }
@ -694,16 +712,22 @@ public:
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;
@ -1409,7 +1433,13 @@ public:
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;
@ -1552,10 +1582,10 @@ public:
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; }
@ -1750,7 +1780,13 @@ public:
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;
@ -1901,7 +1937,13 @@ public:
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;
@ -2098,7 +2140,13 @@ public:
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;
@ -2414,14 +2462,26 @@ public:
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;
@ -2521,14 +2581,26 @@ public:
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;
@ -2629,14 +2701,26 @@ public:
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;
@ -2958,7 +3042,13 @@ public:
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;
@ -3409,7 +3499,13 @@ public:
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;
@ -3542,7 +3638,13 @@ public:
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;
@ -3700,7 +3802,13 @@ public:
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;

50
gcc/rust/ast/rust-path.h
View file

@ -120,7 +120,13 @@ public:
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;
@ -216,10 +222,10 @@ public:
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;
@ -228,14 +234,28 @@ public:
}
}
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);
@ -352,11 +372,11 @@ public:
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 ()
@ -957,7 +977,13 @@ public:
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;
@ -1176,7 +1202,13 @@ public:
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;

36
gcc/rust/ast/rust-pattern.h
View file

@ -138,10 +138,10 @@ public:
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; }
@ -428,16 +428,16 @@ public:
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; }
@ -500,10 +500,10 @@ public:
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; }
@ -663,10 +663,10 @@ public:
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; }
@ -743,10 +743,10 @@ public:
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; }
@ -1183,10 +1183,10 @@ public:
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; }
@ -1428,10 +1428,10 @@ public:
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; }
@ -1490,10 +1490,10 @@ public:
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; }

35
gcc/rust/ast/rust-stmt.h
View file

@ -22,6 +22,7 @@
#include "rust-ast.h"
#include "rust-path.h"
#include "rust-expr.h"
#include <memory>
namespace Rust {
namespace AST {
@ -155,19 +156,31 @@ public:
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;
}
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;
@ -249,12 +262,24 @@ public:
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:

34
gcc/rust/ast/rust-type.h
View file

@ -513,10 +513,10 @@ public:
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:
@ -580,17 +580,17 @@ public:
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
@ -641,17 +641,17 @@ public:
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:
@ -701,10 +701,10 @@ public:
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:
@ -824,7 +824,13 @@ public:
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;
@ -935,10 +941,10 @@ public:
}
// 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; }

4
gcc/rust/checks/errors/rust-ast-validation.cc
View file

@ -125,8 +125,8 @@ ASTValidation::visit (AST::Function &function)
// 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 &param = static_cast<AST::FunctionParam &> (**it);
auto kind = param.get_pattern ().get_pattern_kind ();
if (kind != AST::Pattern::Kind::Identifier
&& kind != AST::Pattern::Kind::Wildcard)

456
gcc/rust/expand/rust-cfg-strip.cc
View file

File diff suppressed because it is too large Load diff

92
gcc/rust/expand/rust-expand-visitor.cc
View file

@ -360,7 +360,7 @@ ExpandVisitor::expand_struct_fields (std::vector<AST::StructField> &fields)
{
for (auto &field : fields)
{
maybe_expand_type (field.get_field_type ());
maybe_expand_type (field.get_field_type_ptr ());
}
}
@ -368,7 +368,7 @@ void
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
@ -388,10 +388,10 @@ ExpandVisitor::expand_generic_args (AST::GenericArgs &args)
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;
@ -407,13 +407,13 @@ ExpandVisitor::expand_generic_args (AST::GenericArgs &args)
// 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 ())
@ -426,7 +426,7 @@ ExpandVisitor::expand_closure_params (std::vector<AST::ClosureParam> &params)
for (auto &param : params)
{
if (param.has_type_given ())
maybe_expand_type (param.get_type ());
maybe_expand_type (param.get_type_ptr ());
}
}
@ -491,7 +491,7 @@ ExpandVisitor::visit (AST::TypePathSegmentFunction &segment)
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
@ -545,42 +545,42 @@ ExpandVisitor::visit (AST::ErrorPropagationExpr &expr)
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
@ -620,7 +620,7 @@ ExpandVisitor::visit (AST::BlockExpr &expr)
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
@ -628,7 +628,7 @@ ExpandVisitor::visit (AST::ClosureExprInnerTyped &expr)
{
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 ());
}
@ -640,7 +640,7 @@ ExpandVisitor::visit (AST::ContinueExpr &expr)
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 ());
}
@ -648,7 +648,7 @@ ExpandVisitor::visit (AST::IfExpr &expr)
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 ());
@ -657,7 +657,7 @@ ExpandVisitor::visit (AST::IfExprConseqElse &expr)
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 ());
}
@ -665,7 +665,7 @@ ExpandVisitor::visit (AST::IfLetExpr &expr)
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 ());
@ -684,9 +684,9 @@ ExpandVisitor::visit (AST::MatchExpr &expr)
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 ());
}
}
@ -697,7 +697,7 @@ ExpandVisitor::visit (AST::TypeParam &param)
visit (bound);
if (param.has_type ())
maybe_expand_type (param.get_type ());
maybe_expand_type (param.get_type_ptr ());
}
void
@ -707,7 +707,7 @@ ExpandVisitor::visit (AST::LifetimeWhereClauseItem &)
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);
@ -745,7 +745,7 @@ ExpandVisitor::visit (AST::Function &function)
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 ());
@ -797,7 +797,7 @@ ExpandVisitor::visit (AST::EnumItemStruct &item)
void
ExpandVisitor::visit (AST::EnumItemDiscriminant &item)
{
maybe_expand_expr (item.get_expr ());
maybe_expand_expr (item.get_expr_ptr ());
}
void
@ -812,27 +812,27 @@ ExpandVisitor::visit (AST::Union &union_item)
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
@ -870,7 +870,7 @@ ExpandVisitor::visit (AST::InherentImpl &impl)
// 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 ();
@ -895,7 +895,7 @@ ExpandVisitor::visit (AST::TraitImpl &impl)
// 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 ();
@ -919,7 +919,7 @@ ExpandVisitor::visit (AST::ExternalTypeItem &item)
void
ExpandVisitor::visit (AST::ExternalStaticItem &static_item)
{
maybe_expand_type (static_item.get_type ());
maybe_expand_type (static_item.get_type_ptr ());
}
void
@ -978,16 +978,16 @@ ExpandVisitor::visit (AST::LetStmt &stmt)
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
@ -995,7 +995,7 @@ ExpandVisitor::visit (AST::BareFunctionType &type)
{
for (auto &param : type.get_function_params ())
{
maybe_expand_type (param.get_type ());
maybe_expand_type (param.get_type_ptr ());
}
if (type.has_return_type ())
@ -1005,7 +1005,7 @@ ExpandVisitor::visit (AST::BareFunctionType &type)
void
ExpandVisitor::visit (AST::FunctionParam &param)
{
maybe_expand_type (param.get_type ());
maybe_expand_type (param.get_type_ptr ());
}
void
@ -1014,7 +1014,7 @@ ExpandVisitor::visit (AST::SelfParam &param)
/* 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>

10
gcc/rust/expand/rust-expand-visitor.h
View file

@ -47,10 +47,16 @@ public:
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);
/**

39
gcc/rust/hir/rust-ast-lower-base.cc
View file

@ -568,7 +568,7 @@ ASTLoweringBase::lower_generic_params (
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));
}
@ -593,8 +593,7 @@ ASTLoweringBase::lower_path_expr_seg (AST::PathExprSegment &s)
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 ());
@ -625,13 +624,12 @@ ASTLoweringBase::lower_generic_args (AST::GenericArgs &args)
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 ()));
@ -660,7 +658,7 @@ ASTLoweringBase::lower_self (AST::Param &param)
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 ());
}
@ -676,13 +674,13 @@ ASTLoweringBase::lower_self (AST::Param &param)
}
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);
}
@ -828,7 +826,7 @@ ASTLoweringBase::lower_tuple_pattern_multiple (
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));
}
@ -845,13 +843,13 @@ ASTLoweringBase::lower_tuple_pattern_ranged (
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));
}
@ -861,14 +859,14 @@ ASTLoweringBase::lower_tuple_pattern_ranged (
}
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 ());
@ -878,23 +876,20 @@ ASTLoweringBase::lower_range_pattern_bound (AST::RangePatternBound *bound)
}
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));

6
gcc/rust/hir/rust-ast-lower-base.h
View file

@ -280,9 +280,9 @@ protected:
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);
@ -310,7 +310,7 @@ protected:
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);

42
gcc/rust/hir/rust-ast-lower-block.h
View file

@ -30,11 +30,11 @@ class ASTLoweringBlock : public ASTLoweringBase
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);
@ -44,16 +44,15 @@ public:
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);
@ -61,7 +60,7 @@ public:
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);
@ -84,10 +83,10 @@ class ASTLoweringIfBlock : public ASTLoweringBase
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);
@ -116,10 +115,10 @@ class ASTLoweringIfLetBlock : public ASTLoweringBase
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);
@ -144,11 +143,11 @@ class ASTLoweringExprWithBlock : public ASTLoweringBase
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);
@ -162,39 +161,38 @@ public:
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 ());

8
gcc/rust/hir/rust-ast-lower-enumitem.h
View file

@ -83,8 +83,7 @@ public:
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 (
@ -121,8 +120,7 @@ public:
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 (
@ -160,7 +158,7 @@ public:
"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),

130
gcc/rust/hir/rust-ast-lower-expr.cc
View file

@ -35,20 +35,20 @@ ASTLoweringExpr::ASTLoweringExpr ()
{}
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;
@ -60,7 +60,7 @@ void
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 (),
@ -79,7 +79,7 @@ ASTLoweringExpr::visit (AST::TupleExpr &expr)
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));
}
@ -97,49 +97,49 @@ ASTLoweringExpr::visit (AST::TupleExpr &expr)
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
@ -148,7 +148,7 @@ ASTLoweringExpr::visit (AST::ReturnExpr &expr)
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 ();
@ -163,14 +163,13 @@ ASTLoweringExpr::visit (AST::ReturnExpr &expr)
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 &param : in_params)
{
auto trans = ASTLoweringExpr::translate (param.get ());
auto trans = ASTLoweringExpr::translate (*param);
params.push_back (std::unique_ptr<HIR::Expr> (trans));
}
@ -190,14 +189,13 @@ ASTLoweringExpr::visit (AST::MethodCallExpr &expr)
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 &param : in_params)
{
auto trans = ASTLoweringExpr::translate (param.get ());
auto trans = ASTLoweringExpr::translate (*param);
params.push_back (std::unique_ptr<HIR::Expr> (trans));
}
@ -215,8 +213,8 @@ ASTLoweringExpr::visit (AST::MethodCallExpr &expr)
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 (),
@ -266,10 +264,9 @@ ASTLoweringExpr::visit (AST::ArrayExpr &expr)
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 (),
@ -288,7 +285,7 @@ ASTLoweringExpr::visit (AST::ArrayElemsValues &elems)
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));
}
@ -305,10 +302,8 @@ ASTLoweringExpr::visit (AST::ArrayElemsValues &elems)
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 (),
@ -337,9 +332,9 @@ ASTLoweringExpr::visit (AST::LiteralExpr &expr)
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 ();
@ -355,9 +350,9 @@ ASTLoweringExpr::visit (AST::ArithmeticOrLogicalExpr &expr)
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 ();
@ -374,9 +369,9 @@ ASTLoweringExpr::visit (AST::ComparisonExpr &expr)
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 ();
@ -394,7 +389,7 @@ void
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 (),
@ -411,9 +406,9 @@ void
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 (),
@ -467,9 +462,8 @@ ASTLoweringExpr::visit (AST::CompoundAssignmentExpr &expr)
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 (),
@ -485,7 +479,7 @@ void
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;
@ -505,7 +499,7 @@ ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr)
{
// 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;
@ -513,7 +507,7 @@ ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr)
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));
}
@ -522,7 +516,7 @@ ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr)
for (auto &field : in_fields)
{
HIR::StructExprField *translated
= ASTLowerStructExprField::translate (field.get ());
= ASTLowerStructExprField::translate (*field);
fields.push_back (std::unique_ptr<HIR::StructExprField> (translated));
}
@ -542,7 +536,7 @@ void
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 (),
@ -558,8 +552,7 @@ ASTLoweringExpr::visit (AST::GroupedExpr &expr)
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 (),
@ -574,19 +567,19 @@ ASTLoweringExpr::visit (AST::FieldAccessExpr &expr)
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
@ -596,7 +589,7 @@ ASTLoweringExpr::visit (AST::BreakExpr &expr)
= 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 ();
@ -629,7 +622,7 @@ void
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 (),
@ -664,7 +657,7 @@ void
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 (),
@ -681,7 +674,7 @@ void
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 (),
@ -695,7 +688,7 @@ ASTLoweringExpr::visit (AST::ErrorPropagationExpr &expr)
void
ASTLoweringExpr::visit (AST::MatchExpr &expr)
{
translated = ASTLoweringExprWithBlock::translate (&expr, &terminated);
translated = ASTLoweringExprWithBlock::translate (expr, &terminated);
}
void
@ -706,9 +699,8 @@ ASTLoweringExpr::visit (AST::RangeFromToExpr &expr)
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,
@ -725,8 +717,7 @@ ASTLoweringExpr::visit (AST::RangeFromExpr &expr)
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),
@ -741,7 +732,7 @@ ASTLoweringExpr::visit (AST::RangeToExpr &expr)
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),
@ -767,9 +758,8 @@ ASTLoweringExpr::visit (AST::RangeFromToInclExpr &expr)
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,
@ -782,7 +772,7 @@ void
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 &param : expr.get_params ())
@ -809,7 +799,7 @@ ASTLoweringExpr::visit (AST::ClosureExprInnerTyped &expr)
{
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 &param : expr.get_params ())

10
gcc/rust/hir/rust-ast-lower-expr.h
View file

@ -30,10 +30,10 @@ class ASTLowerPathInExpression : public ASTLoweringBase
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;
}
@ -52,10 +52,10 @@ class ASTLowerQualPathInExpression : public ASTLoweringBase
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;
}
@ -73,7 +73,7 @@ class ASTLoweringExpr : public ASTLoweringBase
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;

22
gcc/rust/hir/rust-ast-lower-extern.h
View file

@ -51,8 +51,7 @@ public:
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 (),
@ -77,7 +76,7 @@ public:
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 ();
@ -88,25 +87,24 @@ public:
std::vector<HIR::NamedFunctionParam> function_params;
for (auto it = begin; it != end; it++)
{
auto param = static_cast<AST::FunctionParam *> (it->get ());
auto &param = 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 &param_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));

47
gcc/rust/hir/rust-ast-lower-implitem.cc
View file

@ -28,10 +28,10 @@ namespace Rust {
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)
{
@ -63,7 +63,7 @@ ASTLowerImplItem::visit (AST::TypeAlias &alias)
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 (),
@ -86,9 +86,8 @@ ASTLowerImplItem::visit (AST::ConstantItem &constant)
{
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 (),
@ -138,7 +137,7 @@ ASTLowerImplItem::visit (AST::Function &function)
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;
@ -146,28 +145,28 @@ ASTLowerImplItem::visit (AST::Function &function)
{
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 ();
@ -207,10 +206,10 @@ ASTLowerImplItem::visit (AST::Function &function)
}
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)
{
@ -241,7 +240,7 @@ ASTLowerTraitItem::visit (AST::Function &func)
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
@ -256,21 +255,21 @@ ASTLowerTraitItem::visit (AST::Function &func)
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);
}
@ -284,7 +283,7 @@ ASTLowerTraitItem::visit (AST::Function &func)
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;
@ -316,9 +315,9 @@ ASTLowerTraitItem::visit (AST::Function &func)
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 ();

4
gcc/rust/hir/rust-ast-lower-implitem.h
View file

@ -29,7 +29,7 @@ class ASTLowerImplItem : public ASTLoweringBase
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;
@ -47,7 +47,7 @@ class ASTLowerTraitItem : public ASTLoweringBase
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;

68
gcc/rust/hir/rust-ast-lower-item.cc
View file

@ -32,10 +32,10 @@ namespace Rust {
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)
{
@ -44,7 +44,7 @@ ASTLoweringItem::translate (AST::Item *item)
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);
@ -68,7 +68,7 @@ ASTLoweringItem::visit (AST::Module &module)
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)
@ -105,7 +105,7 @@ ASTLoweringItem::visit (AST::TypeAlias &alias)
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 (),
@ -143,13 +143,12 @@ ASTLoweringItem::visit (AST::TupleStruct &struct_decl)
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 (),
@ -202,12 +201,11 @@ ASTLoweringItem::visit (AST::StructStruct &struct_decl)
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 (),
@ -309,13 +307,12 @@ ASTLoweringItem::visit (AST::Union &union_decl)
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 (),
@ -351,8 +348,8 @@ ASTLoweringItem::visit (AST::StaticItem &var)
{
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 (),
@ -372,9 +369,8 @@ ASTLoweringItem::visit (AST::ConstantItem &constant)
{
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 (),
@ -418,7 +414,7 @@ ASTLoweringItem::visit (AST::Function &function)
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;
@ -426,28 +422,28 @@ ASTLoweringItem::visit (AST::Function &function)
{
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 ();
@ -482,8 +478,7 @@ ASTLoweringItem::visit (AST::InherentImpl &impl_block)
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));
}
@ -524,8 +519,7 @@ ASTLoweringItem::visit (AST::InherentImpl &impl_block)
}
}
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 (),
@ -540,7 +534,7 @@ ASTLoweringItem::visit (AST::InherentImpl &impl_block)
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 ());
@ -586,7 +580,7 @@ ASTLoweringItem::visit (AST::Trait &trait)
{
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));
}
@ -599,7 +593,7 @@ ASTLoweringItem::visit (AST::Trait &trait)
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 ());
}
@ -634,8 +628,7 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block)
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));
@ -675,8 +668,7 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block)
}
}
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 ());
@ -693,7 +685,7 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block)
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 ());

2
gcc/rust/hir/rust-ast-lower-item.h
View file

@ -29,7 +29,7 @@ class ASTLoweringItem : public ASTLoweringBase
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;

54
gcc/rust/hir/rust-ast-lower-pattern.cc
View file

@ -25,17 +25,17 @@ namespace HIR {
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;
}
@ -60,18 +60,18 @@ ASTLoweringPattern::visit (AST::IdentifierPattern &pattern)
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
@ -81,13 +81,12 @@ ASTLoweringPattern::visit (AST::TupleStructPattern &pattern)
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));
}
@ -109,7 +108,7 @@ void
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 ());
@ -121,7 +120,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern)
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 ();
@ -130,8 +129,8 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern)
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 (),
@ -151,8 +150,8 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern)
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 (),
@ -214,20 +213,19 @@ void
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;
@ -258,10 +256,8 @@ ASTLoweringPattern::visit (AST::LiteralPattern &pattern)
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 (),
@ -277,7 +273,7 @@ void
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
@ -289,7 +285,7 @@ ASTLoweringPattern::visit (AST::ReferencePattern &pattern)
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),
@ -315,7 +311,7 @@ ASTLoweringPattern::visit (AST::SlicePattern &pattern)
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));
}
@ -340,8 +336,8 @@ ASTLoweringPattern::visit (AST::AltPattern &pattern)
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

2
gcc/rust/hir/rust-ast-lower-pattern.h
View file

@ -29,7 +29,7 @@ class ASTLoweringPattern : public ASTLoweringBase
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;

30
gcc/rust/hir/rust-ast-lower-stmt.cc
View file

@ -46,8 +46,7 @@ ASTLoweringStmt::translate (AST::Stmt *stmt, bool *terminated)
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 (),
@ -61,21 +60,20 @@ ASTLoweringStmt::visit (AST::ExprStmt &stmt)
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 (),
@ -91,25 +89,25 @@ ASTLoweringStmt::visit (AST::LetStmt &stmt)
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
@ -126,7 +124,7 @@ ASTLoweringStmt::visit (AST::EmptyStmt &empty)
void
ASTLoweringStmt::visit (AST::Function &function)
{
translated = ASTLoweringItem::translate (&function);
translated = ASTLoweringItem::translate (function);
}
void
@ -144,19 +142,19 @@ ASTLoweringStmt::visit (AST::MacroRulesDefinition &def)
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

6
gcc/rust/hir/rust-ast-lower-struct-field-expr.h
View file

@ -30,15 +30,15 @@ class ASTLowerStructExprField : public ASTLoweringBase
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;
}

67
gcc/rust/hir/rust-ast-lower-type.cc
View file

@ -44,14 +44,13 @@ ASTLowerTypePath::visit (AST::TypePathSegmentFunction &segment)
std::vector<std::unique_ptr<HIR::Type>> inputs;
for (auto &param : 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> (
@ -143,8 +142,8 @@ ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path)
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 ());
@ -180,10 +179,10 @@ ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &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);
@ -201,7 +200,7 @@ ASTLoweringType::visit (AST::BareFunctionType &fntype)
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));
}
@ -229,7 +228,7 @@ ASTLoweringType::visit (AST::BareFunctionType &fntype)
}
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,
@ -241,9 +240,8 @@ ASTLoweringType::visit (AST::BareFunctionType &fntype)
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 ();
@ -264,7 +262,7 @@ ASTLoweringType::visit (AST::TupleType &tuple)
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));
}
@ -293,10 +291,9 @@ void
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 (),
@ -316,7 +313,7 @@ ASTLoweringType::visit (AST::ReferenceType &type)
= 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 ();
@ -335,7 +332,7 @@ void
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 ();
@ -357,7 +354,7 @@ void
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 ();
@ -397,7 +394,7 @@ ASTLoweringType::visit (AST::TraitObjectTypeOneBound &type)
{
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 ();
@ -417,7 +414,7 @@ ASTLoweringType::visit (AST::TraitObjectType &type)
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));
}
@ -432,14 +429,14 @@ ASTLoweringType::visit (AST::TraitObjectType &type)
}
HIR::GenericParam *
ASTLowerGenericParam::translate (AST::GenericParam *param)
ASTLowerGenericParam::translate (AST::GenericParam &param)
{
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;
@ -469,12 +466,12 @@ ASTLowerGenericParam::visit (AST::ConstGenericParam &param)
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),
@ -491,14 +488,14 @@ ASTLowerGenericParam::visit (AST::TypeParam &param)
{
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 ();
@ -513,10 +510,10 @@ ASTLowerGenericParam::visit (AST::TypeParam &param)
}
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 (
@ -532,7 +529,7 @@ ASTLoweringTypeBounds::visit (AST::TraitBound &bound)
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));
}
@ -604,18 +601,18 @@ ASTLowerWhereClauseItem::visit (AST::TypeBoundWhereClauseItem &item)
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));
}

6
gcc/rust/hir/rust-ast-lower-type.h
View file

@ -63,7 +63,7 @@ class ASTLoweringType : public ASTLoweringBase
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;
@ -97,7 +97,7 @@ class ASTLowerGenericParam : public ASTLoweringBase
using Rust::HIR::ASTLoweringBase::visit;
public:
static HIR::GenericParam *translate (AST::GenericParam *param);
static HIR::GenericParam *translate (AST::GenericParam &param);
void visit (AST::LifetimeParam &param) override;
void visit (AST::ConstGenericParam &param) override;
@ -114,7 +114,7 @@ class ASTLoweringTypeBounds : public ASTLoweringBase
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;

70
gcc/rust/hir/rust-ast-lower.cc
View file

@ -74,9 +74,9 @@ ASTLowering::go ()
{
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));
}
@ -123,7 +123,7 @@ ASTLoweringBlock::visit (AST::BlockExpr &expr)
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");
}
@ -132,7 +132,7 @@ ASTLoweringBlock::visit (AST::BlockExpr &expr)
{
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;
}
@ -155,12 +155,10 @@ void
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 (),
@ -176,16 +174,15 @@ void
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;
@ -207,16 +204,14 @@ ASTLoweringIfLetBlock::visit (AST::IfLetExpr &expr)
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 (),
@ -235,19 +230,17 @@ ASTLoweringIfLetBlock::visit (AST::IfLetExprConseqElse &expr)
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);
@ -268,7 +261,7 @@ ASTLoweringIfLetBlock::visit (AST::IfLetExprConseqElse &expr)
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 (),
@ -283,7 +276,7 @@ ASTLowerStructExprField::visit (AST::StructExprFieldIdentifierValue &field)
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 (),
@ -315,12 +308,11 @@ void
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 (),
@ -362,25 +354,25 @@ void
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));
}
@ -437,8 +429,7 @@ ASTLowerPathInExpression::visit (AST::PathInExpression &expr)
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 ())
@ -486,12 +477,11 @@ ClosureParam
ASTLoweringBase::lower_closure_param (AST::ClosureParam &param)
{
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 (),

2
gcc/rust/resolve/rust-ast-resolve-base.cc
View file

@ -30,7 +30,7 @@ ResolverBase::resolve_visibility (const AST::Visibility &vis)
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

160
gcc/rust/resolve/rust-ast-resolve-expr.cc
View file

@ -28,17 +28,17 @@ namespace Rust {
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
@ -48,41 +48,40 @@ ResolveExpr::visit (AST::TupleExpr &expr)
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 &param : 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 ())
{
@ -92,14 +91,14 @@ ResolveExpr::visit (AST::MethodCallExpr &expr)
auto const &in_params = expr.get_params ();
for (auto &param : 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.
@ -178,63 +177,63 @@ ResolveExpr::visit (AST::IdentifierExpr &expr)
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);
@ -251,10 +250,10 @@ ResolveExpr::visit (AST::IfLetExpr &expr)
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 ();
@ -264,7 +263,7 @@ ResolveExpr::visit (AST::IfLetExpr &expr)
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);
@ -281,11 +280,11 @@ ResolveExpr::visit (AST::IfLetExprConseqElse &expr)
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 ();
@ -328,19 +327,19 @@ ResolveExpr::visit (AST::BlockExpr &expr)
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 ();
@ -350,14 +349,14 @@ ResolveExpr::visit (AST::BlockExpr &expr)
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
@ -369,55 +368,53 @@ ResolveExpr::visit (AST::ArrayExpr &expr)
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
@ -444,7 +441,7 @@ ResolveExpr::visit (AST::LoopExpr &expr)
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
@ -477,7 +474,7 @@ ResolveExpr::visit (AST::BreakExpr &expr)
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
@ -491,7 +488,7 @@ ResolveExpr::visit (AST::BreakExpr &expr)
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);
}
}
@ -520,8 +517,8 @@ ResolveExpr::visit (AST::WhileLoopExpr &expr)
});
}
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
@ -559,9 +556,9 @@ ResolveExpr::visit (AST::ForLoopExpr &expr)
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 ();
@ -600,20 +597,19 @@ ResolveExpr::visit (AST::ContinueExpr &expr)
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
@ -628,8 +624,7 @@ ResolveExpr::visit (AST::MatchExpr &expr)
// 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.
@ -639,11 +634,11 @@ ResolveExpr::visit (AST::MatchExpr &expr)
// 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 ();
@ -655,20 +650,20 @@ ResolveExpr::visit (AST::MatchExpr &expr)
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
@ -680,8 +675,8 @@ ResolveExpr::visit (AST::RangeFullExpr &)
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
@ -705,8 +700,7 @@ ResolveExpr::visit (AST::ClosureExprInner &expr)
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 ();
@ -734,12 +728,11 @@ ResolveExpr::visit (AST::ClosureExprInnerTyped &expr)
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 ();
@ -752,11 +745,10 @@ void
ResolveExpr::resolve_closure_param (AST::ClosureParam &param,
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,

2
gcc/rust/resolve/rust-ast-resolve-expr.h
View file

@ -30,7 +30,7 @@ class ResolveExpr : public ResolverBase
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);

10
gcc/rust/resolve/rust-ast-resolve-implitem.h
View file

@ -31,13 +31,13 @@ class ResolveToplevelImplItem : public ResolverBase
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
@ -183,10 +183,10 @@ class ResolveToplevelExternItem : public ResolverBase
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

203
gcc/rust/resolve/rust-ast-resolve-item.cc
View file

@ -65,10 +65,10 @@ ResolveTraitItems::visit (AST::Function &function)
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
@ -80,45 +80,45 @@ ResolveTraitItems::visit (AST::Function &function)
{
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 &param = 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 &param = static_cast<AST::FunctionParam &> (*p);
ResolveType::go (param.get_type ());
PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param,
bindings);
}
}
@ -127,7 +127,7 @@ ResolveTraitItems::visit (AST::Function &function)
// 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 ();
@ -143,7 +143,7 @@ ResolveTraitItems::visit (AST::TraitItemType &type)
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
@ -155,10 +155,10 @@ ResolveTraitItems::visit (AST::TraitItemConst &constant)
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,
@ -167,11 +167,11 @@ 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
@ -189,12 +189,12 @@ ResolveItem::visit (AST::TypeAlias &alias)
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 ();
}
@ -221,11 +221,11 @@ ResolveItem::visit (AST::Module &module)
// 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 ();
@ -251,19 +251,19 @@ ResolveItem::visit (AST::TupleStruct &struct_decl)
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 ();
@ -285,14 +285,14 @@ ResolveItem::visit (AST::Enum &enum_decl)
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 ();
}
@ -322,10 +322,10 @@ ResolveItem::visit (AST::EnumItemTuple &item)
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 ());
}
}
@ -340,10 +340,10 @@ ResolveItem::visit (AST::EnumItemStruct &item)
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 ());
}
}
@ -375,19 +375,19 @@ ResolveItem::visit (AST::StructStruct &struct_decl)
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 ();
@ -410,17 +410,17 @@ ResolveItem::visit (AST::Union &union_decl)
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 ();
@ -435,8 +435,8 @@ ResolveItem::visit (AST::StaticItem &var)
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
@ -450,8 +450,8 @@ ResolveItem::visit (AST::ConstantItem &constant)
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
@ -477,14 +477,14 @@ ResolveItem::visit (AST::Function &function)
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 ())
{
@ -497,13 +497,13 @@ ResolveItem::visit (AST::Function &function)
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
{
@ -514,7 +514,7 @@ ResolveItem::visit (AST::Function &function)
AST::TypePath self_type_path (std::move (segments),
self_param.get_locus ());
ResolveType::go (&self_type_path);
ResolveType::go (self_type_path);
}
}
@ -527,28 +527,28 @@ ResolveItem::visit (AST::Function &function)
{
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 &param = 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 &param = 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 &param = 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 ();
@ -568,7 +568,7 @@ ResolveItem::visit (AST::InherentImpl &impl_block)
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 ())
@ -577,12 +577,11 @@ ResolveItem::visit (AST::InherentImpl &impl_block)
// 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 ());
@ -609,22 +608,22 @@ ResolveItem::visit (AST::InherentImpl &impl_block)
// 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 ();
@ -646,14 +645,14 @@ ResolveItem::visit (AST::TraitImpl &impl_block)
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 ();
@ -663,7 +662,7 @@ ResolveItem::visit (AST::TraitImpl &impl_block)
}
// 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 ();
@ -675,7 +674,7 @@ ResolveItem::visit (AST::TraitImpl &impl_block)
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);
@ -683,7 +682,7 @@ ResolveItem::visit (AST::TraitImpl &impl_block)
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);
@ -722,22 +721,22 @@ ResolveItem::visit (AST::TraitImpl &impl_block)
// 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 ();
@ -765,7 +764,7 @@ ResolveItem::visit (AST::Trait &trait)
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 (
@ -775,7 +774,7 @@ ResolveItem::visit (AST::Trait &trait)
{
for (auto &bound : trait.get_type_param_bounds ())
{
ResolveTypeBound::go (bound.get ());
ResolveTypeBound::go (*bound);
}
}
@ -804,12 +803,12 @@ ResolveItem::visit (AST::ExternBlock &extern_block)
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)
{
@ -817,7 +816,7 @@ ResolveItem::resolve_impl_item (AST::AssociatedItem *item,
}
void
ResolveItem::resolve_extern_item (AST::ExternalItem *item)
ResolveItem::resolve_extern_item (AST::ExternalItem &item)
{
ResolveExternItem::go (item, prefix, canonical_prefix);
}
@ -953,7 +952,7 @@ ResolveItem::visit (AST::UseDeclaration &use_item)
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;
@ -977,14 +976,14 @@ ResolveImplItems::ResolveImplItems (const CanonicalPath &prefix,
{}
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
@ -1000,11 +999,11 @@ ResolveImplItems::visit (AST::TypeAlias &alias)
}
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
@ -1031,18 +1030,18 @@ ResolveExternItem::visit (AST::Function &function)
// 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 &param : 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
@ -1056,7 +1055,7 @@ ResolveExternItem::visit (AST::ExternalStaticItem &item)
{
resolve_visibility (item.get_visibility ());
ResolveType::go (item.get_type ().get ());
ResolveType::go (item.get_type ());
}
} // namespace Resolver

10
gcc/rust/resolve/rust-ast-resolve-item.h
View file

@ -52,7 +52,7 @@ class ResolveItem : public ResolverBase
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;
@ -76,10 +76,10 @@ public:
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);
@ -93,7 +93,7 @@ class ResolveImplItems : public ResolveItem
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;
@ -108,7 +108,7 @@ class ResolveExternItem : public ResolverBase
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;

38
gcc/rust/resolve/rust-ast-resolve-path.cc
View file

@ -26,35 +26,35 @@ namespace Resolver {
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;
@ -219,14 +219,14 @@ ResolvePath::resolve_path (AST::PathInExpression *expr)
// 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
@ -238,14 +238,14 @@ ResolvePath::resolve_path (AST::PathInExpression *expr)
}
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
@ -260,18 +260,18 @@ ResolvePath::resolve_path (AST::QualifiedPathInExpression *expr)
}
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 ())
@ -393,14 +393,14 @@ ResolvePath::resolve_path (AST::SimplePath *expr)
// 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

12
gcc/rust/resolve/rust-ast-resolve-path.h
View file

@ -29,16 +29,16 @@ class ResolvePath : public ResolverBase
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,

65
gcc/rust/resolve/rust-ast-resolve-pattern.cc
View file

@ -23,7 +23,7 @@ namespace Rust {
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> ())};
@ -31,11 +31,11 @@ PatternDeclaration::go (AST::Pattern *pattern, Rib::ItemType type)
}
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)
{
@ -71,28 +71,28 @@ PatternDeclaration::visit (AST::IdentifierPattern &pattern)
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
@ -101,12 +101,12 @@ PatternDeclaration::visit (AST::TupleStructPattern &pattern)
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;
@ -116,7 +116,7 @@ PatternDeclaration::visit (AST::TupleStructPattern &pattern)
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 ())
@ -127,7 +127,7 @@ PatternDeclaration::visit (AST::StructPattern &pattern)
AST::StructPatternFieldTuplePat &tuple
= static_cast<AST::StructPatternFieldTuplePat &> (*field);
tuple.get_index_pattern ()->accept_vis (*this);
tuple.get_index_pattern ().accept_vis (*this);
}
break;
@ -135,13 +135,12 @@ PatternDeclaration::visit (AST::StructPattern &pattern)
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;
@ -158,13 +157,12 @@ PatternDeclaration::visit (AST::StructPattern &pattern)
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);
@ -172,9 +170,8 @@ PatternDeclaration::visit (AST::TuplePattern &pattern)
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);
@ -342,27 +339,25 @@ PatternDeclaration::check_bindings_consistency (
}
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;
}
@ -371,8 +366,8 @@ resolve_range_pattern_bound (AST::RangePatternBound *bound)
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

4
gcc/rust/resolve/rust-ast-resolve-pattern.h
View file

@ -95,8 +95,8 @@ class PatternDeclaration : public ResolverBase
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;

17
gcc/rust/resolve/rust-ast-resolve-stmt.cc
View file

@ -30,31 +30,30 @@ ResolveStmt::visit (AST::ExternBlock &extern_block)
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

71
gcc/rust/resolve/rust-ast-resolve-stmt.h
View file

@ -33,20 +33,20 @@ class ResolveStmt : public ResolverBase
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
@ -66,21 +66,20 @@ public:
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
@ -107,11 +106,11 @@ public:
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 ();
}
@ -140,11 +139,11 @@ public:
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 ();
}
@ -188,10 +187,10 @@ public:
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 ());
}
}
@ -214,10 +213,10 @@ public:
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 ());
}
}
@ -265,15 +264,15 @@ public:
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 ();
@ -302,14 +301,14 @@ public:
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 ();
@ -343,10 +342,10 @@ public:
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> ())};
@ -357,28 +356,28 @@ public:
{
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 ());
ResolveType::go (param->get_type ().get ());
auto &param = static_cast<AST::SelfParam &> (*p);
ResolveType::go (param.get_type ());
}
else
{
auto param = static_cast<AST::FunctionParam *> (p.get ());
auto &param = 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 ();

10
gcc/rust/resolve/rust-ast-resolve-struct-expr-field.cc
View file

@ -23,12 +23,12 @@ namespace Rust {
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 (
@ -39,13 +39,13 @@ 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
@ -54,7 +54,7 @@ ResolveStructExprField::visit (AST::StructExprFieldIdentifier &field)
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

2
gcc/rust/resolve/rust-ast-resolve-struct-expr-field.h
View file

@ -31,7 +31,7 @@ class ResolveStructExprField : public ResolverBase
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;

26
gcc/rust/resolve/rust-ast-resolve-toplevel.h
View file

@ -31,18 +31,18 @@ class ResolveTopLevel : public ResolverBase
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
@ -67,7 +67,7 @@ public:
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 ();
@ -137,7 +137,7 @@ public:
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 ();
@ -343,9 +343,9 @@ public:
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
@ -354,14 +354,14 @@ public:
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 ();
@ -385,7 +385,7 @@ public:
});
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
@ -416,7 +416,7 @@ public:
{
for (auto &item : extern_block.get_extern_items ())
{
ResolveToplevelExternItem::go (item.get (), prefix);
ResolveToplevelExternItem::go (*item, prefix);
}
}

47
gcc/rust/resolve/rust-ast-resolve-type.cc
View file

@ -27,15 +27,15 @@ namespace Resolver {
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
@ -44,20 +44,20 @@ ResolveType::visit (AST::TraitObjectType &type)
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
@ -75,7 +75,7 @@ ResolveType::visit (AST::NeverType &)
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
@ -153,12 +153,12 @@ ResolveRelativeTypePath::go (AST::TypePath &path, NodeId &resolved_node_id)
AST::TypePathFunction &fn = fnseg->get_type_path_function ();
for (auto &param : 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;
@ -318,11 +318,11 @@ ResolveRelativeQualTypePath::resolve_qual_seg (AST::QualifiedPathType &seg)
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;
}
@ -356,10 +356,10 @@ ResolveRelativeQualTypePath::visit (AST::TypePathSegment &seg)
// 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 ();
}
@ -402,8 +402,9 @@ ResolveTypeToCanonicalPath::visit (AST::TypePath &path)
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));
}
@ -444,8 +445,7 @@ void
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" : "";
@ -458,8 +458,7 @@ void
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
@ -474,7 +473,7 @@ void
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 () + "]";
@ -487,7 +486,7 @@ ResolveTypeToCanonicalPath::visit (AST::TraitObjectTypeOneBound &type)
{
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)
{
@ -550,10 +549,10 @@ ResolveGenericArgs::resolve_disambiguated_generic (AST::GenericArg &arg)
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 ();
@ -584,7 +583,7 @@ ResolveGenericArgs::go (AST::GenericArgs &generic_args,
for (auto &binding : generic_args.get_binding_args ())
{
ResolveType::go (binding.get_type ().get ());
ResolveType::go (binding.get_type ());
}
}

36
gcc/rust/resolve/rust-ast-resolve-type.h
View file

@ -56,20 +56,20 @@ class ResolveType : public ResolverBase
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 &param : 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
@ -81,7 +81,7 @@ public:
}
for (auto &elem : tuple.get_elems ())
ResolveType::go (elem.get ());
ResolveType::go (*elem);
}
void visit (AST::TypePath &path) override
@ -119,16 +119,16 @@ class ResolveTypeBound : public ResolverBase
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:
@ -140,21 +140,21 @@ class ResolveGenericParam : public ResolverBase
using Rust::Resolver::ResolverBase::visit;
public:
static NodeId go (AST::GenericParam *param, const CanonicalPath &prefix,
static NodeId go (AST::GenericParam &param, 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 &param) 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;
}
@ -163,13 +163,13 @@ public:
{
// 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);
}
}
@ -213,12 +213,12 @@ public:
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);
}
}
}
@ -232,7 +232,7 @@ class ResolveTypeToCanonicalPath : public ResolverBase
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;

9
gcc/rust/resolve/rust-ast-resolve.cc
View file

@ -92,9 +92,8 @@ NameResolution::go (AST::Crate &crate)
// 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 ())
@ -104,8 +103,8 @@ NameResolution::go (AST::Crate &crate)
}
// 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 ();

68
gcc/rust/resolve/rust-default-resolver.cc
View file

@ -35,7 +35,7 @@ DefaultResolver::visit (AST::BlockExpr &expr)
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);
@ -61,21 +61,21 @@ DefaultResolver::visit (AST::Function &function)
{
if (p->is_variadic ())
{
auto param = static_cast<AST::VariadicParam *> (p.get ());
if (param->has_pattern ())
param->get_pattern ()->accept_vis (*this);
auto &param = 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 &param = 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 &param = static_cast<AST::FunctionParam &> (*p);
param.get_pattern ().accept_vis (*this);
param.get_type ().accept_vis (*this);
}
}
@ -90,9 +90,9 @@ void
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);
});
}
@ -188,12 +188,12 @@ DefaultResolver::visit (AST::ClosureExprInner &expr)
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
@ -207,13 +207,13 @@ DefaultResolver::visit (AST::ClosureExprInnerTyped &expr)
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
@ -263,16 +263,16 @@ DefaultResolver::visit (AST::WhileLetLoopExpr &expr)
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
@ -289,14 +289,14 @@ DefaultResolver::visit (AST::MatchExpr &expr)
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);
}
}
@ -339,7 +339,7 @@ DefaultResolver::visit (AST::PathInExpression &expr)
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);
}
@ -441,27 +441,27 @@ void
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);
@ -470,7 +470,7 @@ DefaultResolver::visit (AST::ConstantItem &item)
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);

28
gcc/rust/resolve/rust-early-name-resolver.cc
View file

@ -90,13 +90,13 @@ EarlyNameResolver::resolve_generic_args (AST::GenericArgs &generic_args)
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);
@ -227,7 +227,7 @@ EarlyNameResolver::visit (AST::BlockExpr &expr)
stmt->accept_vis (*this);
if (expr.has_tail_expr ())
expr.get_tail_expr ()->accept_vis (*this);
expr.get_tail_expr ().accept_vis (*this);
});
}
@ -243,37 +243,37 @@ void
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);
});
}
});
@ -365,7 +365,7 @@ EarlyNameResolver::visit (AST::Trait &trait)
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);
@ -379,7 +379,7 @@ EarlyNameResolver::visit (AST::InherentImpl &impl)
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);
@ -558,7 +558,7 @@ EarlyNameResolver::visit (AST::StructPattern &)
void
EarlyNameResolver::visit (AST::TupleStructPattern &pattern)
{
pattern.get_items ()->accept_vis (*this);
pattern.get_items ().accept_vis (*this);
}
void

6
gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc
View file

@ -213,7 +213,7 @@ TopLevel::visit (AST::BlockExpr &expr)
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);
@ -223,7 +223,7 @@ void
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);
}
@ -299,7 +299,7 @@ void
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);
}