Add a __has_attribute_enhancement macro to clang

[george.burgess.iv]

Summary

Attributes may gain features or added flexibility over time. This patch aims to add a simple and uniform way to directly add/query for arbitrary changes in attributes, instead of having to rely on other information (e.g. version numbers, the existence of other attributes added at around the same time as the feature you're interested in, ...).

The only user of this at the moment will be https://reviews.llvm.org/D32332, so I won't tag people for review here until that lands.

Better words than "enhancement" are welcome; I tried things like __has_attribute_extension and __has_attribute_feature, but we also have both __has_extension and __has_feature, so... :)

[ahatanak]

docs/LanguageExtensions.rst

176

Do you need "gained" here?

[hfinkel]

I prefer __has_attribute_feature to enhancement. I don't see why we need a new macro for this, however. Why not just use __has_feature(overloadable_unmarked) or similar?

[george.burgess.iv]

Why not just use __has_feature(overloadable_unmarked) or similar?

My impression was that __has_feature was was for larger features than tweaks to attributes. If this would be an appropriate use of __has_feature, though, I'm happy to keep things simple.

I'll update the other review with __has_feature. If it goes in with that, I'll abandon this.

Thanks!

docs/LanguageExtensions.rst

176

Good catch :)

[aaron.ballman]

In D33904#778165, @george.burgess.iv wrote:

Why not just use __has_feature(overloadable_unmarked) or similar?

My impression was that __has_feature was was for larger features than tweaks to attributes. If this would be an appropriate use of __has_feature, though, I'm happy to keep things simple.

I'll update the other review with __has_feature. If it goes in with that, I'll abandon this.

I agree, this need seems more in line with __has_feature than adding a new feature testing macro.

Thanks!

[george.burgess.iv]

r306467 used __has_extension(overloadable_unmarked) instead.

Thanks again for the comments!

docs/LanguageExtensions.rst

.. code-block:: c++
   #define ALWAYS_INLINE
   #endif
   ...
 
 The attribute name can also be specified with a preceding and following ``__``
 (double underscore) to avoid interference from a macro with the same name.  For
 instance, ``__always_inline__`` can be used instead of ``always_inline``.
 
+``__has_attribute_enhancement``
+-------------------------------
+
+This function-like macro takes two arguments: the name of a GNU-style attribute,
+and the name of an enhancement that was made to the attribute since its
+introduction.  It evaluates to 1 if clang supports this enhancement, and 0 if
+not.
+
+For example, clang's ``overloadable`` attribute has existed since before Clang
+3.5, but in Clang 5.0 it gained was modified to support so-called "unmarked
+overloads".  One can use ``__has_attribute_enhancement`` to query whether clang
+supports this upgraded version of ``overloadable`` like so:
+
+.. code-block:: c++
+
+  #ifndef __has_attribute_enhancement            // Optional.
+    #define __has_attribute_enhancement(x, y) 0  // Compatibility with non-clang
+                                                 // compilers.
+  #endif
+
+  #if !__has_attribute_enhancement(overloadable, unmarked_overloads)
+    #error "This library requires unmarked overload support."
+  #endif
+
+Since enhancements are attribute-specific, please consult the documentation to
+see what enhancements each attribute has, if any.
+
+Much like in ``__has_attribute``, if either the first or second argument to
+this macro has a leading and trailing ``__``, clang will ignore them.
 
 ``__has_declspec_attribute``
 ----------------------------
 
 This function-like macro takes a single identifier argument that is the name of
 an attribute implemented as a Microsoft-style ``__declspec`` attribute.  It
 evaluates to 1 if the attribute is supported by the current compilation target,
 or 0 if not.  It can be used like this:

include/clang/Basic/Attr.td

