Add new warning knob for unknown attribute namespaces

[aaron.ballman]

Summary

Being noisy when ignoring unknown attributes is important because it can be very difficult for a user to tell the difference between silently ignoring an attribute and accepting an attribute that doesn't have observable semantics for a particular compiland. However, there are times when the user has a code base with vendor-scoped attributes the implementation doesn't support -- for instance, a static analyzer may add a bunch of [[analyzer::attr]] attributes that Clang doesn't know about.

To support this scenario, this patch allows you to ignore unknown attributes only when the attribute is a scoped attribute in a namespace for which Clang does not support any attributes. It is expected to be used as -Wno-unknown-attributes -Wunknown-attribute-namespaces so that unknown attribute warnings are disabled except for unknown attributes in unknown namespaces. Note that attributes in the standards namespace are considered to always be known to Clang and thus will still be warned on even when passing -Wunknown-attribute-namespaces this way. e.g.,

[[gnu::unknown]] int I; // Still diagnosed because we support other attributes in the gnu namespace.
[[unknown::unknown]] int J; // Is not diagnosed because we do not support any attributes in the unknown namespace.
[[unknown]] int K; // Still diagnosed because Clang should know about all attributes in the global attribute namespace.

If there is a better way to surface the warning flags, I'm happy to explore it.

[Meinersbur]

Thanks for coming up with this patch.

I am not sure whether this solves the original feature requester's problem entirely. It assumes that clang supports all attributes of the std and gnu namespaces. That is, the warning for [[gnu::future_gcc_extension]] cannot be disabled without also disabling the warning for [[gnu::missspelled]].

[aaron.ballman]

In D60872#1471961, @Meinersbur wrote:

Thanks for coming up with this patch.

I am not sure whether this solves the original feature requester's problem entirely. It assumes that clang supports all attributes of the std and gnu namespaces. That is, the warning for [[gnu::future_gcc_extension]] cannot be disabled without also disabling the warning for [[gnu::missspelled]].

Correct -- it was not intended to support the original requester's problem entirely, on purpose (and the OP said this was okay for their needs). We want to diagnose unknown attributes in vendor namespaces we support because otherwise the user cannot tell the difference between [[gnu::we_support_this]] and [[gnu::we_dont_support_this]] without considerable effort. That confusion is significantly reduced when we don't support an entire vendor namespace and there are compelling use cases for that situation (such as static analysis vendors introducing attributes to control the analyzer). If you need per-attribute control, you should use the preprocessor with __has_cpp_attribute.

[dblaikie]

lib/Sema/SemaDeclAttr.cpp

8623

I think most other uses of .inc files only #define the macros they need to - assuming the others aren't defined, rather than explicitly providing an empty definition? (but I'm not sure - I guess that means teh .inc file needs a #ifndef X \ #define X #endif - but perhaps .inc files usually have those?)

8623–8624

Not sure how it's done elsewhere - but I'd sink these #defines down to immediately before the #include

8629–8630

Should AttrList.inc handle undefing all its attributes - so all its users don't have to?

utils/TableGen/ClangAttrEmitter.cpp

2553

Maybe "addAttrNamespacesTo" (not clear whether this would overwrite the contens of the std::set, or add to it)

[aaron.ballman]

lib/Sema/SemaDeclAttr.cpp

8623

This file is generated without a default for ATTR, so there are a few places where we have to define it to an empty macro. I could add it to the emitter and remove a few of these spurious definitions, but that can be done in a follow-up.

8623–8624

I think it's pretty awkward either way, so I'll go with your approach.

8629–8630

Good catch -- it already does that for me. I'll remove.

utils/TableGen/ClangAttrEmitter.cpp

2553

Good catch, I missed renaming it after a signature change where it was accepting an iterator instead of the container directly.

[aaron.ballman]

Updated based on review feedback.

[dblaikie]

Seems pretty good to me - if you'd like to wait for more/other feedback from @rsmith or the like, that's OK too.

