Change lookup_macro_def return type

Wrap the function's return type within an optional.

gcc/rust/ChangeLog:

	* resolve/rust-early-name-resolver-2.0.cc (Early::insert_once): Change
	call site to accomodate the new return type.
	(Early::visit): Likewise.
	* resolve/rust-early-name-resolver.cc (EarlyNameResolver::visit):
	Likewise.
	* resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit):
	Likewise.
	* util/rust-hir-map.cc (Mappings::lookup_macro_def): Change the
	function's return type.
	* util/rust-hir-map.h: Update the function's prototype.

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

diff --git a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc
index 8af4b02467928e18e0e8676bce6f25d59e3a4e6b..473cdc4e317e95fe7cad31ffbbafac0049ea4653 100644 (file)
--- a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc
+++ b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc
@@ -30,26 +30,20 @@ void
 Early::insert_once (AST::MacroInvocation &invocation, NodeId resolved)
 {
   // TODO: Should we use `ctx.mark_resolved()`?
-  AST::MacroRulesDefinition *definition;
-  auto ok = ctx.mappings.lookup_macro_def (resolved, &definition);
-
-  rust_assert (ok);
+  auto definition = ctx.mappings.lookup_macro_def (resolved);
 
   AST::MacroRulesDefinition *existing;
   auto exists = ctx.mappings.lookup_macro_invocation (invocation, &existing);
 
   if (!exists)
-    ctx.mappings.insert_macro_invocation (invocation, definition);
+    ctx.mappings.insert_macro_invocation (invocation, definition.value ());
 }
 
 void
 Early::insert_once (AST::MacroRulesDefinition &def)
 {
   // TODO: Should we use `ctx.mark_resolved()`?
-  AST::MacroRulesDefinition *definition;
-  auto exists = ctx.mappings.lookup_macro_def (def.get_node_id (), &definition);
-
-  if (!exists)
+  if (!ctx.mappings.lookup_macro_def (def.get_node_id ()))
     ctx.mappings.insert_macro_def (&def);
 }
 
@@ -176,18 +170,17 @@ Early::visit (AST::MacroInvocation &invoc)
   // now do we need to keep mappings or something? or insert "uses" into our
   // ForeverStack? can we do that? are mappings simpler?
   auto &mappings = Analysis::Mappings::get ();
-  AST::MacroRulesDefinition *rules_def = nullptr;
-  if (!mappings.lookup_macro_def (definition->get_node_id (), &rules_def))
-    {
-      // Macro definition not found, maybe it is not expanded yet.
-      return;
-    }
+  auto rules_def = mappings.lookup_macro_def (definition->get_node_id ());
+
+  // Macro definition not found, maybe it is not expanded yet.
+  if (!rules_def)
+    return;
 
   AST::MacroRulesDefinition *tmp_def = nullptr;
   if (mappings.lookup_macro_invocation (invoc, &tmp_def))
     return;
 
-  mappings.insert_macro_invocation (invoc, rules_def);
+  mappings.insert_macro_invocation (invoc, rules_def.value ());
 }
 
 void

diff --git a/gcc/rust/resolve/rust-early-name-resolver.cc b/gcc/rust/resolve/rust-early-name-resolver.cc
index 83b6576fe69af832a9f2515cab2e797dc3ce9887..4021f5d5612914ecde17b76f7dbde5767cc2a106 100644 (file)
--- a/gcc/rust/resolve/rust-early-name-resolver.cc
+++ b/gcc/rust/resolve/rust-early-name-resolver.cc
@@ -425,8 +425,7 @@ EarlyNameResolver::visit (AST::MacroRulesDefinition &rules_def)
    * we could be inserting the same macro def over and over again until we
    * implement some optimizations */
   // FIXME: ARTHUR: Remove that lookup and add proper optimizations instead
-  AST::MacroRulesDefinition *tmp = nullptr;
-  if (mappings.lookup_macro_def (rules_def.get_node_id (), &tmp))
+  if (mappings.lookup_macro_def (rules_def.get_node_id ()))
     return;
 
   mappings.insert_macro_def (&rules_def);
@@ -481,11 +480,9 @@ EarlyNameResolver::visit (AST::MacroInvocation &invoc)
     }
 
   // lookup the rules