class Attr {
   // Any additional text that should be included verbatim in the class.
   // Note: Any additional data members will leak and should be constructed
   // externally on the ASTContext.
   code AdditionalMembers = [{}];
   // Any documentation that should be associated with the attribute. Since an
   // attribute may be documented under multiple categories, more than one
   // Documentation entry may be listed.
   list<Documentation> Documentation;
+  // Any features that this attribute supports that were added since its
+  // introduction. These can be queried via the __has_attribute_enhancement
+  // builtin macro.
+  list<string> Enhancements = [];
 }
 
 /// A type attribute is not processed on a declaration or a statement.
 class TypeAttr : Attr {
   // By default, type attributes do not get an AST node.
   let ASTNode = 0;
 }
 
def OptimizeNone : InheritableAttr {
   let Subjects = SubjectList<[Function, ObjCMethod]>;
   let Documentation = [OptnoneDocs];
 }
 
 def Overloadable : Attr {
   let Spellings = [GNU<"overloadable">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [OverloadableDocs];
+  let Enhancements = ["unmarked_overloads"];
 }
 
 def Override : InheritableAttr { 
   let Spellings = [Keyword<"override">];
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
 

include/clang/Basic/Attributes.h

enum class AttrSyntax {
   // Is the identifier known as a pragma attribute?
   Pragma
 };
 
 /// \brief Return the version number associated with the attribute if we
 /// recognize and implement the attribute specified by the given information.
 int hasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope,
                  const IdentifierInfo *Attr, const TargetInfo &Target,
-                 const LangOptions &LangOpts);
+                 const LangOptions &LangOpts,
+                 const IdentifierInfo *Enhancement = nullptr);
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_ATTRIBUTES_H

include/clang/Lex/Preprocessor.h

class Preprocessor {
   /// a token cache rather than lexing the original source file.
   std::unique_ptr<PTHManager> PTH;
 
   /// A BumpPtrAllocator object used to quickly allocate and release
   /// objects internal to the Preprocessor.
   llvm::BumpPtrAllocator BP;
 
   /// Identifiers for builtin macros and other builtins.
-  IdentifierInfo *Ident__LINE__, *Ident__FILE__;   // __LINE__, __FILE__
-  IdentifierInfo *Ident__DATE__, *Ident__TIME__;   // __DATE__, __TIME__
-  IdentifierInfo *Ident__INCLUDE_LEVEL__;          // __INCLUDE_LEVEL__
-  IdentifierInfo *Ident__BASE_FILE__;              // __BASE_FILE__
-  IdentifierInfo *Ident__TIMESTAMP__;              // __TIMESTAMP__
-  IdentifierInfo *Ident__COUNTER__;                // __COUNTER__
-  IdentifierInfo *Ident_Pragma, *Ident__pragma;    // _Pragma, __pragma
-  IdentifierInfo *Ident__identifier;               // __identifier
-  IdentifierInfo *Ident__VA_ARGS__;                // __VA_ARGS__
-  IdentifierInfo *Ident__has_feature;              // __has_feature
-  IdentifierInfo *Ident__has_extension;            // __has_extension
-  IdentifierInfo *Ident__has_builtin;              // __has_builtin
-  IdentifierInfo *Ident__has_attribute;            // __has_attribute
-  IdentifierInfo *Ident__has_include;              // __has_include
-  IdentifierInfo *Ident__has_include_next;         // __has_include_next
-  IdentifierInfo *Ident__has_warning;              // __has_warning
-  IdentifierInfo *Ident__is_identifier;            // __is_identifier
-  IdentifierInfo *Ident__building_module;          // __building_module
-  IdentifierInfo *Ident__MODULE__;                 // __MODULE__
-  IdentifierInfo *Ident__has_cpp_attribute;        // __has_cpp_attribute
-  IdentifierInfo *Ident__has_declspec;             // __has_declspec_attribute
+  IdentifierInfo *Ident__LINE__, *Ident__FILE__;  // __LINE__, __FILE__
+  IdentifierInfo *Ident__DATE__, *Ident__TIME__;  // __DATE__, __TIME__
+  IdentifierInfo *Ident__INCLUDE_LEVEL__;         // __INCLUDE_LEVEL__
+  IdentifierInfo *Ident__BASE_FILE__;             // __BASE_FILE__
+  IdentifierInfo *Ident__TIMESTAMP__;             // __TIMESTAMP__
+  IdentifierInfo *Ident__COUNTER__;               // __COUNTER__
+  IdentifierInfo *Ident_Pragma, *Ident__pragma;   // _Pragma, __pragma
+  IdentifierInfo *Ident__identifier;              // __identifier
+  IdentifierInfo *Ident__VA_ARGS__;               // __VA_ARGS__
+  IdentifierInfo *Ident__has_feature;             // __has_feature
+  IdentifierInfo *Ident__has_extension;           // __has_extension
+  IdentifierInfo *Ident__has_builtin;             // __has_builtin
+  IdentifierInfo *Ident__has_attribute;           // __has_attribute
+  IdentifierInfo
+      *Ident__has_attribute_enhancement;          // __has_attribute_enhancement
+  IdentifierInfo *Ident__has_include;             // __has_include
+  IdentifierInfo *Ident__has_include_next;        // __has_include_next
+  IdentifierInfo *Ident__has_warning;             // __has_warning
+  IdentifierInfo *Ident__is_identifier;           // __is_identifier
+  IdentifierInfo *Ident__building_module;         // __building_module
+  IdentifierInfo *Ident__MODULE__;                // __MODULE__
+  IdentifierInfo *Ident__has_cpp_attribute;       // __has_cpp_attribute
+  IdentifierInfo *Ident__has_declspec;            // __has_declspec_attribute
 
