[CodeComplete] Basic code completion for attribute names.

[sammccall]

Summary

Only the bare name is completed, with no args.
For args to be useful we need arg names. These *are* in the tablegen but
not currently emitted in usable form, so left this as future work.

C++11, C2x, GNU, declspec, MS syntax is supported, with the appropriate
spellings of attributes suggested.
#pragma clang attribute is supported but not terribly useful as we
only reach completion if parens are balanced (i.e. the line is not truncated)

There's no filtering of which attributes might make sense in this
grammatical context (e.g. attached to a function). In code-completion context
this is hard to do, and will only work in few cases :-(

There's also no filtering by langopts: this is because currently the
only way of checking is to try to produce diagnostics, which requires a
valid ParsedAttr which is hard to get.
This should be fairly simple to fix but requires some tablegen changes
to expose the logic without the side-effect.

[aaron.ballman]

Thank you for working on this, I think it's fantastic functionality!

clang/lib/Sema/SemaCodeComplete.cpp

4357

Should we also add some special handling for attributes optionally starting with double underscores? e.g., __attribute__((const)) and __attribute__((__const__))` are both equally useful to complete.

Also, we should add some explicit testing for omp::sequence and omp::directive as those are handled very specially and won't appear in the parsed attribute map. I think the OpenMP code completion would be super useful, but can be handled in a follow-up if you want.

[sammccall]

clang/lib/Sema/SemaCodeComplete.cpp

4357

Should we also add some special handling for attributes optionally starting with double underscores?

I think so. Two questions:

• Do I understand right that this is "just" a matter of adding leading/trailing __ as a second option, for AS_GNU?
• are there similar rules for other syntaxes I've missed?

Offering both seems potentially confusing for users who don't care (especially in the case of const!). But I guess enough users will care about macros. At least in clangd the underscore versions will get ranked lower for having "internal" names though.

FWIW The no-underscores version appears to be ~3x more common (87k vs 27k hits in third-party code in google's repo). Among headers, no-underscores is "only" 2x more common (40k vs 21k).

---

Also, we should add some explicit testing for omp::sequence and omp::directive as those are handled very specially and won't appear in the parsed attribute map.

Yeah, I punted on these because it seems they will need special case logic, I'll add some tests that they don't do anything.

[aaron.ballman]

clang/lib/Sema/SemaCodeComplete.cpp

4357

Do I understand right that this is "just" a matter of adding leading/trailing __ as a second option, for AS_GNU?
are there similar rules for other syntaxes I've missed?

Clang supports GNU attributes in either __attribute__((foo)) or __attribute__((__foo__)) forms. So I'd say that autocompleting after the second ( should either suggest attributes (preferred) or __ (for the poor folks writing libraries). If the user wants to autocomplete after __attribute__((__, I think it should suggest foo__ as the rest of the attribute name. (Basically, if the user looks like they want underscores, give them all the underscores.)

Clang also supports [[]] attributes but with somewhat different rules. We support [[gnu::attr]], [[__gnu__::attr]], [[gnu::__attr__]], and [[__gnu__::__attr__]] for GCC attributes. We support [[clang::attr]], [[_Clang::attr]], [[clang::__attr__]], and [[_Clang::__attr__]] for Clang attributes. For vendors other than Clang and GCC, we don't support any additional underscores for either the scope or the attribute name. I would say that if the user asked for underscores for the vendor scope, they likely want the underscores for the attribute as well.

I suppose there's a third case. That horrible using syntax that I've never really seen used in the wild. e.g., `[[using clang: attr]`. We do support the underscore behavior there as well.

Offering both seems potentially confusing for users who don't care (especially in the case of const!). But I guess enough users will care about macros.

Yeah, users who are writing portable libraries are far more likely to care than users writing typical application code.

[sammccall]

Thanks, I know what to do next!

While I have you here, any thoughts on future patches:

Only the bare name is completed, with no args.
For args to be useful we need arg names. These *are* in the tablegen but
not currently emitted in usable form, so left this as future work.

How do you feel about this plan:

• add an ArrayRef<const char*> to ParsedAttrInfo for this purpose? (Or a null-terminated char** if we're worried about sizeof).
• It'd be populated by the names of the tablegen Args.
• If empty, completions render as now. If nonempty they render as foo(bar, baz) where bar and baz are placeholders - just like function args but without types.

There's also no filtering by langopts: this is because currently the
only way of checking is to try to produce diagnostics, which requires a
valid ParsedAttr which is hard to get.

And for this, WDYT about making diagLangOpts non-virtual and moving the attr-specific test into a virtual bool supportsLangOpts() function with no side-effects?

clang/lib/Sema/SemaCodeComplete.cpp

4357

So I'd say that autocompleting after the second ( should either suggest attributes (preferred) or __ (for the poor folks writing libraries).

This is clever, unfortunately it doesn't really work for other reasons:

• LSP allows clients to "narrow down" results as an identifier is typed with client-side filtering, and _ is treated as an identifier character.
• clang's code completion similarly returns all matches and leaves partial-identifier-filtering them to the CodeCompleteConsumer

I can't see a better plan than including both the underscore and non-underscore versions, with the latter downranked. Doesn't seem *too* bad.

Clang also supports [[]] attributes...

Yeah, I think what we should do here is pretend the scoped namespace contains only the scoped attribute and vice versa:

• When we want qualified attributes, emit gnu::attr and __gnu__::__attr__ but no mixing
• When we want scopes (after using), emit gnu and __gnu__
• When we want unqualified attributes (after ns:: or using ns:), emit either attr or __attr__ depending on the scope

That horrible using syntax

I really don't understand why this is worthwhile. Maybe feature parity with XMLNS? :-)
In any case, it happens to be easy to handle.

[aaron.ballman]

In D107696#2934881, @sammccall wrote:

Thanks, I know what to do next!

While I have you here, any thoughts on future patches:

Only the bare name is completed, with no args.
For args to be useful we need arg names. These *are* in the tablegen but
not currently emitted in usable form, so left this as future work.

How do you feel about this plan:

• add an ArrayRef<const char*> to ParsedAttrInfo for this purpose? (Or a null-terminated char** if we're worried about sizeof).
• It'd be populated by the names of the tablegen Args.
• If empty, completions render as now. If nonempty they render as foo(bar, baz) where bar and baz are placeholders - just like function args but without types.

I think args may be... interesting. Many attributes have arguments that can't really be completed because they're an integer, a string literal, whatever. But there are still quite a few that accept an enumeration, and those enumeration values would be super useful to autocomplete. And still others have arbitrary expressions where autocompletion would be fantastic (like diagnose_if).

I'm not certain that an ArrayRef would be sufficient to the task, but I do think we could probably generate something out of ClangAttrEmitter.cpp to help on an attribute-by-attribute basis.

There's also no filtering by langopts: this is because currently the
only way of checking is to try to produce diagnostics, which requires a
valid ParsedAttr which is hard to get.

And for this, WDYT about making diagLangOpts non-virtual and moving the attr-specific test into a virtual bool supportsLangOpts() function with no side-effects?

I think that'd work fine -- it'll break plugin authors, but that should hopefully be a loud break when they go to recompile their plugin.

[sammccall]

Add support and tests for underscore-guarding.
Add tests that omp attributes are not supported.

[aaron.ballman]

clang/lib/Sema/SemaCodeComplete.cpp

4357

I can't see a better plan than including both the underscore and non-underscore versions, with the latter downranked. Doesn't seem *too* bad.

Seems reasonable enough to me!

Yeah, I think what we should do here is pretend the scoped namespace contains only the scoped attribute and vice versa:

+1, that seems good to me.

I really don't understand why this is worthwhile.

IMHO, it absolutely wasn't worthwhile. :-D

4390

Should we also early return if the attribute is ignored? (See IgnoredAttr in Attr.td) I'm assuming that attributes which do nothing are unlikely to be high-value attributes to autocomplete (so maybe they'd go at the end of the list if we wanted to keep them).

4436–4446

This could probably use a Twine and save some typing, but I don't insist.

[sammccall]

clang/lib/Sema/SemaCodeComplete.cpp

4390

Hmm, I'm not sure about that.
They do nothing *in clang*, but using clang-based code completion doesn't particularly mean we'll use clang to build the code.
Something must care about the attribute, even if it's just a doc generator or something.

In practice, there are 6 attrs with Ignored = 1:

• bounded is an openbsd-gcc extension
• 3 are cuda-specific and probably only used by cuda stdlib headers
• __w64 is a keyword so not relevant here
• property is actually supported by clang, it seems Ignored is lying!

So none of these are *terribly* important, but they also don't seem so worthless that it's important to exclude them. (There are other attributes that aren't important too!)

[aaron.ballman]

Btw, I'm not certain why patch application is failing for you in the precommit CI: https://buildkite.com/llvm-project/diff-checks/builds/58571#c186a7d3-f5c9-4ad2-ae27-07408b1c5dad It doesn't seem like your patch is the cause of it, but this review is the only one where I've noticed the issue. Perhaps if you upload a new patch CI will be happier? Otherwise, beware of bot stampedes when you land. :-)

This LGTM (if you want to, feel free to switch to Twine in the one place I called out, but we don't need another round of review for that), thank you for the patch!

clang/lib/Sema/SemaCodeComplete.cpp

4390

Hmm, I'm not sure about that.

I'm convinced by your reasoning, thank you!

[aaron.ballman]

In D107696#2939827, @aaron.ballman wrote:

Btw, I'm not certain why patch application is failing for you in the precommit CI: https://buildkite.com/llvm-project/diff-checks/builds/58571#c186a7d3-f5c9-4ad2-ae27-07408b1c5dad It doesn't seem like your patch is the cause of it, but this review is the only one where I've noticed the issue.

Literally the next review I looked at had this same issue (https://reviews.llvm.org/D107095), so I'm more comfortable saying the CI failure is unrelated to anything in your patch. :-)

clang-tools-extra/clangd/CodeComplete.cpp

bool contextAllowsIndex(enum CodeCompletionContext::Kind K) {
   case CodeCompletionContext::CCC_MacroNameUse:
   case CodeCompletionContext::CCC_PreprocessorExpression:
   case CodeCompletionContext::CCC_PreprocessorDirective:
   case CodeCompletionContext::CCC_SelectorName:
   case CodeCompletionContext::CCC_TypeQualifiers:
   case CodeCompletionContext::CCC_ObjCInstanceMessage:
   case CodeCompletionContext::CCC_ObjCClassMessage:
   case CodeCompletionContext::CCC_IncludedFile:
+  case CodeCompletionContext::CCC_Attribute:
   // FIXME: Provide identifier based completions for the following contexts:
   case CodeCompletionContext::CCC_Other: // Be conservative.
   case CodeCompletionContext::CCC_NaturalLanguage:
   case CodeCompletionContext::CCC_Recovery:
   case CodeCompletionContext::CCC_NewName:
     return false;
   }
   llvm_unreachable("unknown code completion context");

clang/include/clang/Parse/Parser.h

private:
   /// if this results in adding an attribute to the ParsedAttributes list.
   bool ParseCXX11AttributeArgs(IdentifierInfo *AttrName,
                                SourceLocation AttrNameLoc,
                                ParsedAttributes &Attrs, SourceLocation *EndLoc,
                                IdentifierInfo *ScopeName,
                                SourceLocation ScopeLoc,
                                CachedTokens &OpenMPTokens);
 
-  IdentifierInfo *TryParseCXX11AttributeIdentifier(SourceLocation &Loc);
+  IdentifierInfo *TryParseCXX11AttributeIdentifier(
+      SourceLocation &Loc,
+      Sema::AttributeCompletion Completion = Sema::AttributeCompletion::None,
+      const IdentifierInfo *EnclosingScope = nullptr);
 
   void MaybeParseMicrosoftAttributes(ParsedAttributes &attrs,
                                      SourceLocation *endLoc = nullptr) {
     if (getLangOpts().MicrosoftExt && Tok.is(tok::l_square))
       ParseMicrosoftAttributes(attrs, endLoc);
   }
   void ParseMicrosoftUuidAttributeArgs(ParsedAttributes &Attrs);
   void ParseMicrosoftAttributes(ParsedAttributes &attrs,

clang/include/clang/Sema/CodeCompleteConsumer.h

enum Kind {
     CCC_ObjCInterfaceName,
 
     /// Code completion where an Objective-C category name is expected.
     CCC_ObjCCategoryName,
 
     /// Code completion inside the filename part of a #include directive.
     CCC_IncludedFile,
 
+    /// Code completion of an attribute name.
+    CCC_Attribute,
+
     /// An unknown context, in which we are recovering from a parsing
     /// error and don't know which completions we should give.
     CCC_Recovery
   };
 
   using VisitedContextSet = llvm::SmallPtrSet<DeclContext *, 8>;
 
 private:

clang/include/clang/Sema/ParsedAttr.h

struct ParsedAttrInfo {
   /// Decl then do so and return either AttributeApplied if it was applied or
   /// AttributeNotApplied if it wasn't. Otherwise return NotHandled.
   virtual AttrHandling handleDeclAttribute(Sema &S, Decl *D,
                                            const ParsedAttr &Attr) const {
     return NotHandled;
   }
 
   static const ParsedAttrInfo &get(const AttributeCommonInfo &A);
+  static ArrayRef<const ParsedAttrInfo *> getAllBuiltin();
 };
 
 typedef llvm::Registry<ParsedAttrInfo> ParsedAttrInfoRegistry;
 
 /// Represents information about a change in availability for
 /// an entity, which is part of the encoding of the 'availability'
 /// attribute.
 struct AvailabilityChange {

clang/include/clang/Sema/Sema.h

public:
   void CodeCompletePostfixExpression(Scope *S, ExprResult LHS,
                                      QualType PreferredType);
   void CodeCompleteTag(Scope *S, unsigned TagSpec);
   void CodeCompleteTypeQualifiers(DeclSpec &DS);
   void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
                                       const VirtSpecifiers *VS = nullptr);
   void CodeCompleteBracketDeclarator(Scope *S);
   void CodeCompleteCase(Scope *S);
+  enum class AttributeCompletion {
+    Attribute,
+    Scope,
+    None,
+  };
+  void CodeCompleteAttribute(
+      AttributeCommonInfo::Syntax Syntax,
+      AttributeCompletion Completion = AttributeCompletion::Attribute,
+      const IdentifierInfo *Scope = nullptr);
   /// Determines the preferred type of the current function argument, by
   /// examining the signatures of all possible overloads.
   /// Returns null if unknown or ambiguous, or if code completion is off.
   ///
   /// If the code completion point has been reached, also reports the function
   /// signatures that were considered.
   ///
   /// FIXME: rename to GuessCallArgumentType to reduce confusion.

clang/lib/Frontend/ASTUnit.cpp

static void CalculateHiddenNames(const CodeCompletionContext &Context,
   case CodeCompletionContext::CCC_SelectorName:
   case CodeCompletionContext::CCC_TypeQualifiers:
   case CodeCompletionContext::CCC_Other:
   case CodeCompletionContext::CCC_OtherWithMacros:
   case CodeCompletionContext::CCC_ObjCInstanceMessage:
   case CodeCompletionContext::CCC_ObjCClassMessage:
   case CodeCompletionContext::CCC_ObjCCategoryName:
   case CodeCompletionContext::CCC_IncludedFile:
+  case CodeCompletionContext::CCC_Attribute:
   case CodeCompletionContext::CCC_NewName:
     // We're looking for nothing, or we're looking for names that cannot
     // be hidden.
     return;
   }
 
   using Result = CodeCompletionResult;
   for (unsigned I = 0; I != NumResults; ++I) {

clang/lib/Parse/ParseDecl.cpp

while (Tok.is(tok::kw___attribute)) {
     do {
       // Eat preceeding commas to allow __attribute__((,,,foo))
       while (TryConsumeToken(tok::comma))
         ;
 
       // Expect an identifier or declaration specifier (const, int, etc.)
       if (Tok.isAnnotation())
         break;
+      if (Tok.is(tok::code_completion)) {
+        cutOffParsing();
+        Actions.CodeCompleteAttribute(AttributeCommonInfo::Syntax::AS_GNU);
+        break;
+      }
       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
       if (!AttrName)
         break;
 
       SourceLocation AttrNameLoc = ConsumeToken();
 
       if (Tok.isNot(tok::l_paren)) {
         Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
while (Tok.is(tok::kw___declspec)) {
 
     // An empty declspec is perfectly legal and should not warn.  Additionally,
     // you can specify multiple attributes per declspec.
     while (Tok.isNot(tok::r_paren)) {
       // Attribute not present.
       if (TryConsumeToken(tok::comma))
         continue;
 
+      if (Tok.is(tok::code_completion)) {
+        cutOffParsing();
+        Actions.CodeCompleteAttribute(AttributeCommonInfo::AS_Declspec);
+        return;
+      }
+
       // We expect either a well-known identifier or a generic string.  Anything
       // else is a malformed declspec.
       bool IsString = Tok.getKind() == tok::string_literal;
       if (!IsString && Tok.getKind() != tok::identifier &&
           Tok.getKind() != tok::kw_restrict) {
         Diag(Tok, diag::err_ms_declspec_type);
         T.skipToEnd();
         return;

clang/lib/Parse/ParseDeclCXX.cpp

 ///
 /// \return the parsed identifier on success, and 0 if the next token is not an
 /// attribute-token.
 ///
 /// C++11 [dcl.attr.grammar]p3:
 ///   If a keyword or an alternative token that satisfies the syntactic
 ///   requirements of an identifier is contained in an attribute-token,
 ///   it is considered an identifier.
-IdentifierInfo *Parser::TryParseCXX11AttributeIdentifier(SourceLocation &Loc) {
+IdentifierInfo *
+Parser::TryParseCXX11AttributeIdentifier(SourceLocation &Loc,
+                                         Sema::AttributeCompletion Completion,
+                                         const IdentifierInfo *Scope) {
   switch (Tok.getKind()) {
   default:
     // Identifiers and keywords have identifier info attached.
     if (!Tok.isAnnotation()) {
       if (IdentifierInfo *II = Tok.getIdentifierInfo()) {
         Loc = ConsumeToken();
         return II;
       }
     }
     return nullptr;
 
+  case tok::code_completion:
+    cutOffParsing();
+    Actions.CodeCompleteAttribute(getLangOpts().CPlusPlus ? ParsedAttr::AS_CXX11
+                                                          : ParsedAttr::AS_C2x,
+                                  Completion, Scope);
+    return nullptr;
+
   case tok::numeric_constant: {
     // If we got a numeric constant, check to see if it comes from a macro that
     // corresponds to the predefined __clang__ macro. If it does, warn the user
     // and recover by pretending they said _Clang instead.
     if (Tok.getLocation().isMacroID()) {
       SmallString<8> ExpansionBuf;
       SourceLocation ExpansionLoc =
           PP.getSourceManager().getExpansionLoc(Tok.getLocation());
void Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs,
   SourceLocation CommonScopeLoc;
   IdentifierInfo *CommonScopeName = nullptr;
   if (Tok.is(tok::kw_using)) {
     Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
                                 ? diag::warn_cxx14_compat_using_attribute_ns
                                 : diag::ext_using_attribute_ns);
     ConsumeToken();
 
-    CommonScopeName = TryParseCXX11AttributeIdentifier(CommonScopeLoc);
+    CommonScopeName = TryParseCXX11AttributeIdentifier(
+        CommonScopeLoc, Sema::AttributeCompletion::Scope);
     if (!CommonScopeName) {
       Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
       SkipUntil(tok::r_square, tok::colon, StopBeforeMatch);
     }
     if (!TryConsumeToken(tok::colon) && CommonScopeName)
       Diag(Tok.getLocation(), diag::err_expected) << tok::colon;
   }
 
while (!Tok.isOneOf(tok::r_square, tok::semi, tok::eof)) {
 
     // Eat all remaining superfluous commas before parsing the next attribute.
     while (TryConsumeToken(tok::comma))
       ;
 
     SourceLocation ScopeLoc, AttrLoc;
     IdentifierInfo *ScopeName = nullptr, *AttrName = nullptr;
 
-    AttrName = TryParseCXX11AttributeIdentifier(AttrLoc);
+    AttrName = TryParseCXX11AttributeIdentifier(
+        AttrLoc, Sema::AttributeCompletion::Attribute, CommonScopeName);
     if (!AttrName)
       // Break out to the "expected ']'" diagnostic.
       break;
 
     // scoped attribute
     if (TryConsumeToken(tok::coloncolon)) {
       ScopeName = AttrName;
       ScopeLoc = AttrLoc;
 
-      AttrName = TryParseCXX11AttributeIdentifier(AttrLoc);
+      AttrName = TryParseCXX11AttributeIdentifier(
+          AttrLoc, Sema::AttributeCompletion::Attribute, ScopeName);
       if (!AttrName) {
         Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
         SkipUntil(tok::r_square, tok::comma, StopAtSemi | StopBeforeMatch);
         continue;
       }
     }
 
     if (CommonScopeName) {
void Parser::ParseMicrosoftAttributes(ParsedAttributes &attrs,
 
   do {
     // FIXME: If this is actually a C++11 attribute, parse it as one.
     BalancedDelimiterTracker T(*this, tok::l_square);
     T.consumeOpen();
 
     // Skip most ms attributes except for a specific list.
     while (true) {
-      SkipUntil(tok::r_square, tok::identifier, StopAtSemi | StopBeforeMatch);
+      SkipUntil(tok::r_square, tok::identifier,
+                StopAtSemi | StopBeforeMatch | StopAtCodeCompletion);
+      if (Tok.is(tok::code_completion)) {
+        cutOffParsing();
+        Actions.CodeCompleteAttribute(AttributeCommonInfo::AS_Microsoft,
+                                      Sema::AttributeCompletion::Attribute,
+                                      /*Scope=*/nullptr);
+        break;
+      }
       if (Tok.isNot(tok::identifier)) // ']', but also eof
         break;
       if (Tok.getIdentifierInfo()->getName() == "uuid")
         ParseMicrosoftUuidAttributeArgs(attrs);
       else
         ConsumeToken();
     }
 

clang/lib/Parse/ParsePragma.cpp

void Parser::HandlePragmaAttribute() {
   } else if (Tok.is(tok::kw___attribute)) {
     ConsumeToken();
     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
                          "attribute"))
       return SkipToEnd();
     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "("))
       return SkipToEnd();
 
+    // FIXME: The practical usefulness of completion here is limited because
+    // we only get here if the line has balanced parens.
+    if (Tok.is(tok::code_completion)) {
+      cutOffParsing();
+      // FIXME: suppress completion of unsupported attributes?
+      Actions.CodeCompleteAttribute(AttributeCommonInfo::Syntax::AS_GNU);
+      return SkipToEnd();
+    }
+
     if (Tok.isNot(tok::identifier)) {
       Diag(Tok, diag::err_pragma_attribute_expected_attribute_name);
       SkipToEnd();
       return;
     }
     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
     SourceLocation AttrNameLoc = ConsumeToken();
 

clang/lib/Sema/CodeCompleteConsumer.cpp

bool CodeCompletionContext::wantConstructorResults() const {
   case CCC_TypeQualifiers:
   case CCC_Other:
   case CCC_OtherWithMacros:
   case CCC_ObjCInstanceMessage:
   case CCC_ObjCClassMessage:
   case CCC_ObjCInterfaceName:
   case CCC_ObjCCategoryName:
   case CCC_IncludedFile:
+  case CCC_Attribute:
     return false;
   }
 
   llvm_unreachable("Invalid CodeCompletionContext::Kind!");
 }
 
 StringRef clang::getCompletionKindString(CodeCompletionContext::Kind Kind) {
   using CCKind = CodeCompletionContext::Kind;
StringRef clang::getCompletionKindString(CodeCompletionContext::Kind Kind) {
   case CCKind::CCC_ObjCClassMessage:
     return "ObjCClassMessage";
   case CCKind::CCC_ObjCInterfaceName:
     return "ObjCInterfaceName";
   case CCKind::CCC_ObjCCategoryName:
     return "ObjCCategoryName";
   case CCKind::CCC_IncludedFile:
     return "IncludedFile";
+  case CCKind::CCC_Attribute:
+    return "Attribute";
   case CCKind::CCC_Recovery:
     return "Recovery";
   }
   llvm_unreachable("Invalid CodeCompletionContext::Kind!");
 }
 
 //===----------------------------------------------------------------------===//
 // Code completion string implementation

clang/lib/Sema/ParsedAttr.cpp

for (auto &S : Ptr->Spellings)
         return *Ptr;
 
   // If we failed to find a match then return a default ParsedAttrInfo.
   static const ParsedAttrInfo DefaultParsedAttrInfo(
       AttributeCommonInfo::UnknownAttribute);
   return DefaultParsedAttrInfo;
 }
 
+ArrayRef<const ParsedAttrInfo *> ParsedAttrInfo::getAllBuiltin() {
+  return AttrInfoMap;
+}
+
 unsigned ParsedAttr::getMinArgs() const { return getInfo().NumArgs; }
 
 unsigned ParsedAttr::getMaxArgs() const {
   return getMinArgs() + getInfo().OptArgs;
 }
 
 bool ParsedAttr::hasCustomParsing() const {
   return getInfo().HasCustomParsing;

clang/lib/Sema/SemaCodeComplete.cpp

 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/QualTypeNames.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Type.h"
+#include "clang/Basic/AttributeCommonInfo.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Designator.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Overload.h"
+#include "clang/Sema/ParsedAttr.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
 
   // Note that we intentionally suppress macro results here, since we do not
   // encourage using macros to produce the names of entities.
 
   HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
                             Results.data(), Results.size());
 }
 
+static const char *underscoreAttrScope(llvm::StringRef Scope) {
+  if (Scope == "clang")
+    return "_Clang";
+  if (Scope == "gnu")
+    return "__gnu__";
+  return nullptr;
+}
+
+static const char *noUnderscoreAttrScope(llvm::StringRef Scope) {
+  if (Scope == "_Clang")
+    return "clang";
+  if (Scope == "__gnu__")
+    return "gnu";
+  return nullptr;
+}
+
+void Sema::CodeCompleteAttribute(AttributeCommonInfo::Syntax Syntax,
+                                 AttributeCompletion Completion,
+                                 const IdentifierInfo *InScope) {
+  if (Completion == AttributeCompletion::None)
+    return;
+  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
+                        CodeCompleter->getCodeCompletionTUInfo(),
+                        CodeCompletionContext::CCC_Attribute);
+
+  // We're going to iterate over the normalized spellings of the attribute.
+  // These don't include "underscore guarding": the normalized spelling is
+  // clang::foo but you can also write _Clang::__foo__.
+  //
+  // (Clang supports a mix like clang::__foo__ but we won't suggest it: either
+  // you care about clashing with macros or you don't).
+  //
+  // So if we're already in a scope, we determine its canonical spellings
+  // (for comparison with normalized attr spelling) and remember whether it was
+  // underscore-guarded (so we know how to spell contained attributes).
+  llvm::StringRef InScopeName;
+  bool InScopeUnderscore = false;
+  if (InScope) {
+    InScopeName = InScope->getName();
+    if (const char *NoUnderscore = noUnderscoreAttrScope(InScopeName)) {
+      InScopeName = NoUnderscore;
+      InScopeUnderscore = true;
+    }
+  }
+  bool SyntaxSupportsGuards = Syntax == AttributeCommonInfo::AS_GNU ||
+                              Syntax == AttributeCommonInfo::AS_CXX11 ||
+                              Syntax == AttributeCommonInfo::AS_C2x;
+
+  llvm::DenseSet<llvm::StringRef> FoundScopes;
+  auto AddCompletions = [&](const ParsedAttrInfo &A) {
+    if (A.IsTargetSpecific && !A.existsInTarget(Context.getTargetInfo()))
+      return;
+    // FIXME: filter by langopts (diagLangOpts method requires a ParsedAttr)
+    for (const auto &S : A.Spellings) {
+      if (S.Syntax != Syntax)
+        continue;
+      llvm::StringRef Name = S.NormalizedFullName;
+      llvm::StringRef Scope;
+      if ((Syntax == AttributeCommonInfo::AS_CXX11 ||
+           Syntax == AttributeCommonInfo::AS_C2x)) {
+        std::tie(Scope, Name) = Name.split("::");
+        if (Name.empty()) // oops, unscoped
+          std::swap(Name, Scope);
+      }
+
+      // Do we just want a list of scopes rather than attributes?
+      if (Completion == AttributeCompletion::Scope) {
+        // Make sure to emit each scope only once.
+        if (!Scope.empty() && FoundScopes.insert(Scope).second) {
+          Results.AddResult(
+              CodeCompletionResult(Results.getAllocator().CopyString(Scope)));
+          // Include alternate form (__gnu__ instead of gnu).
+          if (const char *Scope2 = underscoreAttrScope(Scope))
+            Results.AddResult(CodeCompletionResult(Scope2));
+        }
+        continue;
+      }
+
+      // If a scope was specified, it must match but we don't need to print it.
+      if (!InScopeName.empty()) {
+        if (Scope != InScopeName)
+          continue;
+        Scope = "";
+      }
+
+      // Generate the non-underscore-guarded result.
+      // Note this is (a suffix of) the NormalizedFullName, no need to copy.
+      // If an underscore-guarded scope was specified, only the
+      // underscore-guarded attribute name is relevant.
+      if (!InScopeUnderscore)
+        Results.AddResult(Scope.empty() ? Name.data() : S.NormalizedFullName);
+
+      // Generate the underscore-guarded version, for syntaxes that support it.
+      // We skip this if the scope was already spelled and not guarded, or
+      // we must spell it and can't guard it.
+      if (!(InScope && !InScopeUnderscore) && SyntaxSupportsGuards) {
+        llvm::SmallString<32> Guarded;
+        if (!Scope.empty()) {
+          const char *GuardedScope = underscoreAttrScope(Scope);
+          if (!GuardedScope)
+            continue;
+          Guarded.append(GuardedScope);
+          Guarded.append("::");
+        }
+        Guarded.append("__");
+        Guarded.append(Name);
+        Guarded.append("__");
+        Results.AddResult(
+            CodeCompletionResult(Results.getAllocator().CopyString(Guarded)));
+      }
+
+      // FIXME: include the list of arg names (not currently exposed).
+      // It may be nice to include the Kind so we can look up the docs later.
+    }
+  };
+
+  for (const auto *A : ParsedAttrInfo::getAllBuiltin())
+    AddCompletions(*A);
+  for (const auto &Entry : ParsedAttrInfoRegistry::entries())
+    AddCompletions(*Entry.instantiate());
+
+  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
+                            Results.data(), Results.size());
+}
+
 struct Sema::CodeCompleteExpressionData {
   CodeCompleteExpressionData(QualType PreferredType = QualType(),
                              bool IsParenthesized = false)
       : PreferredType(PreferredType), IntegralConstantExpression(false),
         ObjCCollection(false), IsParenthesized(IsParenthesized) {}
 
   QualType PreferredType;
   bool IntegralConstantExpression;

clang/test/CodeCompletion/attr.cpp

+int a [[gnu::used]];
+// RUN: %clang_cc1 -code-completion-at=%s:1:9 %s | FileCheck --check-prefix=STD %s
+// STD:     COMPLETION: __carries_dependency__
+// STD-NOT: COMPLETION: __convergent__
+// STD:     COMPLETION: __gnu__::__used__
+// STD-NOT: COMPLETION: __gnu__::used
+// STD-NOT: COMPLETION: __used__
+// STD:     COMPLETION: _Clang::__convergent__
+// STD:     COMPLETION: carries_dependency
+// STD:     COMPLETION: clang::convergent
+// STD-NOT: COMPLETION: convergent
+// STD-NOT:     COMPLETION: gnu::__used__
+// STD:     COMPLETION: gnu::used
+// STD-NOT: COMPLETION: used
+// RUN: %clang_cc1 -code-completion-at=%s:1:14 %s | FileCheck --check-prefix=STD-NS %s
+// STD-NS-NOT: COMPLETION: __used__
+// STD-NS-NOT: COMPLETION: carries_dependency
+// STD-NS-NOT: COMPLETION: clang::convergent
+// STD-NS-NOT: COMPLETION: convergent
+// STD-NS-NOT: COMPLETION: gnu::used
+// STD-NS:     COMPLETION: used
+int b [[__gnu__::used]];
+// RUN: %clang_cc1 -code-completion-at=%s:22:18 %s | FileCheck --check-prefix=STD-NSU %s
+// STD-NSU:     COMPLETION: __used__
+// STD-NSU-NOT: COMPLETION: used
+
+int c [[using gnu: used]];
+// RUN: %clang_cc1 -code-completion-at=%s:27:15 %s | FileCheck --check-prefix=STD-USING %s
+// STD-USING:     COMPLETION: __gnu__
+// STD-USING:     COMPLETION: _Clang
+// STD-USING-NOT: COMPLETION: carries_dependency
+// STD-USING:     COMPLETION: clang
+// STD-USING-NOT: COMPLETION: clang::
+// STD-USING-NOT: COMPLETION: gnu::
+// STD-USING:     COMPLETION: gnu
+// RUN: %clang_cc1 -code-completion-at=%s:27:20 %s | FileCheck --check-prefix=STD-NS %s
+
+int d __attribute__((used));
+// RUN: %clang_cc1 -code-completion-at=%s:38:22 %s | FileCheck --check-prefix=GNU %s
+// GNU:     COMPLETION: __carries_dependency__
+// GNU:     COMPLETION: __convergent__
+// GNU-NOT: COMPLETION: __gnu__::__used__
+// GNU:     COMPLETION: __used__
+// GNU-NOT: COMPLETION: _Clang::__convergent__
+// GNU:     COMPLETION: carries_dependency
+// GNU-NOT: COMPLETION: clang::convergent
+// GNU:     COMPLETION: convergent
+// GNU-NOT: COMPLETION: gnu::used
+// GNU:     COMPLETION: used
+
+#pragma clang attribute push (__attribute__((internal_linkage)), apply_to=variable)
+int e;
+#pragma clang attribute pop
+// RUN: %clang_cc1 -code-completion-at=%s:51:46 %s | FileCheck --check-prefix=PRAGMA %s
+// PRAGMA: internal_linkage
+
+#ifdef MS_EXT
+int __declspec(thread) f;
+// RUN: %clang_cc1 -fms-extensions -DMS_EXT -code-completion-at=%s:58:16 %s | FileCheck --check-prefix=DS %s
+// DS-NOT: COMPLETION: __convergent__
+// DS-NOT: COMPLETION: __used__
+// DS-NOT: COMPLETION: clang::convergent
+// DS-NOT: COMPLETION: convergent
+// DS:     COMPLETION: thread
+// DS-NOT: COMPLETION: used
+// DS:     COMPLETION: uuid
+
+[uuid("123e4567-e89b-12d3-a456-426614174000")] struct g;
+// RUN: %clang_cc1 -fms-extensions -DMS_EXT -code-completion-at=%s:68:2 %s | FileCheck --check-prefix=MS %s
+// MS-NOT: COMPLETION: __uuid__
+// MS-NOT: COMPLETION: clang::convergent
+// MS-NOT: COMPLETION: convergent
+// MS-NOT: COMPLETION: thread
+// MS-NOT: COMPLETION: used
+// MS:     COMPLETION: uuid
+#endif // MS_EXT
+
+void foo() {
+  [[omp::sequence(directive(parallel), directive(critical))]]
+  {}
+}
+// FIXME: support for omp attributes would be nice.
+// RUN: %clang_cc1 -fopenmp -code-completion-at=%s:79:5 %s | FileCheck --check-prefix=OMP-NS --allow-empty %s
+// OMP-NS-NOT: omp
+// RUN: %clang_cc1 -fopenmp -code-completion-at=%s:79:10 %s | FileCheck --check-prefix=OMP-ATTR --allow-empty %s
+// OMP-ATTR-NOT: sequence
+// RUN: %clang_cc1 -fopenmp -code-completion-at=%s:79:19 %s | FileCheck --check-prefix=OMP-NESTED --allow-empty %s
+// OMP-NESTED-NOT: directive

clang/tools/libclang/CIndexCodeCompletion.cpp

switch (kind) {
     }
     case CodeCompletionContext::CCC_Other:
     case CodeCompletionContext::CCC_ObjCInterface:
     case CodeCompletionContext::CCC_ObjCImplementation:
     case CodeCompletionContext::CCC_NewName:
     case CodeCompletionContext::CCC_MacroName:
     case CodeCompletionContext::CCC_PreprocessorExpression:
     case CodeCompletionContext::CCC_PreprocessorDirective:
+    case CodeCompletionContext::CCC_Attribute:
     case CodeCompletionContext::CCC_TypeQualifiers: {
       //Only Clang results should be accepted, so we'll set all of the other
       //context bits to 0 (i.e. the empty set)
       contexts = CXCompletionContext_Unexposed;
       break;
     }
     case CodeCompletionContext::CCC_Recovery: {
       //We don't know what the current context is, so we'll return unknown