Refactor HIR to reduce the amount of raw pointers

Attempt to use references and smart pointers whenever possible.

gcc/rust/ChangeLog:

	* backend/rust-compile-base.cc (HIRCompileBase::compile_function_body):
	Remove usage of get function to retrieve a raw pointer.
	* backend/rust-compile-base.h:
	Change API usage from raw pointer to a reference.
	* backend/rust-compile-block.cc (CompileBlock::compile): Likewise.
	(CompileBlock::visit): Likewise.
	(CompileConditionalBlocks::visit): Likewise.
	* backend/rust-compile-block.h: Likewise.
	* backend/rust-compile-expr.cc (CompileExpr::Compile): Likewise.
	(CompileExpr::visit): Likewise.
	(check_match_scrutinee): Likewise.
	(CompileExpr::array_value_expr): Likewise.
	(CompileExpr::array_copied_expr): Likewise.
	(CompileExpr::generate_closure_function): Likewise.
	(CompileExpr::generate_possible_fn_trait_call): Likewise.
	* backend/rust-compile-expr.h: Likewise.
	* backend/rust-compile-fnparam.cc (CompileFnParam::compile): Likewise.
	(CompileFnParam::visit): Likewise.
	* backend/rust-compile-fnparam.h: Likewise.
	* backend/rust-compile-implitem.cc (CompileTraitItem::visit): Likewise.
	* backend/rust-compile-intrinsic.cc (compile_fn_params): Likewise.
	* backend/rust-compile-item.cc (CompileItem::visit): Likewise.
	* backend/rust-compile-pattern.cc (CompilePatternCheckExpr::visit):
	Likewise.
	(compile_range_pattern_bound): Likewise.
	(CompilePatternBindings::visit): Likewise.
	(CompilePatternLet::visit): Likewise.
	* backend/rust-compile-pattern.h: Likewise.
	* backend/rust-compile-resolve-path.cc (ResolvePathRef::resolve):
	Likewise.
	(HIRCompileBase::query_compile): Likewise.
	* backend/rust-compile-stmt.cc (CompileStmt::visit): Likewise.
	* backend/rust-compile-struct-field-expr.cc (CompileStructExprField::Compile):
	Likewise.
	(CompileStructExprField::visit): Likewise.
	* backend/rust-compile-struct-field-expr.h: Likewise.
	* backend/rust-compile-type.cc (TyTyResolveCompile::visit): Likewise.
	* backend/rust-compile-var-decl.h: Likewise.
	* backend/rust-compile.cc: Likewise.
	* backend/rust-mangle-v0.cc (v0_inherent_or_trait_impl_path): Likewise.
	* checks/errors/borrowck/rust-bir-builder-expr-stmt.cc (ExprStmtBuilder::visit):
	Likewise.
	* checks/errors/borrowck/rust-bir-builder-lazyboolexpr.h: Likewise.
	* checks/errors/borrowck/rust-bir-builder-pattern.h: Likewise.
	* checks/errors/borrowck/rust-bir-builder-struct.h: Likewise.
	* checks/errors/borrowck/rust-bir-builder.h: Likewise.
	* checks/errors/borrowck/rust-function-collector.h: Likewise.
	* checks/errors/privacy/rust-privacy-reporter.cc (PrivacyReporter::check_type_privacy):
	Likewise.
	(PrivacyReporter::visit): Likewise.
	* checks/errors/privacy/rust-privacy-reporter.h: Likewise.
	* checks/errors/privacy/rust-reachability.cc (ReachabilityVisitor::visit):
	Likewise.
	* checks/errors/rust-const-checker.cc (ConstChecker::visit): Likewise.
	* checks/errors/rust-unsafe-checker.cc (UnsafeChecker::visit):
	Likewise.
	* checks/lints/rust-lint-marklive.cc (MarkLive::visit): Likewise.
	* checks/lints/rust-lint-marklive.h: Likewise.
	* hir/rust-hir-dump.cc (Dump::visit): Likewise.
	* hir/tree/rust-hir-expr.h: Likewise.
	* hir/tree/rust-hir-item.h: Likewise.
	* hir/tree/rust-hir-path.h: Likewise.
	* hir/tree/rust-hir-pattern.h: Likewise.
	* hir/tree/rust-hir-stmt.h: Likewise.
	* hir/tree/rust-hir-type.h: Likewise.
	* hir/tree/rust-hir.h: Likewise.
	* typecheck/rust-autoderef.cc: Likewise.
	* typecheck/rust-hir-dot-operator.cc (MethodResolver::select):
	Likewise.
	* typecheck/rust-hir-inherent-impl-overlap.h: Likewise.
	* typecheck/rust-hir-path-probe.cc (PathProbeType::process_impl_item_candidate):
	Likewise.
	(PathProbeImplTrait::process_trait_impl_items_for_candidates): Likewise.
	* typecheck/rust-hir-trait-resolve.cc (TraitResolver::resolve_trait):
	Likewise.
	(TraitItemReference::resolve_item): Likewise.
	* typecheck/rust-hir-type-check-base.cc: Likewise.
	* typecheck/rust-hir-type-check-base.h: Likewise.
	* typecheck/rust-hir-type-check-enumitem.cc (TypeCheckEnumItem::Resolve):
	Likewise.
	(TypeCheckEnumItem::visit): Likewise.
	* typecheck/rust-hir-type-check-enumitem.h: Likewise.
	* typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::Resolve):
	Likewise.
	(TypeCheckExpr::visit): Likewise.
	(TypeCheckExpr::resolve_fn_trait_call): Likewise.
	* typecheck/rust-hir-type-check-expr.h: Likewise.
	* typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::Resolve):
	Likewise.
	(TypeCheckTopLevelExternItem::visit): Likewise.
	(TypeCheckImplItem::visit): Likewise.
	(TypeCheckImplItemWithTrait::visit): Likewise.
	* typecheck/rust-hir-type-check-implitem.h: Likewise.
	* typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): Likewise.
	(TypeCheckItem::resolve_impl_item): Likewise.
	(TypeCheckItem::resolve_impl_block_substitutions): Likewise.
	(TypeCheckItem::resolve_impl_block_self): Likewise.
	* typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::visit): Likewise.
	(TypeCheckExpr::resolve_segments): Likewise.
	* typecheck/rust-hir-type-check-pattern.cc (TypeCheckPattern::Resolve):
	Likewise.
	(TypeCheckPattern::visit): Likewise.
	(ClosureParamInfer::Resolve): Likewise.
	(ClosureParamInfer::visit): Likewise.
	* typecheck/rust-hir-type-check-pattern.h: Likewise.
	* typecheck/rust-hir-type-check-stmt.cc (TypeCheckStmt::Resolve):
	Likewise.
	(TypeCheckStmt::visit): Likewise.
	* typecheck/rust-hir-type-check-stmt.h: Likewise.
	* typecheck/rust-hir-type-check-struct-field.h: Likewise.
	* typecheck/rust-hir-type-check-struct.cc (TypeCheckStructExpr::TypeCheckStructExpr):
	Likewise.
	(TypeCheckStructExpr::Resolve): Likewise.
	(TypeCheckStructExpr::resolve): Likewise.
	(TypeCheckStructExpr::visit): Likewise.
	* typecheck/rust-hir-type-check-type.cc (TypeCheckResolveGenericArguments::resolve):
	Likewise.
	(TypeCheckType::Resolve): Likewise.
	(TypeCheckType::visit): Likewise.
	(TypeCheckType::resolve_root_path): Likewise.
	(TypeResolveGenericParam::Resolve): Likewise.
	(TypeResolveGenericParam::visit): Likewise.
	(ResolveWhereClauseItem::visit): Likewise.
	* typecheck/rust-hir-type-check-type.h: Likewise.
	* typecheck/rust-hir-type-check.cc (TraitItemReference::get_type_from_fn):
	Likewise.
	* typecheck/rust-hir-type-check.h: Likewise.
	* typecheck/rust-type-util.cc (query_type): Likewise.
	* typecheck/rust-typecheck-context.cc (TypeCheckContextItem::TypeCheckContextItem):
	Likewise.
	* typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::scan): Likewise.
	(TypeCheckBase::get_predicate_from_bound): Likewise.
	* typecheck/rust-tyty-call.cc (TypeCheckCallExpr::visit): Likewise.
	(TypeCheckMethodCallExpr::go): Likewise.
	(TypeCheckMethodCallExpr::check): Likewise.
	* typecheck/rust-tyty-subst.cc: Likewise.
	* typecheck/rust-tyty.cc (BaseType::monomorphized_clone): Likewise.
	(VariantDef::VariantDef): Remove copy constructor.
	(VariantDef::operator=): Change to move operator.
	(VariantDef::get_discriminant): Replace return type to a reference
	instead of a reference to a unique pointer.
	(VariantDef::clone): Change to references.
	(VariantDef::monomorphized_clone): Likewise.
	(FnType::as_string): Likewise.
	(FnType::clone): Likewise.
	* typecheck/rust-tyty.h: Likewise.
	* util/rust-hir-map.cc (Mappings::insert_hir_impl_block): Likewise.
	* backend/rust-compile-asm.cc: Use a reference instead of the raw
	pointer value.
	* checks/errors/borrowck/rust-bir-builder-pattern.cc: Use references.
	* checks/errors/rust-hir-pattern-analysis.cc: Likewise.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