   SourceLocation DATELoc, TIMELoc;
   unsigned CounterValue;  // Next __COUNTER__ value.
 
   enum {
     /// \brief Maximum depth of \#includes.
     MaxAllowedIncludeStackDepth = 200
   };

lib/Basic/Attributes.cpp

 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/AttrSubjectMatchRules.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "llvm/ADT/StringSwitch.h"
 using namespace clang;
 
+static StringRef stripSurroundingUnderscores(StringRef R) {
+  if (R.size() >= 4 && R.startswith("__") && R.endswith("__"))
+    return R.drop_front(2).drop_back(2);
+  return R;
+}
+
 int clang::hasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope,
                         const IdentifierInfo *Attr, const TargetInfo &Target,
-                        const LangOptions &LangOpts) {
-  StringRef Name = Attr->getName();
-  // Normalize the attribute name, __foo__ becomes foo.
-  if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))
-    Name = Name.substr(2, Name.size() - 4);
+                        const LangOptions &LangOpts,
+                        const IdentifierInfo *Enhancement) {
+  StringRef Name = stripSurroundingUnderscores(Attr->getName());
+  StringRef EnhancementName;
+  if (Enhancement)
+    EnhancementName = stripSurroundingUnderscores(Enhancement->getName());
 
 #include "clang/Basic/AttrHasAttributeImpl.inc"
 
   return 0;
 }
 
 const char *attr::getSubjectMatchRuleSpelling(attr::SubjectMatchRule Rule) {
   switch (Rule) {
 #define ATTR_MATCH_RULE(NAME, SPELLING, IsAbstract)                            \
   case attr::NAME:                                                             \
     return SPELLING;
 #include "clang/Basic/AttrSubMatchRulesList.inc"
   }
   llvm_unreachable("Invalid subject match rule");
 }

lib/Lex/PPMacroExpansion.cpp

