[Clang] Fix unknown type attributes diagnosed twice with [[]] spelling

[junaire]

Summary

Don't warn on unknown type attributes in Parser::ProhibitCXX11Attributes
for most cases, but left the diagnostic to the later checks.
module declaration and module import declaration are special cases.

Fixes https://github.com/llvm/llvm-project/issues/54817

[junaire]

Add a missing test.

[junaire]

Update the test.

[junaire]

Rename an argument for consistency.

[aaron.ballman]

Thank you for the fix! Can you add a release note for it as well?

LGTM aside from a minor nit with some comment wording and a testing suggestion.

clang/test/SemaCXX/warn-once-on-unknown-attr.cpp

2

Can you also add this RUN line?

// RUN: %clang_cc1 -fsyntax-only -verify -std=c2x -x c %s

Then we're verifying that we didn't do anything different for C.

[junaire]

Run test in C2x mode.

[junaire]

Add release note.

[junaire]

In D123447#3442780, @aaron.ballman wrote:

Thank you for the fix! Can you add a release note for it as well?

LGTM aside from a minor nit with some comment wording and a testing suggestion.

Hey Aaron, thanks for your review :) I'm not an expert in C or C++, so I'd appreciate it if you can provide better wording.

[aaron.ballman]

I did some minor changes to the release note, but otherwise LGTM!

clang/docs/ReleaseNotes.rst

116–117

clang/docs/ReleaseNotes.rst

- Unevaluated lambdas in dependant contexts no longer result in clang crashing.
   `51414 <https://github.com/llvm/llvm-project/issues/51414>`_,
   `51416 <https://github.com/llvm/llvm-project/issues/51416>`_,
   and `51641 <https://github.com/llvm/llvm-project/issues/51641>`_.
 - The builtin function __builtin_dump_struct would crash clang when the target 
   struct contains a bitfield. It now correctly handles bitfields.
   This fixes Issue `Issue 54462 <https://github.com/llvm/llvm-project/issues/54462>`_.
 - Statement expressions are now disabled in default arguments in general.
   This fixes Issue `Issue 53488 <https://github.com/llvm/llvm-project/issues/53488>`_.
 - According to `CWG 1394 <https://wg21.link/cwg1394>`_ and 
   `C++20 [dcl.fct.def.general]p2 <https://timsong-cpp.github.io/cppwp/n4868/dcl.fct.def#general-2.sentence-3>`_,
   Clang should not diagnose incomplete types in function definitions if the function body is "= delete;".
   This fixes Issue `Issue 52802 <https://github.com/llvm/llvm-project/issues/52802>`_.
+- Unknown type attributes with a ``[[]]`` spelling are no longer diagnosed twice.
+  This fixes Issue `Issue 54817 <https://github.com/llvm/llvm-project/issues/54817>`_.
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - ``-Wliteral-range`` will warn on floating-point equality comparisons with
   constants that are not representable in a casted value. For example,
   ``(float) f == 0.1`` is always false.
 - ``-Winline-namespace-reopened-noninline`` now takes into account that the
   ``inline`` keyword must appear on the original but not necessarily all

clang/include/clang/Parse/Parser.h

void ProhibitAttributes(ParsedAttributesView &Attrs,
     Attrs.clearListOnly();
   }
   void DiagnoseProhibitedAttributes(const SourceRange &Range,
                                     SourceLocation FixItLoc);
 
   // Forbid C++11 and C2x attributes that appear on certain syntactic locations
   // which standard permits but we don't supported yet, for example, attributes
   // appertain to decl specifiers.
+  // For the most cases we don't want to warn on unknown type attributes, but
+  // left them to later diagnoses. However, for a few cases like module
+  // declarations and module import declarations, we should do it.
   void ProhibitCXX11Attributes(ParsedAttributes &Attrs, unsigned DiagID,
-                               bool DiagnoseEmptyAttrs = false);
+                               bool DiagnoseEmptyAttrs = false,
+                               bool WarnOnUnknownAttrs = false);
 
   /// Skip C++11 and C2x attributes and return the end location of the
   /// last one.
   /// \returns SourceLocation() if there are no attributes.
   SourceLocation SkipCXX11Attributes();
 
   /// Diagnose and skip C++11 and C2x attributes that appear in syntactic
   /// locations where attributes are not allowed.

