Refactor HIR with optionals, references & newtypes

The HIR made heavy use of pair and other unamed types which can be
difficult to read.

gcc/rust/ChangeLog:

	* backend/rust-compile-base.cc: Use FnParam getter.
	* backend/rust-compile-expr.cc (CompileExpr::visit): Likewise.
	* backend/rust-compile-intrinsic.cc: Likewise.
	* backend/rust-compile-type.cc: Likewise.
	* checks/errors/privacy/rust-privacy-reporter.cc (PrivacyReporter::visit):
	Only visit childrens if not missing.
	* checks/errors/rust-unsafe-checker.cc (UnsafeChecker::visit): Use
	a reference instead of a raw pointer.
	* hir/tree/rust-hir-expr.h: Add presence function for return
	expression.
	* hir/tree/rust-hir-item.h: Remove take_param_name.
	* hir/tree/rust-hir.h: Make mapping getter const.
	* typecheck/rust-hir-dot-operator.cc (MethodResolver::Select): Use
	getter.
	* typecheck/rust-hir-type-check-expr.cc: Likewise.
	* typecheck/rust-hir-type-check-implitem.cc: Use FnParam vector instead
	of std::pair of Pattern and BaseType.
	* typecheck/rust-hir-type-check-item.cc: Likewise.
	* typecheck/rust-hir-type-check.cc: Likewise.
	* typecheck/rust-tyty-call.cc (TypeCheckCallExpr::visit): Use getters.
	(TypeCheckMethodCallExpr::check): Likewise.
	* typecheck/rust-tyty-cmp.h: Likewise.
	* typecheck/rust-tyty.cc: Use FnParam.
	* typecheck/rust-tyty.h (class FnParam): Add FnParam to handle function
	parameters instead of handling std::pairs.
	* typecheck/rust-unify.cc (UnifyRules::expect_fndef): Use getters.
	(UnifyRules::expect_fnptr): Likewise.

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

1 files changed, 9 insertions, 8 deletions

diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc
index 0ffc363..08b64439 100644
--- a/gcc/rust/backend/rust-compile-intrinsic.cc
+++ b/gcc/rust/backend/rust-compile-intrinsic.cc
@@ -315,13 +315,13 @@ compile_fn_params (Context *ctx, TyTy::FnType *fntype, tree fndecl,
 {
   for (auto &parm : fntype->get_params ())
     {
-      auto &referenced_param = parm.first;
-      auto &param_tyty = parm.second;
+      auto &referenced_param = parm.get_pattern ();
+      auto param_tyty = parm.get_type ();
       auto compiled_param_type = TyTyResolveCompile::compile (ctx, param_tyty);
 
-      location_t param_locus = referenced_param->get_locus ();
+      location_t param_locus = referenced_param.get_locus ();
       Bvariable *compiled_param_var
-	= CompileFnParam::compile (ctx, fndecl, *referenced_param,
+	= CompileFnParam::compile (ctx, fndecl, referenced_param,
 				   compiled_param_type, param_locus);
 
       compiled_param_variables->push_back (compiled_param_var);
@@ -496,9 +496,10 @@ transmute_handler (Context *ctx, TyTy::FnType *fntype)
       rust_error_at (fntype->get_locus (),
 		     "cannot transmute between types of different sizes, or "
 		     "dependently-sized types");
-      rust_inform (fntype->get_ident ().locus, "source type: %qs (%lu bits)",
-		   fntype->get_params ().at (0).second->as_string ().c_str (),
-		   (unsigned long) source_size);
+      rust_inform (
+	fntype->get_ident ().locus, "source type: %qs (%lu bits)",
+	fntype->get_params ().at (0).get_type ()->as_string ().c_str (),
+	(unsigned long) source_size);
       rust_inform (fntype->get_ident ().locus, "target type: %qs (%lu bits)",
 		   fntype->get_return_type ()->as_string ().c_str (),
 		   (unsigned long) target_size);
@@ -1226,7 +1227,7 @@ assume_handler (Context *ctx, TyTy::FnType *fntype)
   // TODO: make sure this is actually helping the compiler optimize
 
   rust_assert (fntype->get_params ().size () == 1);
-  rust_assert (fntype->param_at (0).second->get_kind ()
+  rust_assert (fntype->param_at (0).get_type ()->get_kind ()
 	       == TyTy::TypeKind::BOOL);
 
   tree lookup = NULL_TREE;