gccrs: 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>

diff --git a/gcc/rust/backend/rust-compile-base.cc b/gcc/rust/backend/rust-compile-base.cc
index 598f2e2e451b29829bf369858f41adc23f8d290b..80ea7a4ec95474abe8fe1086eea49910f1ecd81d 100644 (file)
--- a/gcc/rust/backend/rust-compile-base.cc
+++ b/gcc/rust/backend/rust-compile-base.cc
@@ -711,7 +711,7 @@ HIRCompileBase::compile_function (
   for (auto &referenced_param : function_params)
     {
       auto &tyty_param = fntype->param_at (i++);
-      auto param_tyty = tyty_param.second;
+      auto param_tyty = tyty_param.get_type ();
       auto compiled_param_type = TyTyResolveCompile::compile (ctx, param_tyty);
 
       location_t param_locus = referenced_param.get_locus ();

diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc
index c46bda954adfce7f37fd31a0258a71a4eb5c5c63..107ca2eadf5d23b7a479c45199710c7794ac0061 100644 (file)
--- a/gcc/rust/backend/rust-compile-expr.cc
+++ b/gcc/rust/backend/rust-compile-expr.cc
@@ -1267,7 +1267,7 @@ CompileExpr::visit (HIR::CallExpr &expr)
 
     const TyTy::FnType *fn = static_cast<const TyTy::FnType *> (base);
     auto &param = fn->param_at (index);
-    *result = param.second;
+    *result = param.get_type ();
 
     return true;
   };
@@ -1401,7 +1401,7 @@ CompileExpr::visit (HIR::MethodCallExpr &expr)
       // assignments are coercion sites so lets convert the rvalue if
       // necessary, offset from the already adjusted implicit self
       bool ok;
-      TyTy::BaseType *expected = fntype->param_at (i + 1).second;
+      TyTy::BaseType *expected = fntype->param_at (i + 1).get_type ();
 
       TyTy::BaseType *actual = nullptr;
       ok = ctx->get_tyctx ()->lookup_type (

diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc
index bf595e4fb8719194304f0ed4d781e1597ed9d15e..16447b29a51e77706f74ccbd780dac640fc28e4d 100644 (file)
--- 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;

diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc
index c53b359b01fc6632da7c9829499b601f4be2b079..56d64e1405bd7d3c31071d4f8d96ed65bc0ff8d6 100644 (file)
--- a/gcc/rust/backend/rust-compile-type.cc
+++ b/gcc/rust/backend/rust-compile-type.cc
@@ -208,12 +208,12 @@ TyTyResolveCompile::visit (const TyTy::FnType &type)
 
   for (auto &param_pair : type.get_params ())
     {
-      auto param_tyty = param_pair.second;
+      auto param_tyty = param_pair.get_type ();
       auto compiled_param_type
        = TyTyResolveCompile::compile (ctx, param_tyty, trait_object_mode);
 
       auto compiled_param = Backend::typed_identifier (
-       param_pair.first->as_string (), compiled_param_type,
+       param_pair.get_pattern ().as_string (), compiled_param_type,
        ctx->get_mappings ().lookup_location (param_tyty->get_ref ()));
 
       parameters.push_back (compiled_param);

diff --git a/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc b/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc
index 3cbf47ecc8b16c92c64c76f9f378c12a53ba1631..71030e5c7efaca0e1cc2e5f52271285b25d877ee 100644 (file)
--- a/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc
+++ b/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc
@@ -497,8 +497,8 @@ PrivacyReporter::visit (HIR::BlockExpr &expr)
   for (auto &stmt : expr.get_statements ())
     stmt->accept_vis (*this);
 
-  auto &last_expr = expr.get_final_expr ();
-  last_expr.accept_vis (*this);
+  if (expr.has_final_expr ())
+    expr.get_final_expr ().accept_vis (*this);
 }
 
 void
@@ -508,8 +508,8 @@ PrivacyReporter::visit (HIR::ContinueExpr &)
 void
 PrivacyReporter::visit (HIR::BreakExpr &expr)
 {
-  auto &break_expr = expr.get_expr ();
-  break_expr.accept_vis (*this);
+  if (expr.has_break_expr ())
+    expr.get_expr ().accept_vis (*this);
 }
 
 void
@@ -551,7 +551,8 @@ PrivacyReporter::visit (HIR::RangeToInclExpr &)
 void
 PrivacyReporter::visit (HIR::ReturnExpr &expr)
 {
-  expr.get_expr ().accept_vis (*this);
+  if (expr.has_expr ())
+    expr.get_expr ().accept_vis (*this);
 }
 
 void

diff --git a/gcc/rust/checks/errors/rust-unsafe-checker.cc b/gcc/rust/checks/errors/rust-unsafe-checker.cc
index 8f97edb6df5b3058f2c349d52c525dfdcbd8bbe5..6c9141c2dd2c7c5cb50768d2f293bd5212ccb72b 100644 (file)
--- a/gcc/rust/checks/errors/rust-unsafe-checker.cc
+++ b/gcc/rust/checks/errors/rust-unsafe-checker.cc
@@ -482,7 +482,7 @@ UnsafeChecker::visit (MethodCallExpr &expr)
   context.lookup_type (expr.get_method_name ().get_mappings ().get_hirid (),
                       &method_type);
 
-  auto fn = *static_cast<TyTy::FnType *> (method_type);
+  auto &fn = static_cast<TyTy::FnType &> (*method_type);
 
   auto method = mappings.lookup_hir_implitem (fn.get_ref ());
   if (!unsafe_context.is_in_context () && method)

diff --git a/gcc/rust/hir/tree/rust-hir-expr.h b/gcc/rust/hir/tree/rust-hir-expr.h
index 692b9b4a9acc014546d4caae81d789aa9c6ea7ef..c66b549a4d4a2a507236e0ebd4f0735d882e0daa 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir-expr.h
+++ b/gcc/rust/hir/tree/rust-hir-expr.h
@@ -2238,6 +2238,7 @@ public:
 
   bool is_final_stmt (Stmt *stmt) { return statements.back ().get () == stmt; }
 
+  bool has_final_expr () { return expr != nullptr; }
   Expr &get_final_expr () { return *expr; }
 
   std::vector<std::unique_ptr<Stmt> > &get_statements () { return statements; }
@@ -2785,6 +2786,7 @@ public:
   void accept_vis (HIRFullVisitor &vis) override;
   void accept_vis (HIRExpressionVisitor &vis) override;
 
+  bool has_expr () { return return_expr != nullptr; }
   Expr &get_expr () { return *return_expr; }
 
   ExprType get_expression_type () const override final

diff --git a/gcc/rust/hir/tree/rust-hir-item.h b/gcc/rust/hir/tree/rust-hir-item.h
index 3e98ad412ed206d639698120245b8884e6790319..7001466ade6c48efe8c7b3fbb5c238e7dd61f4e0 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir-item.h
+++ b/gcc/rust/hir/tree/rust-hir-item.h
@@ -549,8 +549,6 @@ public:
 
   Pattern &get_param_name () { return *param_name; }
 
-  std::unique_ptr<Pattern> take_param_name () { return std::move (param_name); }
-
   Type &get_type () { return *type; }
 
   const Analysis::NodeMapping &get_mappings () const { return mappings; }

diff --git a/gcc/rust/hir/tree/rust-hir.h b/gcc/rust/hir/tree/rust-hir.h
index 7d133e135b09411b27b30e40f9befb3c8a4d8acb..d208122a0ddb97099a320e1992378cf66c2246ab 100644 (file)
--- a/gcc/rust/hir/tree/rust-hir.h
+++ b/gcc/rust/hir/tree/rust-hir.h
@@ -465,7 +465,10 @@ public:
 
   virtual void accept_vis (HIRTypeVisitor &vis) = 0;
 
-  virtual Analysis::NodeMapping get_mappings () const { return mappings; }
+  virtual const Analysis::NodeMapping &get_mappings () const
+  {
+    return mappings;
+  }
   virtual location_t get_locus () const { return locus; }
 
 protected:

diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc
index 6af23176467b5cba3ebf5411935193e9205ff8d3..38bd5b75fb70dce3d7bae7287fdc114c6527ca3a 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-dot-operator.cc
+++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc
@@ -62,7 +62,7 @@ MethodResolver::Select (std::set<MethodCandidate> &candidates,
       for (size_t i = 0; i < arguments.size (); i++)
        {
          TyTy::BaseType *arg = arguments.at (i);
-         TyTy::BaseType *param = fn.get_params ().at (i + 1).second;
+         TyTy::BaseType *param = fn.get_params ().at (i + 1).get_type ();
          TyTy::BaseType *coerced
            = try_coercion (0, TyTy::TyWithLocation (param),
                            TyTy::TyWithLocation (arg), UNDEF_LOCATION);

diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc
index 32e3839930cf02988ae7feced7d751a8fcfbc7bd..e93fa297fd38c9d061d52bd38792c9d992cc4929 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc
@@ -1795,7 +1795,7 @@ TypeCheckExpr::resolve_operator_overload (LangItem::Kind lang_item_type,
 
   // typecheck the self
   unify_site (expr.get_mappings ().get_hirid (),
-             TyTy::TyWithLocation (fnparam.second),
+             TyTy::TyWithLocation (fnparam.get_type ()),
              TyTy::TyWithLocation (adjusted_self), expr.get_locus ());
   if (rhs == nullptr)
     {
@@ -1806,7 +1806,7 @@ TypeCheckExpr::resolve_operator_overload (LangItem::Kind lang_item_type,
       rust_assert (type->num_params () == 2);
       auto &fnparam = type->param_at (1);
       unify_site (expr.get_mappings ().get_hirid (),
-                 TyTy::TyWithLocation (fnparam.second),
+                 TyTy::TyWithLocation (fnparam.get_type ()),
                  TyTy::TyWithLocation (rhs), expr.get_locus ());
     }
 

diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc
index 2173938fb15a59b113c97e1ec4bd68ead7bb0672..602076811c35b8baa6878fb6d123e989fcdf54a0 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc
@@ -130,8 +130,7 @@ TypeCheckTopLevelExternItem::visit (HIR::ExternalFunctionItem &function)
        function.get_return_type ().get_mappings ().get_hirid ());
     }
 
-  std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *> > params;
-  std::unique_ptr<HIR::IdentifierPattern> param_pattern = nullptr;
+  std::vector<TyTy::FnParam> params;
   for (auto &param : function.get_function_params ())
     {
       // get the name as well required for later on
@@ -143,14 +142,12 @@ TypeCheckTopLevelExternItem::visit (HIR::ExternalFunctionItem &function)
                                     mappings.get_next_hir_id (crate_num),
                                     UNKNOWN_LOCAL_DEFID);
 
-      param_pattern = Rust::make_unique<HIR::IdentifierPattern> (
+      auto param_pattern = Rust::make_unique<HIR::IdentifierPattern> (
        HIR::IdentifierPattern (mapping, param.get_param_name (),
                                UNDEF_LOCATION, false, Mutability::Imm,
                                std::unique_ptr<HIR::Pattern> (nullptr)));
 
-      params.push_back (
-       std::pair<HIR::Pattern *, TyTy::BaseType *> (param_pattern.get (),
-                                                    param_tyty));
+      params.push_back (TyTy::FnParam (std::move (param_pattern), param_tyty));
 
       context->insert_type (param.get_mappings (), param_tyty);
 
@@ -375,8 +372,7 @@ TypeCheckImplItem::visit (HIR::Function &function)
        function.get_return_type ().get_mappings ().get_hirid ());
     }
 
-  std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *> > params;
-  std::unique_ptr<HIR::IdentifierPattern> self_pattern = nullptr;
+  std::vector<TyTy::FnParam> params;
   if (function.is_method ())
     {
       // these are implicit mappings and not used
@@ -390,10 +386,11 @@ TypeCheckImplItem::visit (HIR::Function &function)
       // reuse the HIR identifier pattern which requires it
       HIR::SelfParam &self_param = function.get_self_param ();
       // FIXME: which location should be used for Rust::Identifier for `self`?
-      self_pattern = Rust::make_unique<HIR::IdentifierPattern> (
-       HIR::IdentifierPattern (mapping, {"self"}, self_param.get_locus (),
-                               self_param.is_ref (), self_param.get_mut (),
-                               std::unique_ptr<HIR::Pattern> (nullptr)));
+      std::unique_ptr<HIR::Pattern> self_pattern
+       = Rust::make_unique<HIR::IdentifierPattern> (
+         HIR::IdentifierPattern (mapping, {"self"}, self_param.get_locus (),
+                                 self_param.is_ref (), self_param.get_mut (),
+                                 std::unique_ptr<HIR::Pattern> (nullptr)));
 
       // might have a specified type
       TyTy::BaseType *self_type = nullptr;
@@ -450,9 +447,7 @@ TypeCheckImplItem::visit (HIR::Function &function)
        }
 
       context->insert_type (self_param.get_mappings (), self_type);
-      params.push_back (
-       std::pair<HIR::Pattern *, TyTy::BaseType *> (self_pattern.get (),
-                                                    self_type));
+      params.push_back (TyTy::FnParam (std::move (self_pattern), self_type));
     }
 
   for (auto &param : function.get_function_params ())
@@ -464,8 +459,7 @@ TypeCheckImplItem::visit (HIR::Function &function)
       TypeCheckPattern::Resolve (param.get_param_name (), param_tyty);
 
       params.push_back (
-       std::pair<HIR::Pattern *, TyTy::BaseType *> (&param.get_param_name (),
-                                                    param_tyty));
+       TyTy::FnParam (param.get_param_name ().clone_pattern (), param_tyty));
     }
 
   tl::optional<CanonicalPath> canonical_path;

diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc
index e84ae333071e0a31045e91eaf5d43a690c955f64..ab684425f278a4c80c95c9458020ddbe6ce74dcf 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-item.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc
@@ -574,15 +574,15 @@ TypeCheckItem::visit (HIR::Function &function)
        function.get_return_type ().get_mappings ().get_hirid ());
     }
 
-  std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *>> params;
+  std::vector<TyTy::FnParam> params;
   for (auto &param : function.get_function_params ())
     {
       // get the name as well required for later on
       auto param_tyty = TypeCheckType::Resolve (param.get_type ());
-      params.emplace_back (&param.get_param_name (), param_tyty);
-
       context->insert_type (param.get_mappings (), param_tyty);
       TypeCheckPattern::Resolve (param.get_param_name (), param_tyty);
+      params.push_back (
+       TyTy::FnParam (param.get_param_name ().clone_pattern (), param_tyty));
     }
 
   auto path = CanonicalPath::create_empty ();

diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc
index 8e69f286d5c7c499922bcaaf0fdf7c32947b2e5e..4bcb709de754a759545cca3876a018075dae992a 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check.cc
@@ -222,9 +222,8 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const
        function.get_return_type ().get_mappings ().get_hirid ());
     }
 
-  std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *> > params;
+  std::vector<TyTy::FnParam> params;
 