[rsmith]

Hmm. So there are a few different situations where we might meet an unknown attribute (I'm sure I missed some):

1. The attribute had a typo in it (eg: [[clagn::fallthrough]]).
2. The attribute has semantic effects (ignoring it is incorrect and will -- at best -- not compile or -- at worst -- generate a subtly broken program, eg: [[gnu::aligned]] or [[gnu::target]]).
3. The attribute has important effects (ignoring it is probably correct but suboptimal in some way, eg: [[no_unique_address]], [[gnu::packed]], ...).
4. The attribute has unimportant effects (is entirely safely ignorable) or is only intended to affect the behavior of a different tool (eg: gsl, static analyzer, clang-tidy, etc).

I think the ideal would be to warn on unknown attributes in cases 1 and 2, optionally warn on unknown attributes in case 3, and to not warn in case 4. Without user hints, we can't tell which is which in general.

"Do not warn on unknown namespaces" gives us some part of not warning on case 4. However, it also turns off warnings in cases 1-3 (eg, we won't warn on [[gcc::noinline]] as a typo for [[gnu::noinline]]), and doesn't turn off warnings for case-4 attributes in, say, namespace gnu, so it's somewhat imperfect. I think it's also going to be surprising that the clang release that starts parsing a [[gsl::*]] attribute also starts warning on other ("unknown") [[gsl::*]] attributes for people in this new mode.

It seems to me that we can achieve the ideal (don't warn on safely-ignorable unknown attributes, but warn on all other unknown attributes) if we ask the user to give us a list of safely-ignorable attributes and attribute namespaces that they intend to use. (That even lets us do typo-correction for attributes we don't support.) In the cfe-dev thread, there was mention that there are hundreds of attributes supported by clang, and so hundreds of attributes would need to be listed, but that doesn't follow: you only need to list the attributes that you actually intend to use. That should be a much smaller list (especially once modules adoption picks up, and you don't need to list those attributes used by your dependencies).

[aaron.ballman]

In D60872#1473205, @rsmith wrote:

Hmm. So there are a few different situations where we might meet an unknown attribute (I'm sure I missed some):

1. The attribute had a typo in it (eg: [[clagn::fallthrough]]).
2. The attribute has semantic effects (ignoring it is incorrect and will -- at best -- not compile or -- at worst -- generate a subtly broken program, eg: [[gnu::aligned]] or [[gnu::target]]).
3. The attribute has important effects (ignoring it is probably correct but suboptimal in some way, eg: [[no_unique_address]], [[gnu::packed]], ...).
4. The attribute has unimportant effects (is entirely safely ignorable) or is only intended to affect the behavior of a different tool (eg: gsl, static analyzer, clang-tidy, etc).

I think the ideal would be to warn on unknown attributes in cases 1 and 2, optionally warn on unknown attributes in case 3, and to not warn in case 4. Without user hints, we can't tell which is which in general.

"Do not warn on unknown namespaces" gives us some part of not warning on case 4. However, it also turns off warnings in cases 1-3 (eg, we won't warn on [[gcc::noinline]] as a typo for [[gnu::noinline]]),

Disabling warnings sometimes means you lose out on good information. It's a good point to keep in mind, but at the same time, it's also the point to the diagnostic to not warn on attributes in unknown namespaces, so the behavior doesn't seem all that surprising to me.

and doesn't turn off warnings for case-4 attributes in, say, namespace gnu, so it's somewhat imperfect. I think it's also going to be surprising that the clang release that starts parsing a [[gsl::*]] attribute also starts warning on other ("unknown") [[gsl::*]] attributes for people in this new mode.

It seems to me that we can achieve the ideal (don't warn on safely-ignorable unknown attributes, but warn on all other unknown attributes) if we ask the user to give us a list of safely-ignorable attributes and attribute namespaces that they intend to use. (That even lets us do typo-correction for attributes we don't support.) In the cfe-dev thread, there was mention that there are hundreds of attributes supported by clang, and so hundreds of attributes would need to be listed, but that doesn't follow: you only need to list the attributes that you actually intend to use. That should be a much smaller list (especially once modules adoption picks up, and you don't need to list those attributes used by your dependencies).

I am pretty strongly opposed to having the user specify the list of attributes on the command line. We spend a lot of time worrying about users who cannot spell, so giving them another place to make typos (but one that pushes them towards needing more advanced build strategies like response files) seems counter-intuitive. We also would have to solve some interesting issues like the user specifying "foo_attr" on the command line, using __attribute__((foo_attr)) in code and having it warned on as an unknown attribute because we happen to know about __declspec(foo_attr) but not the __attribute__((foo_attr)) spelling, etc.

I think am coming at this from a different angle -- the user's code is compiled with 1 compiler (Clang) vs N compilers (including Clang). For a user who is using N compilers, they should be using the preprocessor to solve this issue. This is the longstanding status quo solution and is the reason we standardized __has_cpp_attribute and friends, and I'm not strongly motivated to maintain an additional solution that pushes the issue into the build system for only one of their N compilers because the user will still have to come up with ad hoc solutions for the other N - 1 compilers, so this doesn't seem like it gets them much (compared to the macro approach, which can work for all compilers). What I am strongly motivated to support are users who are using Clang as their only compiler. These users have no reason to need the macro boilerplate, except for 3rd party tooling that is entirely unknown to Clang (static analyzers being a primary source). Given that well-behaved 3rd party tools should only be introducing attributes in their own vendor namespace (a namespace Clang is unlikely to know anything about), and we have no reason to believe 3rd parties won't come up with numerous attributes the user may want to use, it seems very useful to allow users to inhibit the unknown attribute warnings for those vendor namespaces without making the user maintain a separate, manual list of attributes in the build system. I also don't see Clang introducing attributes from those vendor namespaces with any frequency, so that's why I'm not too worried about upgrades introducing new warnings.

test/SemaCXX/attr-cxx0x.cpp

64–67

This logic is backwards. We want to suppress the warning in this case, not issue it. :-)

72

This is the case we wanted warned on.

include/clang/Basic/DiagnosticCommonKinds.td

 
 // OpenCL Section 6.8.g
 def err_opencl_unknown_type_specifier : Error<
   "OpenCL %select{C|C++}0 version %1 does not support the '%2' "
   "%select{type qualifier|storage class specifier}3">;
 
 def warn_unknown_attribute_ignored : Warning<
   "unknown attribute %0 ignored">, InGroup<UnknownAttributes>;
+def warn_unknown_attribute_namespace_ignored : Warning<
+  warn_unknown_attribute_ignored.Text>, InGroup<UnknownAttributeNamespaces>;
+
 def err_use_of_tag_name_without_tag : Error<
   "must use '%1' tag to refer to type %0%select{| in this scope}2">;
 
 def duplicate_declspec : TextSubstitution<
   "duplicate '%0' declaration specifier">;
 
 def ext_duplicate_declspec : Extension<"%sub{duplicate_declspec}0">,
   InGroup<DuplicateDeclSpecifier>;

include/clang/Basic/DiagnosticGroups.td

 def Pragmas : DiagGroup<"pragmas", [UnknownPragmas, IgnoredPragmas,
                                     PragmaClangAttribute, PragmaPack]>;
 def UnknownWarningOption : DiagGroup<"unknown-warning-option">;
 def NSobjectAttribute : DiagGroup<"NSObject-attribute">;
 def NSConsumedMismatch : DiagGroup<"nsconsumed-mismatch">;
 def NSReturnsMismatch : DiagGroup<"nsreturns-mismatch">;
 
 def IndependentClassAttribute : DiagGroup<"IndependentClass-attribute">;
-def UnknownAttributes : DiagGroup<"unknown-attributes">;
+def UnknownAttributeNamespaces : DiagGroup<"unknown-attribute-namespaces">;
+def UnknownAttributes
+    : DiagGroup<"unknown-attributes", [UnknownAttributeNamespaces]>;
 def IgnoredAttributes : DiagGroup<"ignored-attributes">;
 def Attributes : DiagGroup<"attributes", [UnknownAttributes,
                                           IgnoredAttributes]>;
 def UnknownSanitizers : DiagGroup<"unknown-sanitizers">;
 def UnnamedTypeTemplateArgs : DiagGroup<"unnamed-type-template-args",
                                         [CXX98CompatUnnamedTypeTemplateArgs]>;
 def UnsupportedFriend : DiagGroup<"unsupported-friend">;
 def UnusedArgument : DiagGroup<"unused-argument">;

include/clang/Sema/Sema.h

   ///
   /// Argument-independent diagnose_if attributes should be checked on every use
   /// of a function.
   ///
   /// Returns true if any errors were emitted.
   bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
                                              SourceLocation Loc);
 
