Refactor mapping any lang items to be done during HIR lowering

This extracts a common way of handling outer attributes on Items to improve
error handling and make lang item mappings more generic.

Author: philberty

gcc/rust/hir/rust-ast-lower-base.h

@@ -281,6 +281,16 @@ class ASTLoweringBase : public AST::ASTVisitor
 
   HIR::FunctionQualifiers
   lower_qualifiers (const AST::FunctionQualifiers &qualifiers);
+
+  void handle_outer_attributes (const HIR::Item &item);
+
+  void handle_lang_item_attribute (const HIR::Item &item,
+				   const AST::Attribute &attr);
+
+  static bool is_known_attribute (const std::string &attribute_path);
+
+  static bool
+  attribute_handled_in_another_pass (const std::string &attribute_path);
 };
 
 } // namespace HIR

gcc/rust/hir/rust-ast-lower-item.h

@@ -44,6 +44,10 @@ class ASTLoweringItem : public ASTLoweringBase
   {
     ASTLoweringItem resolver;
     item->accept_vis (resolver);
+
+    if (resolver.translated != nullptr)
+      resolver.handle_outer_attributes (*resolver.translated);
+
     return resolver.translated;
   }
 

gcc/rust/hir/rust-ast-lower.cc

@@ -609,5 +609,84 @@ ASTLoweringBase::lower_qualifiers (const AST::FunctionQualifiers &qualifiers)
 				  has_extern, extern_abi);
 }
 
+void
+ASTLoweringBase::handle_outer_attributes (const HIR::Item &item)
+{
+  for (const auto &attr : item.get_outer_attrs ())
+    {
+      const auto &str_path = attr.get_path ().as_string ();
+      if (!is_known_attribute (str_path))
+	{
+	  rust_error_at (attr.get_locus (), "unknown attribute");
+	  continue;
+	}
+
+      bool is_lang_item = str_path.compare ("lang") == 0
+			  && attr.has_attr_input ()
+			  && attr.get_attr_input ().get_attr_input_type ()
+			       == AST::AttrInput::AttrInputType::LITERAL;
+
+      if (is_lang_item)
+	handle_lang_item_attribute (item, attr);
+      else if (!attribute_handled_in_another_pass (str_path))
+	{
+	  rust_error_at (attr.get_locus (), "unhandled attribute: [%s]",
+			 attr.get_path ().as_string ().c_str ());
+	}
+    }
+}
+
+void
+ASTLoweringBase::handle_lang_item_attribute (const HIR::Item &item,
+					     const AST::Attribute &attr)
+{
+  auto &literal = static_cast<AST::AttrInputLiteral &> (attr.get_attr_input ());
+  const auto &lang_item_type_str = literal.get_literal ().as_string ();
+  auto lang_item_type = Analysis::RustLangItem::Parse (lang_item_type_str);
+  if (lang_item_type == Analysis::RustLangItem::ItemType::UNKNOWN)
+    {
+      rust_error_at (attr.get_locus (), "unknown lang item");
+      return;
+    }
+  mappings->insert_lang_item (lang_item_type,
+			      item.get_mappings ().get_defid ());
+}
+
+bool
+ASTLoweringBase::is_known_attribute (const std::string &attribute_path)
+{
+  if (attribute_path.compare ("inline") == 0)
+    return true;
+  else if (attribute_path.compare ("cfg") == 0)
+    return true;
+  else if (attribute_path.compare ("cfg_attr") == 0)
+    return true;
+  else if (attribute_path.compare ("allow") == 0)
+    return true;
+  else if (attribute_path.compare ("lang") == 0)
+    return true;
+
+  return false;
+}
+
+bool
+ASTLoweringBase::attribute_handled_in_another_pass (
+  const std::string &attribute_path)
+{
+  // handled during code-generation
+  if (attribute_path.compare ("inline") == 0)
+    return true;
+
+  // handled during previous expansion pass
+  else if (attribute_path.compare ("cfg") == 0)
+    return true;
+  else if (attribute_path.compare ("cfg_attr") == 0)
+    return true;
+  else if (attribute_path.compare ("allow") == 0)
+    return true;
+
+  return false;
+}
+
 } // namespace HIR
 } // namespace Rust

gcc/rust/typecheck/rust-hir-trait-resolve.h

@@ -207,31 +207,6 @@ class TraitResolver : public TypeCheckBase
     // loop of trying to resolve traits as required by the types
     tref->on_resolved ();
 
-    // does this have any lang-item attributes?
-    for (auto &attr : trait_reference->get_outer_attrs ())
-      {
-	bool is_lang_item = attr.get_path ().as_string ().compare ("lang") == 0
-			    && attr.has_attr_input ()
-			    && attr.get_attr_input ().get_attr_input_type ()
-				 == AST::AttrInput::AttrInputType::LITERAL;
-	if (is_lang_item)
-	  {
-	    auto &literal
-	      = static_cast<AST::AttrInputLiteral &> (attr.get_attr_input ());
-	    const auto &lang_item_type_str
-	      = literal.get_literal ().as_string ();
-	    auto lang_item_type
-	      = Analysis::RustLangItem::Parse (lang_item_type_str);
-	    if (lang_item_type == Analysis::RustLangItem::ItemType::UNKNOWN)
-	      {
-		rust_error_at (attr.get_locus (), "unknown lang item");
-		return tref;
-	      }
-	    mappings->insert_lang_item (
-	      lang_item_type, trait_reference->get_mappings ().get_defid ());
-	  }
-      }
-
     return tref;
   }