1 files changed, 35 insertions, 42 deletions

diff --git a/gcc/rust/backend/rust-compile-pattern.cc b/gcc/rust/backend/rust-compile-pattern.cc
index c462a6d..a1d2e68 100644
--- a/gcc/rust/backend/rust-compile-pattern.cc
+++ b/gcc/rust/backend/rust-compile-pattern.cc
@@ -67,7 +67,7 @@ CompilePatternCheckExpr::visit (HIR::PathInExpression &pattern)
   // must be enum
   match_scrutinee_expr = scrutinee_expr_qualifier_expr;
 
-  HIR::Expr *discrim_expr = variant->get_discriminant ();
+  HIR::Expr &discrim_expr = variant->get_discriminant ();
   tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
 
   check_expr
@@ -80,10 +80,9 @@ void
 CompilePatternCheckExpr::visit (HIR::LiteralPattern &pattern)
 {
   // Compile the literal
-  HIR::LiteralExpr *litexpr
-    = new HIR::LiteralExpr (pattern.get_mappings (), pattern.get_literal (),
-			    pattern.get_locus (),
-			    std::vector<AST::Attribute> ());
+  auto litexpr = Rust::make_unique<HIR::LiteralExpr> (
+    HIR::LiteralExpr (pattern.get_mappings (), pattern.get_literal (),
+		      pattern.get_locus (), std::vector<AST::Attribute> ()));
 
   // Note: Floating point literals are currently accepted but will likely be
   // forbidden in LiteralPatterns in a future version of Rust.
@@ -95,7 +94,7 @@ CompilePatternCheckExpr::visit (HIR::LiteralPattern &pattern)
       rust_sorry_at (pattern.get_locus (), "floating-point literal in pattern");
     }
 