-  AST::MacroRulesDefinition *rules_def = nullptr;
-  bool ok = mappings.lookup_macro_def (resolved_node, &rules_def);
-  rust_assert (ok);
+  auto rules_def = mappings.lookup_macro_def (resolved_node);
 
-  auto &outer_attrs = rules_def->get_outer_attrs ();
+  auto &outer_attrs = rules_def.value ()->get_outer_attrs ();
   bool is_builtin
     = std::any_of (outer_attrs.begin (), outer_attrs.end (),
                   [] (AST::Attribute attr) {
@@ -495,12 +492,12 @@ EarlyNameResolver::visit (AST::MacroInvocation &invoc)
 
   if (is_builtin)
     {
-      auto builtin_kind
-       = builtin_macro_from_string (rules_def->get_rule_name ().as_string ());
+      auto builtin_kind = builtin_macro_from_string (
+       rules_def.value ()->get_rule_name ().as_string ());
       invoc.map_to_builtin (builtin_kind.value ());
     }
 
-  auto attributes = rules_def->get_outer_attrs ();
+  auto attributes = rules_def.value ()->get_outer_attrs ();
 
   /* Since the EarlyNameResolver runs multiple time (fixed point algorithm)
    * we could be inserting the same macro def over and over again until we
@@ -510,7 +507,7 @@ EarlyNameResolver::visit (AST::MacroInvocation &invoc)
   if (mappings.lookup_macro_invocation (invoc, &tmp_def))
     return;
 
-  mappings.insert_macro_invocation (invoc, rules_def);
+  mappings.insert_macro_invocation (invoc, *rules_def);
 }
 
 // FIXME: ARTHUR: Do we need to resolve these as well here?

diff --git a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc
index 7bcebba9fb47175d8c1483484605aea20268f2c6..b991145c4d4afc5e5ecfd0f47e716bfd86a62dfe 100644 (file)
--- a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc
+++ b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc
@@ -307,8 +307,7 @@ TopLevel::visit (AST::MacroRulesDefinition &macro)
     insert_or_error_out (macro.get_rule_name (), macro, Namespace::Macros);
 
   auto &mappings = Analysis::Mappings::get ();
-  AST::MacroRulesDefinition *tmp = nullptr;
-  if (mappings.lookup_macro_def (macro.get_node_id (), &tmp))
+  if (mappings.lookup_macro_def (macro.get_node_id ()))
     return;
 
   mappings.insert_macro_def (&macro);

diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc
index c0d9a65d393f870b934457cf7e9ffe1fce8469d1..5d46fc49af271ce4e076c9e50858a3417011054d 100644 (file)
--- a/gcc/rust/util/rust-hir-map.cc
+++ b/gcc/rust/util/rust-hir-map.cc
@@ -877,15 +877,14 @@ Mappings::insert_macro_def (AST::MacroRulesDefinition *macro)
   macroMappings[macro->get_node_id ()] = macro;
 }
 
-bool
-Mappings::lookup_macro_def (NodeId id, AST::MacroRulesDefinition **def)
+tl::optional<AST::MacroRulesDefinition *>
+Mappings::lookup_macro_def (NodeId id)
 {
   auto it = macroMappings.find (id);
   if (it == macroMappings.end ())
-    return false;
+    return tl::nullopt;
 
-  *def = it->second;
-  return true;
+  return it->second;
 }
 
 void

diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h
index a912ca878f7b9cced29784fceb8b4db30388fcd7..aff787db7cbd50b8cc78a2e99d9b108a04344dd8 100644 (file)
--- a/gcc/rust/util/rust-hir-map.h
+++ b/gcc/rust/util/rust-hir-map.h
@@ -278,7 +278,7 @@ public:
 
   void insert_macro_def (AST::MacroRulesDefinition *macro);
 
-  bool lookup_macro_def (NodeId id, AST::MacroRulesDefinition **def);
+  tl::optional<AST::MacroRulesDefinition *> lookup_macro_def (NodeId id);
 
   void insert_macro_invocation (AST::MacroInvocation &invoc,
                                AST::MacroRulesDefinition *def);