+  /// Emits a diagnostic about an attribute that is unknown.
+  void diagnoseUnknownAttribute(const ParsedAttr &A);
+
+
   /// Returns whether the given function's address can be taken or not,
   /// optionally emitting a diagnostic if the address can't be taken.
   ///
   /// Returns false if taking the address of the function is illegal.
   bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
                                          bool Complain = false,
                                          SourceLocation Loc = SourceLocation());
 

lib/Parse/ParseDecl.cpp

 }
 
 void Parser::ProhibitCXX11Attributes(ParsedAttributesWithRange &Attrs,
                                      unsigned DiagID) {
   for (const ParsedAttr &AL : Attrs) {
     if (!AL.isCXX11Attribute() && !AL.isC2xAttribute())
       continue;
     if (AL.getKind() == ParsedAttr::UnknownAttribute)
-      Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) << AL.getName();
+      Actions.diagnoseUnknownAttribute(AL);
     else {
       Diag(AL.getLoc(), DiagID) << AL.getName();
       AL.setInvalid();
     }
   }
 }
 
 // Usually, `__attribute__((attrib)) class Foo {} var` means that attribute

lib/Sema/SemaDeclAttr.cpp

 #include "clang/Sema/DelayedDiagnostic.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace clang;
 using namespace sema;
 
 namespace AttributeLangSupport {
   enum LANG {
     C,

   }
 
   return false;
 }
 
 bool Sema::CheckAttrTarget(const ParsedAttr &AL) {
   // Check whether the attribute is valid on the current target.
   if (!AL.existsInTarget(Context.getTargetInfo())) {
-    Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) << AL;
+    diagnoseUnknownAttribute(AL);
     AL.setInvalid();
     return true;
   }
 
   return false;
 }
 
 static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {

   if (AL.isCXX11Attribute() && !IncludeCXX11Attributes)
     return;
 
   // Unknown attributes are automatically warned on. Target-specific attributes
   // which do not apply to the current target architecture are treated as
   // though they were unknown attributes.
   if (AL.getKind() == ParsedAttr::UnknownAttribute ||
       !AL.existsInTarget(S.Context.getTargetInfo())) {
-    S.Diag(AL.getLoc(),
-           AL.isDeclspecAttribute()
-               ? (unsigned)diag::warn_unhandled_ms_attribute_ignored
-               : (unsigned)diag::warn_unknown_attribute_ignored)
-        << AL;
+    S.diagnoseUnknownAttribute(AL);
     return;
   }
 
   if (handleCommonAttributeFeatures(S, D, AL))
     return;
 
   switch (AL.getKind()) {
   default:

 static void checkUnusedDeclAttributes(Sema &S, const ParsedAttributesView &A) {
   for (const ParsedAttr &AL : A) {
     // Only warn if the attribute is an unignored, non-type attribute.
     if (AL.isUsedAsTypeAttr() || AL.isInvalid())
       continue;
     if (AL.getKind() == ParsedAttr::IgnoredAttribute)
       continue;
 
-    if (AL.getKind() == ParsedAttr::UnknownAttribute) {
-      S.Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
+    if (AL.getKind() == ParsedAttr::UnknownAttribute)
+      S.diagnoseUnknownAttribute(AL);
+    else
+      S.Diag(AL.getLoc(), diag::warn_attribute_not_on_decl)
           << AL << AL.getRange();
-    } else {
-      S.Diag(AL.getLoc(), diag::warn_attribute_not_on_decl) << AL
-                                                            << AL.getRange();
-    }
   }
 }
 
 /// checkUnusedDeclAttributes - Given a declarator which is not being
 /// used to build a declaration, complain about any decl attributes
 /// which might be lying around on it.
 void Sema::checkUnusedDeclAttributes(Declarator &D) {
   ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes());

       if (PDeclResult == Result)
         ObjCPDecl = PD;
     }
   }
 
   EmitAvailabilityWarning(*this, Result, D, OffendingDecl, Message, Locs,
                           UnknownObjCClass, ObjCPDecl, ObjCPropertyAccess);
 }