-  tree lit = CompileExpr::Compile (litexpr, ctx);
+  tree lit = CompileExpr::Compile (*litexpr, ctx);
 
   check_expr = Backend::comparison_expression (ComparisonOperator::EQUAL,
 					       match_scrutinee_expr, lit,
@@ -103,19 +102,17 @@ CompilePatternCheckExpr::visit (HIR::LiteralPattern &pattern)
 }
 
 static tree
-compile_range_pattern_bound (HIR::RangePatternBound *bound,
+compile_range_pattern_bound (HIR::RangePatternBound &bound,
 			     Analysis::NodeMapping mappings, location_t locus,
 			     Context *ctx)
 {
   tree result = NULL_TREE;
-  switch (bound->get_bound_type ())
+  switch (bound.get_bound_type ())
     {
       case HIR::RangePatternBound::RangePatternBoundType::LITERAL: {
-	HIR::RangePatternBoundLiteral &ref
-	  = *static_cast<HIR::RangePatternBoundLiteral *> (bound);
+	auto &ref = static_cast<HIR::RangePatternBoundLiteral &> (bound);
 
-	HIR::LiteralExpr *litexpr
-	  = new HIR::LiteralExpr (mappings, ref.get_literal (), locus,
+	HIR::LiteralExpr litexpr (mappings, ref.get_literal (), locus,
 				  std::vector<AST::Attribute> ());
 
 	result = CompileExpr::Compile (litexpr, ctx);
@@ -123,8 +120,7 @@ compile_range_pattern_bound (HIR::RangePatternBound *bound,
       break;
 
       case HIR::RangePatternBound::RangePatternBoundType::PATH: {
-	HIR::RangePatternBoundPath &ref
-	  = *static_cast<HIR::RangePatternBoundPath *> (bound);
+	auto &ref = static_cast<HIR::RangePatternBoundPath &> (bound);
 
 	result = ResolvePathRef::Compile (ref.get_path (), ctx);
 
@@ -134,8 +130,7 @@ compile_range_pattern_bound (HIR::RangePatternBound *bound,
       break;
 
       case HIR::RangePatternBound::RangePatternBoundType::QUALPATH: {
-	HIR::RangePatternBoundQualPath &ref
-	  = *static_cast<HIR::RangePatternBoundQualPath *> (bound);
+	auto &ref = static_cast<HIR::RangePatternBoundQualPath &> (bound);
 
 	result = ResolvePathRef::Compile (ref.get_qualified_path (), ctx);
 
@@ -150,10 +145,10 @@ compile_range_pattern_bound (HIR::RangePatternBound *bound,
 void
 CompilePatternCheckExpr::visit (HIR::RangePattern &pattern)
 {
-  tree upper = compile_range_pattern_bound (pattern.get_upper_bound ().get (),
+  tree upper = compile_range_pattern_bound (pattern.get_upper_bound (),
 					    pattern.get_mappings (),
 					    pattern.get_locus (), ctx);
-  tree lower = compile_range_pattern_bound (pattern.get_lower_bound ().get (),
+  tree lower = compile_range_pattern_bound (pattern.get_lower_bound (),
 					    pattern.get_mappings (),
 					    pattern.get_locus (), ctx);
 
@@ -175,7 +170,7 @@ CompilePatternCheckExpr::visit (HIR::ReferencePattern &pattern)
 {
   match_scrutinee_expr
     = indirect_expression (match_scrutinee_expr, pattern.get_locus ());
-  pattern.get_referenced_pattern ()->accept_vis (*this);
+  pattern.get_referenced_pattern ().accept_vis (*this);
 }
 
 void
@@ -183,14 +178,13 @@ CompilePatternCheckExpr::visit (HIR::AltPattern &pattern)
 {
   auto &alts = pattern.get_alts ();
 
-  check_expr = CompilePatternCheckExpr::Compile (alts.at (0).get (),
+  check_expr = CompilePatternCheckExpr::Compile (*alts.at (0),
 						 match_scrutinee_expr, ctx);
   auto end = alts.end ();
   for (auto i = alts.begin () + 1; i != end; i++)
     {
       tree next_expr
-	= CompilePatternCheckExpr::Compile (i->get (), match_scrutinee_expr,
-					    ctx);
+	= CompilePatternCheckExpr::Compile (**i, match_scrutinee_expr, ctx);
       check_expr = Backend::arithmetic_or_logical_expression (
 	ArithmeticOrLogicalOperator::BITWISE_OR, check_expr, next_expr,
 	(*i)->get_locus ());
@@ -229,7 +223,7 @@ CompilePatternCheckExpr::visit (HIR::StructPattern &pattern)
       // // would be DECL_QUALIFIER i think. For now this will just access the
       // // first record field and its respective qualifier because it will
       // // always be set because this is all a big special union
-      HIR::Expr *discrim_expr = variant->get_discriminant ();
+      HIR::Expr &discrim_expr = variant->get_discriminant ();
       tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
 
       // find discriminant field of scrutinee
@@ -282,11 +276,11 @@ CompilePatternCheckExpr::visit (HIR::StructPattern &pattern)
 						  ident.get_locus ());
 
 	    tree check_expr_sub
-	      = CompilePatternCheckExpr::Compile (ident.get_pattern ().get (),
+	      = CompilePatternCheckExpr::Compile (ident.get_pattern (),
 						  field_expr, ctx);
 	    check_expr = Backend::arithmetic_or_logical_expression (
 	      ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
-	      check_expr_sub, ident.get_pattern ()->get_locus ());
+	      check_expr_sub, ident.get_pattern ().get_locus ());
 	  }
 	  break;
 
@@ -328,7 +322,7 @@ CompilePatternCheckExpr::visit (HIR::TupleStructPattern &pattern)
       rust_assert (ok);
 
       // find expected discriminant
-      HIR::Expr *discrim_expr = variant->get_discriminant ();
+      HIR::Expr &discrim_expr = variant->get_discriminant ();
       tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
 
       // find discriminant field of scrutinee
@@ -357,8 +351,8 @@ CompilePatternCheckExpr::visit (HIR::TupleStructPattern &pattern)
       tuple_field_index = 0;
     }
 
-  std::unique_ptr<HIR::TupleStructItems> &items = pattern.get_items ();
-  switch (items->get_item_type ())
+  HIR::TupleStructItems &items = pattern.get_items ();
+  switch (items.get_item_type ())
     {
       case HIR::TupleStructItems::RANGED: {
 	// TODO
@@ -368,7 +362,7 @@ CompilePatternCheckExpr::visit (HIR::TupleStructPattern &pattern)
 
       case HIR::TupleStructItems::MULTIPLE: {
 	HIR::TupleStructItemsNoRange &items_no_range
-	  = static_cast<HIR::TupleStructItemsNoRange &> (*items.get ());
+	  = static_cast<HIR::TupleStructItemsNoRange &> (items);
 
 	rust_assert (items_no_range.get_patterns ().size ()
 		     == variant->num_fields ());
@@ -381,8 +375,7 @@ CompilePatternCheckExpr::visit (HIR::TupleStructPattern &pattern)
 						  pattern->get_locus ());
 
 	    tree check_expr_sub
-	      = CompilePatternCheckExpr::Compile (pattern.get (), field_expr,
-						  ctx);
+	      = CompilePatternCheckExpr::Compile (*pattern, field_expr, ctx);
 	    check_expr = Backend::arithmetic_or_logical_expression (
 	      ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
 	      check_expr_sub, pattern->get_locus ());
@@ -397,7 +390,7 @@ CompilePatternCheckExpr::visit (HIR::TuplePattern &pattern)
 {
   check_expr = boolean_true_node;
 
-  switch (pattern.get_items ()->get_item_type ())
+  switch (pattern.get_items ().get_item_type ())
     {
       case HIR::TuplePatternItems::RANGED: {
 	// TODO
@@ -407,7 +400,7 @@ CompilePatternCheckExpr::visit (HIR::TuplePattern &pattern)
 
       case HIR::TuplePatternItems::MULTIPLE: {
 	auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
-	  *pattern.get_items ());
+	  pattern.get_items ());
 	size_t tuple_field_index = 0;
 
 	for (auto &pat : items.get_patterns ())
@@ -418,7 +411,7 @@ CompilePatternCheckExpr::visit (HIR::TuplePattern &pattern)
 						  pat->get_locus ());
 
 	    tree check_expr_sub
-	      = CompilePatternCheckExpr::Compile (pat.get (), field_expr, ctx);
+	      = CompilePatternCheckExpr::Compile (*pat, field_expr, ctx);
 	    check_expr = Backend::arithmetic_or_logical_expression (
 	      ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
 	      check_expr_sub, pat->get_locus ());
@@ -459,8 +452,8 @@ CompilePatternBindings::visit (HIR::TupleStructPattern &pattern)
   rust_assert (variant->get_variant_type ()
 	       == TyTy::VariantDef::VariantType::TUPLE);
 
-  std::unique_ptr<HIR::TupleStructItems> &items = pattern.get_items ();
-  switch (items->get_item_type ())
+  HIR::TupleStructItems &items = pattern.get_items ();
+  switch (items.get_item_type ())
     {
       case HIR::TupleStructItems::RANGED: {
 	// TODO
@@ -470,7 +463,7 @@ CompilePatternBindings::visit (HIR::TupleStructPattern &pattern)
 
       case HIR::TupleStructItems::MULTIPLE: {
 	HIR::TupleStructItemsNoRange &items_no_range
-	  = static_cast<HIR::TupleStructItemsNoRange &> (*items.get ());
+	  = static_cast<HIR::TupleStructItemsNoRange &> (items);
 
 	rust_assert (items_no_range.get_patterns ().size ()
 		     == variant->num_fields ());
@@ -609,8 +602,8 @@ CompilePatternBindings::visit (HIR::ReferencePattern &pattern)
   tree derefed
     = indirect_expression (match_scrutinee_expr, pattern.get_locus ());
 
-  CompilePatternBindings::Compile (pattern.get_referenced_pattern ().get (),
-				   derefed, ctx);
+  CompilePatternBindings::Compile (pattern.get_referenced_pattern (), derefed,
+				   ctx);
 }
 
 void
@@ -670,12 +663,12 @@ CompilePatternLet::visit (HIR::TuplePattern &pattern)
   tree access_expr = Backend::var_expression (tmp_var, pattern.get_locus ());
   ctx->add_statement (init_stmt);
 
-  switch (pattern.get_items ()->get_item_type ())
+  switch (pattern.get_items ().get_item_type ())
     {
       case HIR::TuplePatternItems::ItemType::RANGED: {
 	size_t tuple_idx = 0;
 	auto &items
-	  = static_cast<HIR::TuplePatternItemsRanged &> (*pattern.get_items ());
+	  = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
 
 	auto &items_lower = items.get_lower_patterns ();
 	auto &items_upper = items.get_upper_patterns ();
@@ -719,7 +712,7 @@ CompilePatternLet::visit (HIR::TuplePattern &pattern)
       case HIR::TuplePatternItems::ItemType::MULTIPLE: {
 	size_t tuple_idx = 0;
 	auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
-	  *pattern.get_items ());
+	  pattern.get_items ());
 
 	for (auto &sub : items.get_patterns ())
 	  {