-  std::unique_ptr<HIR::IdentifierPattern> self_pattern = nullptr;
   if (function.is_method ())
     {
       // these are implicit mappings and not used
@@ -238,7 +237,7 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const
       // for compilation to know parameter names. The types are ignored
       // but we reuse the HIR identifier pattern which requires it
       HIR::SelfParam &self_param = function.get_self ();
-      self_pattern
+      std::unique_ptr<HIR::Pattern> self_pattern
        = Rust::make_unique<HIR::IdentifierPattern> (HIR::IdentifierPattern (
          mapping, {"self"}, self_param.get_locus (), self_param.is_ref (),
          self_param.is_mut () ? Mutability::Mut : Mutability::Imm,
@@ -290,21 +289,18 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const
        }
 
       context->insert_type (self_param.get_mappings (), self_type);
-      params.push_back (
-       std::pair<HIR::Pattern *, TyTy::BaseType *> (self_pattern.get (),
-                                                    self_type));
+      params.push_back (TyTy::FnParam (std::move (self_pattern), self_type));
     }
 
   for (auto &param : function.get_function_params ())
     {
       // get the name as well required for later on
       auto param_tyty = TypeCheckType::Resolve (param.get_type ());
-      params.push_back (
-       std::pair<HIR::Pattern *, TyTy::BaseType *> (&param.get_param_name (),
-                                                    param_tyty));
-
       context->insert_type (param.get_mappings (), param_tyty);
       TypeCheckPattern::Resolve (param.get_param_name (), param_tyty);
+      // FIXME: Should we take the name ? Use a shared pointer instead ?
+      params.push_back (
+       TyTy::FnParam (param.get_param_name ().clone_pattern (), param_tyty));
     }
 
   auto &mappings = Analysis::Mappings::get ();
@@ -332,7 +328,7 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const
     function.get_function_name ().as_string (), ident,
     function.is_method () ? TyTy::FnType::FNTYPE_IS_METHOD_FLAG
                          : TyTy::FnType::FNTYPE_DEFAULT_FLAGS,
-    ABI::RUST, params, ret_type, substitutions,
+    ABI::RUST, std::move (params), ret_type, substitutions,
     TyTy::SubstitutionArgumentMappings::empty (
       context->get_lifetime_resolver ().get_num_bound_regions ()),
     region_constraints);

