[Clang] Change up algorithm

Author: chinmaydd

clang/include/clang/Basic/AttributeCommonInfo.h

@@ -67,16 +67,7 @@ class AttributeCommonInfo {
     IgnoredAttribute,
     UnknownAttribute,
   };
-  enum Scope {
-    SC_NONE,
-    SC_CLANG,
-    SC_GNU,
-    SC_MSVC,
-    SC_OMP,
-    SC_HLSL,
-    SC_GSL,
-    SC_RISCV
-  };
+  enum class Scope { NONE, CLANG, GNU, MSVC, OMP, HLSL, GSL, RISCV };
 
 private:
   const IdentifierInfo *AttrName = nullptr;

clang/lib/Basic/Attributes.cpp

@@ -17,6 +17,8 @@
 #include "clang/Basic/ParsedAttrInfo.h"
 #include "clang/Basic/TargetInfo.h"
 
+#include "llvm/ADT/StringMap.h"
+
 using namespace clang;
 
 static int hasAttributeImpl(AttributeCommonInfo::Syntax Syntax, StringRef Name,
@@ -153,18 +155,18 @@ std::string AttributeCommonInfo::getNormalizedFullName() const {
       normalizeName(getAttrName(), getScopeName(), getSyntax()));
 }
 
-const std::map<StringRef, AttributeCommonInfo::Scope> ScopeMap = {
-    {"", AttributeCommonInfo::SC_NONE},
-    {"clang", AttributeCommonInfo::SC_CLANG},
-    {"gnu", AttributeCommonInfo::SC_GNU},
-    {"msvc", AttributeCommonInfo::SC_MSVC},
-    {"omp", AttributeCommonInfo::SC_OMP},
-    {"hlsl", AttributeCommonInfo::SC_HLSL},
-    {"gsl", AttributeCommonInfo::SC_GSL},
-    {"riscv", AttributeCommonInfo::SC_RISCV}};
+const llvm::StringMap<AttributeCommonInfo::Scope> ScopeMap = {
+    {"", AttributeCommonInfo::Scope::NONE},
+    {"clang", AttributeCommonInfo::Scope::CLANG},
+    {"gnu", AttributeCommonInfo::Scope::GNU},
+    {"msvc", AttributeCommonInfo::Scope::MSVC},
+    {"omp", AttributeCommonInfo::Scope::OMP},
+    {"hlsl", AttributeCommonInfo::Scope::HLSL},
+    {"gsl", AttributeCommonInfo::Scope::GSL},
+    {"riscv", AttributeCommonInfo::Scope::RISCV}};
 
 AttributeCommonInfo::Scope
