gccrs: Change lookup_macro_invocation's return type

Wrap the function's return type within an optional and remove the out
reference argument.

gcc/rust/ChangeLog:

	* expand/rust-macro-expand.cc (MacroExpander::expand_invoc): Adapt
	the function call to match its new prototype.
	* resolve/rust-early-name-resolver-2.0.cc (Early::insert_once):
	Likewise.
	(Early::visit): Likewise.
	* resolve/rust-early-name-resolver.cc (EarlyNameResolver::visit):
	Likewise.
	* util/rust-hir-map.cc (Mappings::lookup_macro_invocation): 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/expand/rust-macro-expand.cc b/gcc/rust/expand/rust-macro-expand.cc
index 86c6695408b92e7be9e0885dd4fd497711d5bcbf..e2ef4041effcc559c93cc971a2e65c7f8ead70b1 100644 (file)
--- a/gcc/rust/expand/rust-macro-expand.cc
+++ b/gcc/rust/expand/rust-macro-expand.cc
@@ -272,25 +272,25 @@ MacroExpander::expand_invoc (AST::MacroInvocation &invoc, bool has_semicolon)
   invoc_data.set_expander (this);
 
   // lookup the rules
-  AST::MacroRulesDefinition *rules_def = nullptr;
-  bool ok = mappings.lookup_macro_invocation (invoc, &rules_def);
+  auto rules_def = mappings.lookup_macro_invocation (invoc);
 
   // If there's no rule associated with the invocation, we can simply return
   // early. The early name resolver will have already emitted an error.
-  if (!ok)
+  if (!rules_def)
     return;
 
+  auto rdef = rules_def.value ();
+
   // We store the last expanded invocation and macro definition for error
   // reporting in case the recursion limit is reached
   last_invoc = *invoc.clone_macro_invocation_impl ();
-  last_def = *rules_def;
+  last_def = *rdef;
 
-  if (rules_def->is_builtin ())
-    fragment
-      = rules_def->get_builtin_transcriber () (invoc.get_locus (), invoc_data)
-         .value_or (AST::Fragment::create_empty ());
+  if (rdef->is_builtin ())
+    fragment = rdef->get_builtin_transcriber () (invoc.get_locus (), invoc_data)
+                .value_or (AST::Fragment::create_empty ());
   else
-    fragment = expand_decl_macro (invoc.get_locus (), invoc_data, *rules_def,
+    fragment = expand_decl_macro (invoc.get_locus (), invoc_data, *rdef,
                                  has_semicolon);
 
   set_expanded_fragment (std::move (fragment));

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 c0513931f85a44ab19a85a3c72dc0586aee09ec2..1b21e115aeeb16b86ff13af00e1beb82322727a3 100644 (file)
--- a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc
+++ b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc
@@ -32,10 +32,7 @@ Early::insert_once (AST::MacroInvocation &invocation, NodeId resolved)
   // TODO: Should we use `ctx.mark_resolved()`?
   auto definition = ctx.mappings.lookup_macro_def (resolved);
 
-  AST::MacroRulesDefinition *existing;
-  auto exists = ctx.mappings.lookup_macro_invocation (invocation, &existing);
-
-  if (!exists)
+  if (!ctx.mappings.lookup_macro_invocation (invocation))
     ctx.mappings.insert_macro_invocation (invocation, definition.value ());
 }
 
@@ -176,8 +173,7 @@ Early::visit (AST::MacroInvocation &invoc)
   if (!rules_def)
     return;
 
-  AST::MacroRulesDefinition *tmp_def = nullptr;
-  if (mappings.lookup_macro_invocation (invoc, &tmp_def))
+  if (mappings.lookup_macro_invocation (invoc))
     return;
 
   mappings.insert_macro_invocation (invoc, rules_def.value ());

diff --git a/gcc/rust/resolve/rust-early-name-resolver.cc b/gcc/rust/resolve/rust-early-name-resolver.cc
index 604b05da2b8277b26c894cc8b06ff6c9ce6ea4af..ce427ddb2c86cacc3a53765247ed59366b17b083 100644 (file)
--- a/gcc/rust/resolve/rust-early-name-resolver.cc
+++ b/gcc/rust/resolve/rust-early-name-resolver.cc
@@ -503,8 +503,7 @@ EarlyNameResolver::visit (AST::MacroInvocation &invoc)
    * 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_def = nullptr;
-  if (mappings.lookup_macro_invocation (invoc, &tmp_def))
+  if (mappings.lookup_macro_invocation (invoc))
     return;
 
   mappings.insert_macro_invocation (invoc, *rules_def);

diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc
index f6df55fdc9f1b9667384eb3112a0de7b22b8c34d..3b721198ecc5711fcd2442404953a8357d2f6aec 100644 (file)
--- a/gcc/rust/util/rust-hir-map.cc
+++ b/gcc/rust/util/rust-hir-map.cc
@@ -897,16 +897,14 @@ Mappings::insert_macro_invocation (AST::MacroInvocation &invoc,
   macroInvocations[invoc.get_macro_node_id ()] = def;
 }
 
-bool
-Mappings::lookup_macro_invocation (AST::MacroInvocation &invoc,
-                                  AST::MacroRulesDefinition **def)
+tl::optional<AST::MacroRulesDefinition *>
+Mappings::lookup_macro_invocation (AST::MacroInvocation &invoc)
 {
   auto it = macroInvocations.find (invoc.get_macro_node_id ());
   if (it == macroInvocations.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 3747804c175120a67523796a226fbc9884ee89b4..d80a15ec00cca952a0f03b8ed3fb0632f51a452f 100644 (file)
--- a/gcc/rust/util/rust-hir-map.h
+++ b/gcc/rust/util/rust-hir-map.h
@@ -282,8 +282,8 @@ public:
 
   void insert_macro_invocation (AST::MacroInvocation &invoc,
                                AST::MacroRulesDefinition *def);
-  bool lookup_macro_invocation (AST::MacroInvocation &invoc,
-                               AST::MacroRulesDefinition **def);
+  tl::optional<AST::MacroRulesDefinition *>
+  lookup_macro_invocation (AST::MacroInvocation &invoc);
 
   void insert_exported_macro (AST::MacroRulesDefinition &def);
   std::vector<NodeId> &get_exported_macros ();