void Preprocessor::RegisterBuiltinMacros() {
   // C++ Standing Document Extensions.
   if (LangOpts.CPlusPlus)
     Ident__has_cpp_attribute =
         RegisterBuiltinMacro(*this, "__has_cpp_attribute");
   else
     Ident__has_cpp_attribute = nullptr;
 
   // GCC Extensions.
-  Ident__BASE_FILE__     = RegisterBuiltinMacro(*this, "__BASE_FILE__");
+  Ident__BASE_FILE__ = RegisterBuiltinMacro(*this, "__BASE_FILE__");
   Ident__INCLUDE_LEVEL__ = RegisterBuiltinMacro(*this, "__INCLUDE_LEVEL__");
-  Ident__TIMESTAMP__     = RegisterBuiltinMacro(*this, "__TIMESTAMP__");
+  Ident__TIMESTAMP__ = RegisterBuiltinMacro(*this, "__TIMESTAMP__");
 
   // Microsoft Extensions.
   if (LangOpts.MicrosoftExt) {
     Ident__identifier = RegisterBuiltinMacro(*this, "__identifier");
     Ident__pragma = RegisterBuiltinMacro(*this, "__pragma");
   } else {
     Ident__identifier = nullptr;
     Ident__pragma = nullptr;
   }
 
   // Clang Extensions.
-  Ident__has_feature      = RegisterBuiltinMacro(*this, "__has_feature");
-  Ident__has_extension    = RegisterBuiltinMacro(*this, "__has_extension");
-  Ident__has_builtin      = RegisterBuiltinMacro(*this, "__has_builtin");
-  Ident__has_attribute    = RegisterBuiltinMacro(*this, "__has_attribute");
+  Ident__has_feature = RegisterBuiltinMacro(*this, "__has_feature");
+  Ident__has_extension = RegisterBuiltinMacro(*this, "__has_extension");
+  Ident__has_builtin = RegisterBuiltinMacro(*this, "__has_builtin");
+  Ident__has_attribute = RegisterBuiltinMacro(*this, "__has_attribute");
+  Ident__has_attribute_enhancement =
+      RegisterBuiltinMacro(*this, "__has_attribute_enhancement");
   Ident__has_declspec = RegisterBuiltinMacro(*this, "__has_declspec_attribute");
-  Ident__has_include      = RegisterBuiltinMacro(*this, "__has_include");
+  Ident__has_include = RegisterBuiltinMacro(*this, "__has_include");
   Ident__has_include_next = RegisterBuiltinMacro(*this, "__has_include_next");
-  Ident__has_warning      = RegisterBuiltinMacro(*this, "__has_warning");
-  Ident__is_identifier    = RegisterBuiltinMacro(*this, "__is_identifier");
+  Ident__has_warning = RegisterBuiltinMacro(*this, "__has_warning");
+  Ident__is_identifier = RegisterBuiltinMacro(*this, "__is_identifier");
 
   // Modules.
   Ident__building_module  = RegisterBuiltinMacro(*this, "__building_module");
   if (!LangOpts.CurrentModule.empty())
     Ident__MODULE__ = RegisterBuiltinMacro(*this, "__MODULE__");
   else
     Ident__MODULE__ = nullptr;
 }
static bool EvaluateHasIncludeNext(Token &Tok,
   } else {
     // Start looking up in the next directory.
     ++Lookup;
   }
 
   return EvaluateHasIncludeCommon(Tok, II, PP, Lookup, LookupFromFile);
 }
 