clang/lib/Parse/ParseDecl.cpp

if (CorrectLocation.isValid()) {
     Diag(CorrectLocation, diag::err_attributes_misplaced)
         << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
         << FixItHint::CreateRemoval(AttrRange);
   } else
     Diag(Range.getBegin(), diag::err_attributes_not_allowed) << Range;
 }
 
 void Parser::ProhibitCXX11Attributes(ParsedAttributes &Attrs, unsigned DiagID,
-                                     bool DiagnoseEmptyAttrs) {
+                                     bool DiagnoseEmptyAttrs,
+                                     bool WarnOnUnknownAttrs) {
 
   if (DiagnoseEmptyAttrs && Attrs.empty() && Attrs.Range.isValid()) {
     // An attribute list has been parsed, but it was empty.
     // This is the case for [[]].
     const auto &LangOpts = getLangOpts();
     auto &SM = PP.getSourceManager();
     Token FirstLSquare;
     Lexer::getRawToken(Attrs.Range.getBegin(), FirstLSquare, SM, LangOpts);
if (FirstLSquare.is(tok::l_square)) {
         return;
       }
     }
   }
 
   for (const ParsedAttr &AL : Attrs) {
     if (!AL.isCXX11Attribute() && !AL.isC2xAttribute())
       continue;
-    if (AL.getKind() == ParsedAttr::UnknownAttribute)
+    if (AL.getKind() == ParsedAttr::UnknownAttribute) {
+      if (WarnOnUnknownAttrs)
         Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
             << AL << AL.getRange();
-    else {
+    } else {
       Diag(AL.getLoc(), DiagID) << AL;
       AL.setInvalid();
     }
   }
 }
 
 void Parser::DiagnoseCXX11AttributeExtension(ParsedAttributes &Attrs) {
   for (const ParsedAttr &PA : Attrs) {

clang/lib/Parse/Parser.cpp

if (Tok.is(tok::colon)) {
     // Recover by ignoring the partition name.
     else if (ParseModuleName(ModuleLoc, Partition, /*IsImport*/ false))
       return nullptr;
   }
 
   // We don't support any module attributes yet; just parse them and diagnose.
   ParsedAttributes Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs);
-  ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr);
+  ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr,
+                          /*DiagnoseEmptyAttrs=*/false,
+                          /*WarnOnUnknownAttrs=*/true);
 
   ExpectAndConsumeSemi(diag::err_module_expected_semi);
 
   return Actions.ActOnModuleDecl(StartLoc, ModuleLoc, MDK, Path, Partition,
                                  ImportState);
 }
 
 /// Parse a module import declaration. This is essentially the same for
Decl *Parser::ParseModuleImport(SourceLocation AtLoc,
   } else {
     if (ParseModuleName(ImportLoc, Path, /*IsImport*/ true))
       return nullptr;
   }
 
   ParsedAttributes Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs);
   // We don't support any module import attributes yet.
-  ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr);
+  ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr,
+                          /*DiagnoseEmptyAttrs=*/false,
+                          /*WarnOnUnknownAttrs=*/true);
 
   if (PP.hadModuleLoaderFatalFailure()) {
     // With a fatal failure in the module loader, we abort parsing.
     cutOffParsing();
     return nullptr;
   }
 
   // Diagnose mis-imports.

clang/test/SemaCXX/warn-once-on-unknown-attr.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c2x -x c %s
+void foo() {
+  int [[attr]] i;             // expected-warning {{unknown attribute 'attr' ignored}}
+  (void)sizeof(int [[attr]]); // expected-warning {{unknown attribute 'attr' ignored}}
+}
+
+void bar() {
+  [[attr]];       // expected-warning {{unknown attribute 'attr' ignored}}
+  [[attr]] int i; // expected-warning {{unknown attribute 'attr' ignored}}
+}