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.

5 files changed, 152 insertions, 30 deletions

diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in
index 739b27d..080b9dd 100644
--- a/gcc/rust/Make-lang.in
+++ b/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 \
diff --git a/gcc/rust/hir/rust-ast-lower-base.h b/gcc/rust/hir/rust-ast-lower-base.h
index 038b6cf..9eb9300 100644
--- a/gcc/rust/hir/rust-ast-lower-base.h
+++ b/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 @@ public:
   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 @@ protected:
   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
diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc
index 45081af..8062f2f 100644
--- a/gcc/rust/hir/rust-ast-lower.cc
+++ b/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
diff --git a/gcc/rust/util/rust-attributes.cc b/gcc/rust/util/rust-attributes.cc
new file mode 100644
index 0000000..3809ad7
--- /dev/null
+++ b/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
diff --git a/gcc/rust/util/rust-attributes.h b/gcc/rust/util/rust-attributes.h
new file mode 100644
index 0000000..6c2063c7
--- /dev/null
+++ b/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