-/// \brief Process single-argument builtin feature-like macros that return
-/// integer values.
+/// \brief Process builtin feature-like macros that return integer values. Any
+/// multi-arg handling should be done from `Op`.
 static void EvaluateFeatureLikeBuiltinMacro(llvm::raw_svector_ostream& OS,
                                             Token &Tok, IdentifierInfo *II,
                                             Preprocessor &PP,
                                             llvm::function_ref<
                                               int(Token &Tok,
-                                                  bool &HasLexedNextTok)> Op) {
+                                                  bool &HasLexedNextTok,
+                                                  bool &SuppressDiags)> Op) {
   // Parse the initial '('.
   PP.LexUnexpandedToken(Tok);
   if (Tok.isNot(tok::l_paren)) {
     PP.Diag(Tok.getLocation(), diag::err_pp_expected_after) << II
                                                             << tok::l_paren;
 
     // Provide a dummy '0' value on output stream to elide further errors.
     if (!Tok.isOneOf(tok::eof, tok::eod)) {
switch (Tok.getKind()) {
         return;
 
       default: {
         // Parse the macro argument, if one not found so far.
         if (Result.hasValue())
           break;
 
         bool HasLexedNextToken = false;
-        Result = Op(Tok, HasLexedNextToken);
+        bool NoMoreDiags = false;
+        Result = Op(Tok, HasLexedNextToken, NoMoreDiags);
+        SuppressDiagnostic |= NoMoreDiags;
         ResultTok = Tok;
         if (HasLexedNextToken)
           goto already_lexed;
         continue;
       }
     }
 
     // Diagnose missing ')'.
if (II == Ident__LINE__) {
     OS << '"' << StringRef(Result).drop_back() << '"';
     Tok.setKind(tok::string_literal);
   } else if (II == Ident__COUNTER__) {
     // __COUNTER__ expands to a simple numeric value.
     OS << CounterValue++;
     Tok.setKind(tok::numeric_constant);
   } else if (II == Ident__has_feature) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
-      [this](Token &Tok, bool &HasLexedNextToken) -> int {
+      [this](Token &Tok, bool &HasLexedNextToken, bool &SuppressDiags) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         return II && HasFeature(*this, II->getName());
       });
   } else if (II == Ident__has_extension) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
-      [this](Token &Tok, bool &HasLexedNextToken) -> int {
+      [this](Token &Tok, bool &HasLexedNextToken, bool &SuppressDiags) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         return II && HasExtension(*this, II->getName());
       });
   } else if (II == Ident__has_builtin) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
-      [this](Token &Tok, bool &HasLexedNextToken) -> int {
+      [this](Token &Tok, bool &HasLexedNextToken, bool &SuppressDiags) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         if (!II)
           return false;
         else if (II->getBuiltinID() != 0)
           return true;
         else {
           const LangOptions &LangOpts = getLangOpts();
           return llvm::StringSwitch<bool>(II->getName())
                       .Case("__make_integer_seq", LangOpts.CPlusPlus)
                       .Case("__type_pack_element", LangOpts.CPlusPlus)
                       .Case("__builtin_available", true)
                       .Default(false);
         }
       });
   } else if (II == Ident__is_identifier) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
-      [](Token &Tok, bool &HasLexedNextToken) -> int {
+      [](Token &Tok, bool &HasLexedNextToken, bool &SuppressDiags) -> int {
         return Tok.is(tok::identifier);
       });
   } else if (II == Ident__has_attribute) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
-      [this](Token &Tok, bool &HasLexedNextToken) -> int {
+      [this](Token &Tok, bool &HasLexedNextToken, bool &SuppressDiags) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         return II ? hasAttribute(AttrSyntax::GNU, nullptr, II,
                                  getTargetInfo(), getLangOpts()) : 0;
       });
+  } else if (II == Ident__has_attribute_enhancement) {
+    EvaluateFeatureLikeBuiltinMacro(
+        OS, Tok, II, *this,
+        [this](Token &Tok, bool &HasLexedNextToken,
+               bool &SuppressDiags) -> int {
+          IdentifierInfo *AttrName = ExpectFeatureIdentifierInfo(
+              Tok, *this, diag::err_feature_check_malformed);
+
+          if (!AttrName)
+            return 0;
+
+          IdentifierInfo *EnhancementName = nullptr;
+          SourceLocation InitialIdentLoc = Tok.getLocation();
+          LexUnexpandedToken(Tok);
+          if (Tok.isNot(tok::comma)) {
+            if (Tok.is(tok::r_paren))
+              Diag(Tok.getLocation(), diag::err_too_few_args_in_macro_invoc);
+            else
+              Diag(Tok.getLocation(), diag::err_pp_expected_after)
+                  << AttrName << tok::comma << InitialIdentLoc;
+            HasLexedNextToken = true;
+            SuppressDiags = true;
+            return 0;
+          }
+
+          LexUnexpandedToken(Tok);
+          EnhancementName = ExpectFeatureIdentifierInfo(
+              Tok, *this, diag::err_pp_expected_ident_in_arg_list);
+          // If the enhancement name is invalid, pretend we don't have it.
+          if (!EnhancementName) {
+            SuppressDiags = true;
+            HasLexedNextToken = true;
+            return 0;
+          }
+
+          return hasAttribute(AttrSyntax::GNU, nullptr, AttrName,
+                              getTargetInfo(), getLangOpts(), EnhancementName);
+        });
   } else if (II == Ident__has_declspec) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