diff --git a/gcc/rust/typecheck/rust-tyty-call.cc b/gcc/rust/typecheck/rust-tyty-call.cc
index 23a4a059691ceb3ceb0aa89c2a62198d071ada60..725b8414671f9efafdb8ec355b535087d16bc6bf 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-call.cc
+++ b/gcc/rust/typecheck/rust-tyty-call.cc
@@ -152,12 +152,12 @@ TypeCheckCallExpr::visit (FnType &type)
       if (i < type.num_params ())
        {
          auto &fnparam = type.param_at (i);
-         auto &fn_param_pattern = fnparam.first;
-         BaseType *param_ty = fnparam.second;
+         auto &fn_param_pattern = fnparam.get_pattern ();
+         BaseType *param_ty = fnparam.get_type ();
          location_t param_locus
-           = fn_param_pattern == nullptr
+           = fnparam.has_pattern ()
                ? mappings.lookup_location (param_ty->get_ref ())
-               : fn_param_pattern->get_locus ();
+               : fn_param_pattern.get_locus ();
 
          HirId coercion_side_id = argument->get_mappings ().get_hirid ();
          auto resolved_argument_type
@@ -375,12 +375,12 @@ TypeCheckMethodCallExpr::check (FnType &type)
       location_t arg_locus = argument.get_locus ();
 
       auto &fnparam = type.param_at (i);
-      HIR::Pattern *fn_param_pattern = fnparam.first;
-      BaseType *param_ty = fnparam.second;
+      HIR::Pattern &fn_param_pattern = fnparam.get_pattern ();
+      BaseType *param_ty = fnparam.get_type ();
       location_t param_locus
-       = fn_param_pattern == nullptr
+       = fnparam.has_pattern ()
            ? mappings.lookup_location (param_ty->get_ref ())
-           : fn_param_pattern->get_locus ();
+           : fn_param_pattern.get_locus ();
 
       auto argument_expr_tyty = argument.get_argument_type ();
       HirId coercion_side_id = argument.get_mappings ().get_hirid ();

diff --git a/gcc/rust/typecheck/rust-tyty-cmp.h b/gcc/rust/typecheck/rust-tyty-cmp.h
index c384287e550d970b918fb9ce6b26ae617047a4b2..7088b585edaf470c6448b6083ecf43fbcb17acbf 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-cmp.h
+++ b/gcc/rust/typecheck/rust-tyty-cmp.h
@@ -735,8 +735,8 @@ public:
 
     for (size_t i = 0; i < base->num_params (); i++)
       {
-       auto a = base->param_at (i).second;
-       auto b = type.param_at (i).second;
+       auto a = base->param_at (i).get_type ();
+       auto b = type.param_at (i).get_type ();
 
        if (!a->can_eq (b, emit_error_flag))
          {
@@ -831,7 +831,7 @@ public:
     for (size_t i = 0; i < base->num_params (); i++)
       {
        auto this_param = base->get_param_type_at (i);
-       auto other_param = type.param_at (i).second;
+       auto other_param = type.param_at (i).get_type ();
        if (!this_param->can_eq (other_param, emit_error_flag))
          {
            BaseCmp::visit (type);

diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc
index 639a39bcbf937b6222258fc002a5cde14dcc6374..757cfa59f62502ce3630ee6c104769a95c2b0645 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty.cc
+++ b/gcc/rust/typecheck/rust-tyty.cc
@@ -594,10 +594,9 @@ BaseType::monomorphized_clone () const
     }
   else if (auto fn = x->try_as<const FnType> ())
     {
-      std::vector<std::pair<HIR::Pattern *, BaseType *>> cloned_params;
+      std::vector<TyTy::FnParam> cloned_params;
       for (auto &p : fn->get_params ())
-       cloned_params.push_back (std::pair<HIR::Pattern *, BaseType *> (
-         p.first, p.second->monomorphized_clone ()));
+       cloned_params.push_back (p.clone ());
 
       BaseType *retty = fn->get_return_type ()->monomorphized_clone ();
       return new FnType (fn->get_ref (), fn->get_ty_ref (), fn->get_id (),
@@ -688,7 +687,7 @@ BaseType::is_concrete () const
     {
       for (const auto &param : fn->get_params ())
        {
-         if (!param.second->is_concrete ())
+         if (!param.get_type ()->is_concrete ())
            return false;
        }
       return fn->get_return_type ()->is_concrete ();
@@ -1879,9 +1878,9 @@ FnType::as_string () const
   std::string params_str = "";
   for (auto &param : params)
     {
-      auto &pattern = param.first;
-      auto ty = param.second;
-      params_str += pattern->as_string () + " " + ty->as_string ();
+      auto &pattern = param.get_pattern ();
+      auto ty = param.get_type ();
+      params_str += pattern.as_string () + " " + ty->as_string ();
       params_str += ",";
     }
 
@@ -1902,7 +1901,7 @@ FnType::is_equal (const BaseType &other) const
   if (get_kind () != other.get_kind ())
     return false;
 
-  auto other2 = static_cast<const FnType &> (other);
+  auto &other2 = static_cast<const FnType &> (other);
   if (get_identifier ().compare (other2.get_identifier ()) != 0)
     return false;
 
@@ -1936,8 +1935,8 @@ FnType::is_equal (const BaseType &other) const
 
   for (size_t i = 0; i < num_params (); i++)
     {
-      auto lhs = param_at (i).second;
-      auto rhs = other2.param_at (i).second;
+      auto lhs = param_at (i).get_type ();
+      auto rhs = other2.param_at (i).get_type ();
       if (!lhs->is_equal (*rhs))
        return false;
     }
@@ -1947,10 +1946,9 @@ FnType::is_equal (const BaseType &other) const
 BaseType *
 FnType::clone () const
 {
-  std::vector<std::pair<HIR::Pattern *, BaseType *>> cloned_params;
+  std::vector<TyTy::FnParam> cloned_params;
   for (auto &p : params)
-    cloned_params.push_back (
-      std::pair<HIR::Pattern *, BaseType *> (p.first, p.second->clone ()));
+    cloned_params.push_back (p.clone ());
 
   return new FnType (get_ref (), get_ty_ref (), get_id (), get_identifier (),
                     ident, flags, abi, std::move (cloned_params),
@@ -2024,7 +2022,7 @@ FnType::handle_substitions (SubstitutionArgumentMappings &subst_mappings)
 
   for (auto &param : fn->get_params ())
     {
-      auto fty = param.second;
+      auto fty = param.get_type ();
 
       bool is_param_ty = fty->get_kind () == TypeKind::PARAM;
       if (is_param_ty)
@@ -2043,7 +2041,7 @@ FnType::handle_substitions (SubstitutionArgumentMappings &subst_mappings)
                {
                  auto new_field = argt->clone ();
                  new_field->set_ref (fty->get_ref ());
-                 param.second = new_field;
+                 param.set_type (new_field);
                }
              else
                {
@@ -2067,7 +2065,7 @@ FnType::handle_substitions (SubstitutionArgumentMappings &subst_mappings)
 
          auto new_field = concrete->clone ();
          new_field->set_ref (fty->get_ref ());
-         param.second = new_field;
+         param.set_type (new_field);
        }
     }
 

diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h
index f394b8d91971ab0d210dfb86aa1f67df5fe4a05d..a74f4497f0cb6d9c97bfc63a57b44f32604c1e53 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty.h
+++ b/gcc/rust/typecheck/rust-tyty.h
@@ -766,6 +766,34 @@ private:
   ReprOptions repr;
 };
 
+class FnParam
+{
+public:
+  FnParam (std::unique_ptr<HIR::Pattern> pattern, BaseType *type)
+    : pattern (std::move (pattern)), type (type)
+  {}
+
+  FnParam (const FnParam &) = delete;
+  FnParam (FnParam &&) = default;
+  FnParam &operator= (FnParam &&) = default;
+
+  HIR::Pattern &get_pattern () { return *pattern; }
+  const HIR::Pattern &get_pattern () const { return *pattern; }
+
+  bool has_pattern () { return pattern != nullptr; }
+  BaseType *get_type () const { return type; }
+  void set_type (BaseType *new_type) { type = new_type; }
+
+  FnParam clone () const
+  {
+    return FnParam (pattern->clone_pattern (), type->monomorphized_clone ());
+  }
+
+private:
+  std::unique_ptr<HIR::Pattern> pattern;
+  BaseType *type;
+};
+
 class FnType : public CallableTypeInterface, public SubstitutionRef
 {
 public:
@@ -777,25 +805,23 @@ public:
   static const uint8_t FNTYPE_IS_VARADIC_FLAG = 0X04;
 
   FnType (HirId ref, DefId id, std::string identifier, RustIdent ident,
-         uint8_t flags, ABI abi,
-         std::vector<std::pair<HIR::Pattern *, BaseType *>> params,
-         BaseType *type, std::vector<SubstitutionParamMapping> subst_refs,
+         uint8_t flags, ABI abi, std::vector<FnParam> params, BaseType *type,
+         std::vector<SubstitutionParamMapping> subst_refs,
          SubstitutionArgumentMappings substitution_argument_mappings,
          RegionConstraints region_constraints,
          std::set<HirId> refs = std::set<HirId> ())
     : CallableTypeInterface (ref, ref, TypeKind::FNDEF, ident, refs),
       SubstitutionRef (std::move (subst_refs), substitution_argument_mappings,
                       region_constraints),
-      params (params), type (type), flags (flags), identifier (identifier),
-      id (id), abi (abi)
+      params (std::move (params)), type (type), flags (flags),
+      identifier (identifier), id (id), abi (abi)
   {
     LocalDefId local_def_id = id.localDefId;
     rust_assert (local_def_id != UNKNOWN_LOCAL_DEFID);
   }
 
   FnType (HirId ref, HirId ty_ref, DefId id, std::string identifier,
-         RustIdent ident, uint8_t flags, ABI abi,
-         std::vector<std::pair<HIR::Pattern *, BaseType *>> params,
+         RustIdent ident, uint8_t flags, ABI abi, std::vector<FnParam> params,
          BaseType *type, std::vector<SubstitutionParamMapping> subst_refs,
          SubstitutionArgumentMappings substitution_argument_mappings,
          RegionConstraints region_constraints,
@@ -810,6 +836,9 @@ public:
     rust_assert (local_def_id != UNKNOWN_LOCAL_DEFID);
   }
 
+  FnType (const FnType &) = delete;
+  FnType (FnType &&) = default;
+
   void accept_vis (TyVisitor &vis) override;
   void accept_vis (TyConstVisitor &vis) const override;
 
@@ -843,28 +872,16 @@ public:
   BaseType *get_self_type () const
   {
     rust_assert (is_method ());
-    return param_at (0).second;
+    return param_at (0).get_type ();
   }
 
-  std::vector<std::pair<HIR::Pattern *, BaseType *>> &get_params ()
-  {
-    return params;
-  }
+  std::vector<FnParam> &get_params () { return params; }
 
-  const std::vector<std::pair<HIR::Pattern *, BaseType *>> &get_params () const
-  {
-    return params;
-  }
+  const std::vector<FnParam> &get_params () const { return params; }
 
-  std::pair<HIR::Pattern *, BaseType *> &param_at (size_t idx)
-  {
-    return params.at (idx);
-  }
+  FnParam &param_at (size_t idx) { return params.at (idx); }
 
-  const std::pair<HIR::Pattern *, BaseType *> &param_at (size_t idx) const
-  {
-    return params.at (idx);
-  }
+  const FnParam &param_at (size_t idx) const { return params.at (idx); }
 
   BaseType *clone () const final override;
 
@@ -881,7 +898,7 @@ public:
 
   WARN_UNUSED_RESULT BaseType *get_param_type_at (size_t index) const override
   {
-    return param_at (index).second;
+    return param_at (index).get_type ();
   }
 
   WARN_UNUSED_RESULT BaseType *get_return_type () const override
@@ -890,7 +907,7 @@ public:
   }
 
 private:
-  std::vector<std::pair<HIR::Pattern *, BaseType *>> params;
+  std::vector<FnParam> params;
   BaseType *type;
   uint8_t flags;
   std::string identifier;

diff --git a/gcc/rust/typecheck/rust-unify.cc b/gcc/rust/typecheck/rust-unify.cc
index fa2308f1b34d34571d61aae6dfb0c5d1ba5776b2..8159c7d52bbaa993d20cd3ad5f3bde1b4f8db49a 100644 (file)
--- a/gcc/rust/typecheck/rust-unify.cc
+++ b/gcc/rust/typecheck/rust-unify.cc
@@ -929,8 +929,8 @@ UnifyRules::expect_fndef (TyTy::FnType *ltype, TyTy::BaseType *rtype)
 
        for (size_t i = 0; i < ltype->num_params (); i++)
          {
-           auto a = ltype->param_at (i).second;
-           auto b = type.param_at (i).second;
+           auto a = ltype->param_at (i).get_type ();
+           auto b = type.param_at (i).get_type ();
 
            auto unified_param
              = UnifyRules::Resolve (TyTy::TyWithLocation (a),
@@ -1069,7 +1069,7 @@ UnifyRules::expect_fnptr (TyTy::FnPtr *ltype, TyTy::BaseType *rtype)
        for (size_t i = 0; i < ltype->num_params (); i++)
          {
            auto this_param = ltype->get_param_type_at (i);
-           auto other_param = type.param_at (i).second;
+           auto other_param = type.param_at (i).get_type ();
 
            auto unified_param
              = UnifyRules::Resolve (TyTy::TyWithLocation (this_param),