-getScopeFromNormalizedScopeName(const StringRef ScopeName) {
+getScopeFromNormalizedScopeName(StringRef ScopeName) {
   auto It = ScopeMap.find(ScopeName);
   if (It == ScopeMap.end()) {
     llvm_unreachable("Unknown normalized scope name. Shouldn't get here");

clang/utils/TableGen/ClangAttrEmitter.cpp

@@ -3854,91 +3854,55 @@ void EmitClangAttrSpellingListIndex(const RecordKeeper &Records,
       continue;
     }
 
-    bool HasSingleUniqueSpellingName = true;
-    StringMap<std::vector<const FlattenedSpelling *>> SpellingMap;
-
-    StringRef FirstName = Spellings.front().name();
-    for (const auto &S : Spellings) {
-      StringRef Name = S.name();
-      if (Name != FirstName)
-        HasSingleUniqueSpellingName = false;
-      SpellingMap[Name].push_back(&S);
-    }
-
-    // If parsed attribute has only one possible spelling name, only compare
-    // syntax and scope.
-    if (HasSingleUniqueSpellingName) {
-      for (const auto &[Idx, S] : enumerate(SpellingMap[FirstName])) {
-        OS << "    if (getSyntax() == AttributeCommonInfo::AS_" << S->variety()
+    std::vector<StringRef> Names;
+    llvm::transform(Spellings, std::back_inserter(Names),
+                    [](const FlattenedSpelling &FS) { return FS.name(); });
+    llvm::sort(Names);
+    Names.erase(llvm::unique(Names), Names.end());
+
+    for (const auto &[Idx, FS] : enumerate(Spellings)) {
+      if (Names.size() == 1) {
+        OS << "    if (getSyntax() == AttributeCommonInfo::AS_" << FS.variety()
            << " && ComputedScope == ";
 
-        if (S->nameSpace() == "")
-          OS << "AttributeCommonInfo::SC_NONE";
+        if (FS.nameSpace() == "")
+          OS << "AttributeCommonInfo::Scope::NONE";
         else
-          OS << "AttributeCommonInfo::SC_" + S->nameSpace().upper();
+          OS << "AttributeCommonInfo::Scope::" + FS.nameSpace().upper();
 
         OS << ")\n"
            << "      return " << Idx << ";\n";
-      }
-    } else {
-      size_t Idx = 0;
-      StringMap<bool> Completed;
-      for (const auto &Spell : Spellings) {
-        if (Completed.contains(Spell.name()))
-          continue;
+      } else {
+        SmallVector<StringRef, 6> SameLenNames;
+        llvm::copy_if(
+            Names, std::back_inserter(SameLenNames),
+            [&](StringRef N) { return N.size() == FS.name().size(); });
+
+        if (SameLenNames.size() == 1) {
+          OS << "    if (Name.size() == " << FS.name().size()
+             << " && getSyntax() == AttributeCommonInfo::AS_" << FS.variety()
+             << " && ComputedScope == ";
 
-        const std::vector<const FlattenedSpelling *> &Cases =
-            SpellingMap[Spell.name()];
-
-        if (Cases.size() > 1) {
-          // For names with multiple possible cases, emit an enclosing if such
-          // that the name is compared against only once. Eg:
-          //
-          // if (Name == "always_inline") {
-          //   if (getSyntax() == AttributeCommonInfo::AS_GNU &&
-          //       ComputedScope == AttributeCommonInfo::SC_None)
-          //     return 0;
-          //   ...
-          // }
-          OS << "    if (Name == \"" << Spell.name() << "\") {\n";
-          for (const auto &S : SpellingMap[Spell.name()]) {
-            OS << "      if (getSyntax() == AttributeCommonInfo::AS_"
-               << S->variety() << " && ComputedScope == ";
-
-            if (S->nameSpace() == "")
-              OS << "AttributeCommonInfo::SC_NONE";
-            else
-              OS << "AttributeCommonInfo::SC_" + S->nameSpace().upper();
-
-            OS << ")\n"
-               << "        return " << Idx << ";\n";
-            Idx++;
-          }
-          OS << "    }\n";
+          if (FS.nameSpace() == "")
+            OS << "AttributeCommonInfo::Scope::NONE";
+          else
+            OS << "AttributeCommonInfo::Scope::" + FS.nameSpace().upper();
+
+          OS << ")\n"
+             << "      return " << Idx << ";\n";
         } else {
-          // If there is only possible case for the spelling name, no need of
-          // enclosing if. Eg.
-          //
-          // if (Name == "__forceinline" &&
-          //     getSyntax() == AttributeCommonInfo::AS_Keyword
-          //     && ComputedScope == AttributeCommonInfo::SC_NONE)
-          //   return 5;
-          const FlattenedSpelling *S = Cases.front();
-          OS << "    if (Name == \"" << Spell.name() << "\""
-             << " && getSyntax() == AttributeCommonInfo::AS_" << S->variety()
+          OS << "    if (Name == \"" << FS.name() << "\""
+             << " && getSyntax() == AttributeCommonInfo::AS_" << FS.variety()
              << " && ComputedScope == ";
 
-          std::string ScopeStr = "AttributeCommonInfo::SC_";
-          if (S->nameSpace() == "")
-            OS << "AttributeCommonInfo::SC_NONE";
+          if (FS.nameSpace() == "")
+            OS << "AttributeCommonInfo::Scope::NONE";
           else
-            OS << "AttributeCommonInfo::SC_" + S->nameSpace().upper();
+            OS << "AttributeCommonInfo::Scope::" + FS.nameSpace().upper();
 
           OS << ")\n"
-             << "        return " << Idx << ";\n";
-          Idx++;
+             << "      return " << Idx << ";\n";
         }
-        Completed[Spell.name()] = true;
       }
     }