+
+void Sema::diagnoseUnknownAttribute(const ParsedAttr &A) {
+  // We emit a few different "unknown attribute" diagnostics, depending on the
+  // circumstances, such as a scoped attribute with an unknown namespace, etc.
+  unsigned Warning = diag::warn_unknown_attribute_ignored;
+  if (A.isDeclspecAttribute()) {
+    Warning = diag::warn_unhandled_ms_attribute_ignored;
+  } else if (A.hasScope()) {
+    if (llvm::StringSwitch<bool>(A.getScopeName()->getName())
+#define ATTR(A)
+#define ATTR_NAMESPACE(A) .Case(#A, false)
+#include "clang/Basic/AttrList.inc"
+            .Default(true))
+      Warning = diag::warn_unknown_attribute_namespace_ignored;
+  } else if (A.isC2xAttribute() || A.isCXX11Attribute()) {
+    // We use the namespaced attribute warning for a C2x or C++11 attribute
+    // without a scope. This ensures that a user who does
+    // -Wno-unknown-attributes -Wunknown-attribute-namespaces still gets a
+    // diagnostic for attributes that could have a scope but do not (e.g.,
+    // [[unknown_attribute]]).
+    Warning = diag::warn_unknown_attribute_namespace_ignored;
+  }
+  Diag(A.getLoc(), Warning) << A << A.getRange();
+}

