Add new Builtin attributes mappings

This class keeps track of all known builtin attributes and specifies which
pass they are handled at. This replaces the checks we added for outer
attributes during hir lowering making it a more maintainable data
structure.

Author: philberty

gcc/rust/Make-lang.in

@@ -77,6 +77,7 @@ GRS_OBJS = \
     rust/rust-macro-invoc-lexer.o \
     rust/rust-hir-full-test.o \
     rust/rust-hir-map.o \
+    rust/rust-attributes.o \
     rust/rust-abi.o \
     rust/rust-ast-lower.o \
     rust/rust-ast-lower-pattern.o \

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

@@ -24,6 +24,7 @@
 #include "rust-ast-visitor.h"
 #include "rust-hir-map.h"
 #include "rust-hir-full.h"
+#include "rust-attributes.h"
 
 namespace Rust {
 namespace HIR {
@@ -230,9 +231,13 @@ class ASTLoweringBase : public AST::ASTVisitor
   virtual void visit (AST::BareFunctionType &type) {}
 
 protected:
-  ASTLoweringBase () : mappings (Analysis::Mappings::get ()) {}
+  ASTLoweringBase ()
+    : mappings (Analysis::Mappings::get ()),
+      attr_mappings (Analysis::BuiltinAttributeMappings::get ())
+  {}
 
   Analysis::Mappings *mappings;
+  Analysis::BuiltinAttributeMappings *attr_mappings;
 
   HIR::Lifetime lower_lifetime (AST::Lifetime &lifetime)
   {
@@ -287,10 +292,10 @@ class ASTLoweringBase : public AST::ASTVisitor
   void handle_lang_item_attribute (const HIR::Item &item,
 				   const AST::Attribute &attr);
 
-  static bool is_known_attribute (const std::string &attribute_path);
+  bool is_known_attribute (const std::string &attribute_path) const;
 
-  static bool
-  attribute_handled_in_another_pass (const std::string &attribute_path);
+  bool
+  attribute_handled_in_another_pass (const std::string &attribute_path) const;
 };
 
 } // namespace HIR

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

@@ -653,39 +653,24 @@ ASTLoweringBase::handle_lang_item_attribute (const HIR::Item &item,
 }
 
 bool
-ASTLoweringBase::is_known_attribute (const std::string &attribute_path)
+ASTLoweringBase::is_known_attribute (const std::string &attribute_path) const
 {
-  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;
+  const auto &lookup = attr_mappings->lookup_builtin (attribute_path);
+  return !lookup.is_error ();
 }
 
 bool
 ASTLoweringBase::attribute_handled_in_another_pass (
-  const std::string &attribute_path)
+  const std::string &attribute_path) const
 {
-  // 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;
+  const auto &lookup = attr_mappings->lookup_builtin (attribute_path);
+  if (lookup.is_error ())
+    return false;
 
-  return false;
+  if (lookup.handler == Analysis::CompilerPass::UNKNOWN)
+    return false;
+
+  return lookup.handler != Analysis::CompilerPass::HIR_LOWERING;
 }
 
 } // namespace HIR

gcc/rust/util/rust-attributes.cc

@@ -0,0 +1,61 @@
+// Copyright (C) 2020-2022 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-attributes.h"
+
+namespace Rust {
+namespace Analysis {
+
+// https://doc.rust-lang.org/stable/nightly-rustc/src/rustc_feature/builtin_attrs.rs.html#256
+static const BuiltinAttrDefinition __definitions[] = {
+  {"inline", CODE_GENERATION}, {"cfg", EXPANSION},     {"cfg_attr", EXPANSION},
+  {"allow", STATIC_ANALYSIS},  {"lang", HIR_LOWERING},
+};
+
+BuiltinAttributeMappings *
+BuiltinAttributeMappings::get ()
+{
+  static BuiltinAttributeMappings *instance = nullptr;
+  if (instance == nullptr)
+    instance = new BuiltinAttributeMappings ();
+
+  return instance;
+}
+
+const BuiltinAttrDefinition &
+BuiltinAttributeMappings::lookup_builtin (const std::string &attr_name) const
+{
+  auto it = mappings.find (attr_name);
+  if (it == mappings.end ())
+    return BuiltinAttrDefinition::error_node ();
+
+  return it->second;
+}
+
+BuiltinAttributeMappings::BuiltinAttributeMappings ()
+{
+  size_t ndefinitions = sizeof (__definitions) / sizeof (BuiltinAttrDefinition);
+  for (size_t i = 0; i < ndefinitions; i++)
+    {
+      const BuiltinAttrDefinition &def = __definitions[i];
+      mappings.insert ({def.name, def});
+    }
+}
+
+} // namespace Analysis
+} // namespace Rust

gcc/rust/util/rust-attributes.h

@@ -0,0 +1,70 @@
+// Copyright (C) 2020-2022 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-system.h"
+
+namespace Rust {
+namespace Analysis {
+
+enum CompilerPass
+{
+  UNKNOWN,
+
+  EXPANSION,
+  NAME_RESOLUTION,
+  HIR_LOWERING,
+  TYPE_CHECK,
+  STATIC_ANALYSIS,
+  CODE_GENERATION
+};
+
+struct BuiltinAttrDefinition
+{
+  std::string name;
+  CompilerPass handler;
+
+  static BuiltinAttrDefinition get_error ()
+  {
+    return BuiltinAttrDefinition{"", UNKNOWN};
+  }
+
+  static BuiltinAttrDefinition &error_node ()
+  {
+    static BuiltinAttrDefinition error_node = get_error ();
+    return error_node;
+  }
+
+  bool is_error () const { return name.empty (); }
+};
+
+class BuiltinAttributeMappings
+{
+public:
+  static BuiltinAttributeMappings *get ();
+
+  const BuiltinAttrDefinition &
+  lookup_builtin (const std::string &attr_name) const;
+
+private:
+  BuiltinAttributeMappings ();
+
+  std::map<std::string, const BuiltinAttrDefinition> mappings;
+};
+
+} // namespace Analysis
+} // namespace Rust