-      [this](Token &Tok, bool &HasLexedNextToken) -> int {
+      [this](Token &Tok, bool &HasLexedNextToken, bool &SuppressDiags) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         return II ? hasAttribute(AttrSyntax::Declspec, nullptr, II,
                                  getTargetInfo(), getLangOpts()) : 0;
       });
   } else if (II == Ident__has_cpp_attribute) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
-      [this](Token &Tok, bool &HasLexedNextToken) -> int {
+      [this](Token &Tok, bool &HasLexedNextToken, bool &SuppressDiags) -> int {
         IdentifierInfo *ScopeII = nullptr;
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         if (!II)
           return false;
 
         // It is possible to receive a scope token.  Read the "::", if it is
         // available, and the subsequent identifier.
if (II == Ident__LINE__) {
 
     if (Tok.isNot(tok::r_paren))
       return;
     OS << (int)Value;
     Tok.setKind(tok::numeric_constant);
   } else if (II == Ident__has_warning) {
     // The argument should be a parenthesized string literal.
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
-      [this](Token &Tok, bool &HasLexedNextToken) -> int {
+      [this](Token &Tok, bool &HasLexedNextToken, bool &SuppressDiags) -> int {
         std::string WarningName;
         SourceLocation StrStartLoc = Tok.getLocation();
 
         HasLexedNextToken = Tok.is(tok::string_literal);
         if (!FinishLexStringLiteral(Tok, WarningName, "'__has_warning'",
                                     /*MacroExpansion=*/false))
           return false;
 
EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
                 getDiagnosticsInGroup(diag::Flavor::WarningOrError,
                                       WarningName.substr(2), Diags);
       });
   } else if (II == Ident__building_module) {
     // The argument to this builtin should be an identifier. The
     // builtin evaluates to 1 when that identifier names the module we are
     // currently building.
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
-      [this](Token &Tok, bool &HasLexedNextToken) -> int {
+      [this](Token &Tok, bool &HasLexedNextToken, bool &SuppressDiags) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                        diag::err_expected_id_building_module);
         return getLangOpts().isCompilingModule() && II &&
                (II->getName() == getLangOpts().CurrentModule);
       });
   } else if (II == Ident__MODULE__) {
     // The current module as an identifier.
     OS << getLangOpts().CurrentModule;

test/Preprocessor/has_attribute.c

 
 // CHECK: does_not_have_uuid
 #if !__has_attribute(uuid)
   int does_not_have_uuid
 #endif
 
 #if __has_cpp_attribute(selectany) // expected-error {{function-like macro '__has_cpp_attribute' is not defined}}
 #endif
+
+#if !defined(__has_attribute_enhancement)
+#error "No extended has_attribute support?"
+#endif
+
+#if __has_attribute_enhancement(attr_does_not_exist) // expected-error{{too few arguments}}
+#error "We have an enhancement on an attr that doesn't exist?"
+#endif
+
+#if __has_attribute_enhancement(attr_does_not_exist thing) // expected-error{{missing ',' after 'attr_does_not_exist'}}
+#error "We have an enhancement on an attr that doesn't exist?"
+#endif
+
+#if __has_attribute_enhancement(attr_does_not_exist, ____)
+#error "We have an enhancement on an attr that doesn't exist?"
+#endif
+
+#if __has_attribute_enhancement(always_inline, ____)
+#error "Empty enhancement exists on always_inline?"
+#endif
+
+#if __has_attribute_enhancement(always_inline, enhancement_does_not_exist)
+#error "Enhancement checks on enhancementless attributes seem broken"
+#endif
+
+#if !__has_attribute(overloadable)
+#error "The following tests depend on having overloadable"
+#endif
+
+#if __has_attribute_enhancement(overloadable,) // expected-error{{expected identifier}}
+#error "Should assume false"
+#endif
+
+#if __has_attribute_enhancement(overloadable, not a valid enhancement) // expected-error{{missing ')' after 'not'}} expected-note{{to match this}}
+#error "Should assume false"
+#endif
+
+#if __has_attribute_enhancement(overloadable, not_an_existing_enhancement)
+#error "Should assume false"
+#endif
+
+#if __has_attribute_enhancement(overloadable, __not_an_existing_enhancement__)
+#error "Should assume false"
+#endif
+
+#if !__has_attribute_enhancement(overloadable, unmarked_overloads)
+#error "Unmarked overloads are supported"
+#endif
+
+#if __has_attribute_enhancement(overloadable, __unmarked_overloads_)
+#error "Underscores should be all-or-nothing"
+#endif
+
+#if !__has_attribute_enhancement(overloadable, __unmarked_overloads__)
+#error "Unmarked overloads are supported"
+#endif

utils/TableGen/ClangAttrEmitter.cpp

if (!R->isValueUnset("CXXABIs")) {
     }
     Test += ")";
   }
 }
 
 static void GenerateHasAttrSpellingStringSwitch(
     const std::vector<Record *> &Attrs, raw_ostream &OS,
     const std::string &Variety = "", const std::string &Scope = "") {
+  const StringRef CaseIndent = "    ";
   for (const auto *Attr : Attrs) {
     // C++11-style attributes have specific version information associated with
     // them. If the attribute has no scope, the version information must not
     // have the default value (1), as that's incorrect. Instead, the unscoped
     // attribute version information should be taken from the SD-6 standing
     // document, which can be found at: 
     // https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations
     int Version = 1;
if (Attr->isSubClassOf("TargetSpecificAttr")) {
       // If this is the C++11 variety, also add in the LangOpts test.
       if (Variety == "CXX11")
         Test += " && LangOpts.CPlusPlus11";
     } else if (Variety == "CXX11")
       // C++11 mode should be checked against LangOpts, which is presumed to be
       // present in the caller.
       Test = "LangOpts.CPlusPlus11";
 
+    // Any enhancements must be checked for, as well.
+    if (!Test.empty())
+      Test += " && ";
+
+    std::vector<StringRef> Enhancements =
+        Attr->getValueAsListOfStrings("Enhancements");
+    if (Enhancements.empty()) {
+      Test += "!Enhancement";
+    } else {
+      Test += "(!Enhancement || llvm::StringSwitch<bool>(EnhancementName)";
+
+      std::string Preamble = ("\n" + CaseIndent + CaseIndent).str();
+      for (const auto &Enhancement : Enhancements) {
+        assert(Enhancement.find('"') == std::string::npos &&
+               "Quotes aren't allowed in enhancements!");
+        Test += (Preamble + ".Case(\"" + Enhancement + "\", true)").str();
+      }
+      Test += Preamble + ".Default(false))";
+    }
+
     std::string TestStr =
         !Test.empty() ? Test + " ? " + llvm::itostr(Version) + " : 0" : "1";
     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
     for (const auto &S : Spellings)
       if (Variety.empty() || (Variety == S.variety() &&
                               (Scope.empty() || Scope == S.nameSpace())))
-        OS << "    .Case(\"" << S.name() << "\", " << TestStr << ")\n";
+        OS << CaseIndent << ".Case(\"" << S.name() << "\", " << TestStr << ")\n";
   }
-  OS << "    .Default(0);\n";
+  OS << CaseIndent << ".Default(0);\n";
 }
 
 // Emits the list of spellings for attributes.
 void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Code to implement the __has_attribute logic", OS);
 
   // Separate all of the attributes out into four group: generic, C++11, GNU,
   // and declspecs. Then generate a big switch statement for each of them.