lib/Sema/SemaDeclCXX.cpp

   // We haven't yet attached the base specifiers.
   Class->setIsParsingBaseSpecifiers();
 
   // We do not support any C++11 attributes on base-specifiers yet.
   // Diagnose any attributes we see.
   for (const ParsedAttr &AL : Attributes) {
     if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
       continue;
-    Diag(AL.getLoc(), AL.getKind() == ParsedAttr::UnknownAttribute
-                          ? (unsigned)diag::warn_unknown_attribute_ignored
-                          : (unsigned)diag::err_base_specifier_attribute)
-        << AL.getName();
+    if (AL.getKind() == ParsedAttr::UnknownAttribute)
+      diagnoseUnknownAttribute(AL);
+    else
+      Diag(AL.getLoc(), diag::err_base_specifier_attribute) << AL;
   }
 
   TypeSourceInfo *TInfo = nullptr;
   GetTypeFromParser(basetype, &TInfo);
 
   if (EllipsisLoc.isInvalid() &&
       DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
                                       UPPC_BaseType))

lib/Sema/SemaStmtAttr.cpp

 
   return OpenCLUnrollHintAttr::CreateImplicit(S.Context, UnrollFactor);
 }
 
 static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A,
                                   SourceRange Range) {
   switch (A.getKind()) {
   case ParsedAttr::UnknownAttribute:
-    S.Diag(A.getLoc(), A.isDeclspecAttribute()
-                           ? (unsigned)diag::warn_unhandled_ms_attribute_ignored
-                           : (unsigned)diag::warn_unknown_attribute_ignored)
-        << A.getName();
+    S.diagnoseUnknownAttribute(A);
     return nullptr;
   case ParsedAttr::AT_FallThrough:
     return handleFallThroughAttr(S, St, A, Range);
   case ParsedAttr::AT_LoopHint:
     return handleLoopHintAttr(S, St, A, Range);
   case ParsedAttr::AT_OpenCLUnrollHint:
     return handleOpenCLUnrollHint(S, St, A, Range);
   case ParsedAttr::AT_Suppress:

lib/Sema/SemaType.cpp

         state.getSema().Diag(attr.getLoc(), diag::err_attribute_not_type_attr)
             << attr;
         attr.setUsedAsTypeAttr();
       }
       break;
 
     case ParsedAttr::UnknownAttribute:
       if (attr.isCXX11Attribute() && TAL == TAL_DeclChunk)
-        state.getSema().Diag(attr.getLoc(),
-                             diag::warn_unknown_attribute_ignored)
-          << attr.getName();
+        state.getSema().diagnoseUnknownAttribute(attr);
       break;
 
     case ParsedAttr::IgnoredAttribute:
       break;
 
     case ParsedAttr::AT_MayAlias:
       // FIXME: This attribute needs to actually be handled, but if we ignore
       // it it breaks large amounts of Linux software.

test/SemaCXX/attr-cxx0x.cpp

-// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -pedantic -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -pedantic -DUNKNOWN_ATTRS -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -pedantic -Wno-unknown-attributes -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -pedantic -Wno-unknown-attributes -Wunknown-attribute-namespaces -DUNKNOWN_NAMESPACE -std=c++11 %s
 
 int align_illegal alignas(3); //expected-error {{requested alignment is not a power of 2}}
 char align_big alignas(int);
 int align_small alignas(1); // expected-error {{requested alignment is less than minimum}}
 int align_multiple alignas(1) alignas(8) alignas(1);
 alignas(4) int align_before;
 
 struct align_member {

 static_assert(alignof(align_class_template<8>) == 8, "template's alignment is wrong");
 static_assert(alignof(align_class_template<16>) == 16, "template's alignment is wrong");
 static_assert(alignof(align_class_temp_pack_type<short, int, long>) == alignof(long), "template's alignment is wrong");
 static_assert(alignof(align_class_temp_pack_expr<8, 16, 32>) == 32, "template's alignment is wrong");
 static_assert(alignof(outer<int,char>::inner<double,short>) == alignof(int) * alignof(double), "template's alignment is wrong");
 
 static_assert(alignof(int(int)) >= 1, "alignof(function) not positive"); // expected-error{{invalid application of 'alignof' to a function type}}
 
-[[__carries_dependency__]]  // expected-warning{{unknown attribute '__carries_dependency__' ignored}}
+#if defined(UNKNOWN_ATTRS) || defined(UNKNOWN_NAMESPACE)
+// expected-warning@+2 {{unknown attribute '__carries_dependency__' ignored}}
+#endif
+[[__carries_dependency__]]
 void func(void);
 
 alignas(4) auto PR19252 = 0;
+
+#if defined(UNKNOWN_ATTRS) || defined(UNKNOWN_NAMESPACE)
+// expected-warning@+2 {{unknown attribute 'frobble' ignored}}
+#endif
+[[frobble]] int unknown1;
+
+#if defined(UNKNOWN_ATTRS) || defined(UNKNOWN_NAMESPACE)
+// expected-warning@+2 {{unknown attribute 'bobble' ignored}}
+#endif
+[[frobble::bobble]] int unknown2;
+
+#ifdef UNKNOWN_ATTRS
+// expected-warning@+2 {{unknown attribute 'unknown_attribute' ignored}}
+#endif
+[[gsl::unknown_attribute]] int unknown3;

utils/TableGen/ClangAttrEmitter.cpp

 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/StringMatcher.h"
 #include "llvm/TableGen/TableGenBackend.h"

     void emitAttrList(raw_ostream &OS) const {
       for (auto SubClass : SubClasses) {
         SubClass->emitAttrList(OS);
       }
 
       ::emitAttrList(OS, Descriptor.MacroName, Attrs);
     }
 
+    void addAttrNamespacesTo(std::set<std::string> &S) const {
+      for (const Record *R : Attrs) {
+        std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
+        for (const auto &Spell : Spellings) {
+          if (!Spell.nameSpace().empty())
+            S.insert(Spell.nameSpace());
+        }
+      }
+    }
+
     void classifyAttrOnRoot(Record *Attr) {
       bool result = classifyAttr(Attr);
       assert(result && "failed to classify on root"); (void) result;
     }
 
     void emitAttrRange(raw_ostream &OS) const {
       OS << "ATTR_RANGE(" << Descriptor.TableGenName
          << ", " << getFirstAttr()->getName()

 #ifndef NDEBUG
       for (auto i = Classes.begin(), e = Classes.end(); i != e; ++i) {
         assert((i == Classes.begin()) == ((*i)->SuperClass == nullptr) &&
                "only the first class should be a root class!");
       }
 #endif
     }
 
+    void emitAttrNamespaces(raw_ostream &OS) const {
+      // Gather the unique set of attribute namespaces Clang knows about. We
+      // want this set to be ordered so we can do efficient lookups.
+      std::set<std::string> Namespaces;
+      for (const auto &Class : Classes) {
+        Class->addAttrNamespacesTo(Namespaces);
+      }
+      // Emit the list of namespaces.
+      for (const auto &Namespace : Namespaces) {
+        OS << "ATTR_NAMESPACE(" << Namespace << ")\n";
+      }
+    }
+
     void emitDefaultDefines(raw_ostream &OS) const {
       for (auto &Class : Classes) {
         Class->emitDefaultDefines(OS);
       }
     }
 
     void emitUndefs(raw_ostream &OS) const {
       for (auto &Class : Classes) {

 void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
 
   AttrClassHierarchy Hierarchy(Records);
 
   // Add defaulting macro definitions.
   Hierarchy.emitDefaultDefines(OS);
   emitDefaultDefine(OS, "PRAGMA_SPELLING_ATTR", nullptr);
+  emitDefaultDefine(OS, "ATTR_NAMESPACE", nullptr);
 
   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
   std::vector<Record *> PragmaAttrs;
   for (auto *Attr : Attrs) {
     if (!Attr->getValueAsBit("ASTNode"))
       continue;
 
     // Add the attribute to the ad-hoc groups.
     if (AttrHasPragmaSpelling(Attr))
       PragmaAttrs.push_back(Attr);
 
     // Place it in the hierarchy.
     Hierarchy.classifyAttr(Attr);
   }
 
   // Emit the main attribute list.
   Hierarchy.emitAttrLists(OS);
 
   // Emit the ad hoc groups.
   emitAttrList(OS, "PRAGMA_SPELLING_ATTR", PragmaAttrs);
+  Hierarchy.emitAttrNamespaces(OS);
 
   // Emit the attribute ranges.
   OS << "#ifdef ATTR_RANGE\n";
   Hierarchy.emitAttrRanges(OS);
   OS << "#undef ATTR_RANGE\n";
   OS << "#endif\n";
 
   Hierarchy.emitUndefs(OS);
   OS << "#undef PRAGMA_SPELLING_ATTR\n";
+  OS << "#undef ATTR_NAMESPACE\n";
 }
 
 // Emits the enumeration list for attributes.
 void EmitClangAttrSubjectMatchRuleList(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader(
       "List of all attribute subject matching rules that Clang recognizes", OS);
   PragmaClangAttributeSupport &PragmaAttributeSupport =
       getPragmaAttributeSupport(Records);