[clang][DeclPrinter] Improve AST print of function attributes

[strimo378]

Summary

The commit improves the AST print output of function attributes. In the previous version, all attributes were output after the function declaration. This is correct for most attributes but e.g. not for [[noreturn]]. Now it is decided for each attribues if it should be output before or after function declaration. It follows the following rule:

• All [[...]] attributes are placed before declaration
• __declspec attributes are placed before declaration as requested by Microsoft ... https://learn.microsoft.com/en-us/cpp/cpp/declspec?view=msvc-170
• Some keyword are placed after the declaration
• Without a function body attributes are placed after declaration
• With a function body attributes are placed before declaration because GCC produces are error and Clang a warning otherwise

[strimo378]

Finish version

[aaron.ballman]

This is looking to make similar changes to the ones proposed in https://reviews.llvm.org/D141714 -- can you coordinate with the other author so there's only one review that covers both needs?

[strimo378]

Using Attr::getSyntax function (instead of unnecessarly added Attr::getVariety function)

[giulianobelinassi]

This patch do not address attributes in variables nor the __declspec case, as D141714 do. His patch looks cleaner and I can surely coordinate with @strimo378 to also fix those cases, but I want an answer to the tblgen question first to see if we decide to drop the tblgen solution or not.

clang/lib/AST/DeclPrinter.cpp

259

@aaron.ballman @erichkeane

Is this enough to describe the position of the attribute kind, or should it go for a tblgen approach, as I did in D141714? This here looks much cleaner than the tblgen IMHO.

283

You can use A->isStandardAttributeSyntax()

286

I am pretty sure this function when called with AttrLocation::BeforeDecl will print an extra space before it prints out the attribute. Unfortunately to fix this it needs to be print into a string and then remove the first space from the generated string. Or do something more clever and patch printPretty so it does not do that.

[aaron.ballman]

In D157394#4572777, @giulianobelinassi wrote:

This patch do not address attributes in variables nor the __declspec case, as D141714 do. His patch looks cleaner and I can surely coordinate with @strimo378 to also fix those cases, but I want an answer to the tblgen question first to see if we decide to drop the tblgen solution or not.

Yeah, the two patches are trying to solve the same problem but for different parts of the language.

In terms of the tablegen approach, what you have in D141714 is along the same lines of what I was thinking of, though I've not had the chance to give it a thorough review yet. It keeps all of the knowledge about the specifics of the attributes in Attr.td instead of putting special per-attribute logic into the declaration printer, which is what I was mostly concerned about.

clang/lib/AST/DeclPrinter.cpp

259

Oofda, I forgot that we model those as keyword attributes. override and final (and other keyword attributes) are a bit trickier than just "before" or "after" because there's a very particular order in which those can be parsed grammatically, especially for functions: https://godbolt.org/z/ad5qecbrj

Thinking out loud: perhaps an approach to solving this is to sort the attributes by source location. So all the before attributes are written in the same order as they were in source, as are all of the after attributes. So long as we're skipping over implicit attributes, this seems like it should keep the order of the attributes correct.

A different alternative that's possibly more work than it's worth: the decl printer could dispatch to a table-genned function to ask the attribute "do you want to be printed now?" based on what part of the declaration we've already printed. This would require the decl printer to know e.g., "I've finished printing the parameter list but haven't yet printed cv qualifiers" and pass that information along to the attribute; individual attributes with special rules could supply special logic in Attr.td to say "the attribute should be printed after the function parameter list and after the cv and ref qualifiers, but before the override/final keywords" while most attributes can hopefully get away with whatever the default behavior is coming out of tablegen.

[giulianobelinassi]

clang/lib/AST/DeclPrinter.cpp

259

Oofda, I forgot that we model those as keyword attributes. override and final (and other keyword attributes) are a bit trickier than just "before" or "after" because there's a very particular order in which those can be parsed grammatically, especially for functions: https://godbolt.org/z/ad5qecbrj

Thinking out loud: perhaps an approach to solving this is to sort the attributes by source location. So all the before attributes are written in the same order as they were in source, as are all of the after attributes. So long as we're skipping over implicit attributes, this seems like it should keep the order of the attributes correct.

This may work in cases where clang is able to find the SourceLocation of the Decl. My concern is when clang is *not* able to do it. When analyzing Linux sourcecode there are cases where this happen, and I have to fallback to AST dumping. The only way I see this working is by changing the parser for it to mark the attribute and its position. This may be something for the future, but the presented fix solves the issue for the cases we have already found.

A different alternative that's possibly more work than it's worth: the decl printer could dispatch to a table-genned function to ask the attribute "do you want to be printed now?" based on what part of the declaration we've already printed. This would require the decl printer to know e.g., "I've finished printing the parameter list but haven't yet printed cv qualifiers" and pass that information along to the attribute; individual attributes with special rules could supply special logic in Attr.td to say "the attribute should be printed after the function parameter list and after the cv and ref qualifiers, but before the override/final keywords" while most attributes can hopefully get away with whatever the default behavior is coming out of tablegen.

Sounds a lot of work :). Wouldn't my previous suggestion be simpler?

[strimo378]

In D157394#4572777, @giulianobelinassi wrote:

This patch do not address attributes in variables nor the __declspec case, as D141714 do. His patch looks cleaner and I can surely coordinate with @strimo378 to also fix those cases, but I want an answer to the tblgen question first to see if we decide to drop the tblgen solution or not.

The patch is intended to only address function attributes to keep it simple and the test cases focused. Most important is that the AttrLocation is introduced and functionality can be easily extended to other decl types in subsequent patches. I did some work to address variable and record attributes but I think that I did not consider all cases for variables as you did.

__declspec should be always placed left?

clang/lib/AST/DeclPrinter.cpp

259

Currently, I would not go for a tblgen approach since we do not know all factors that influence the position. The current logic is relatively simple. I don't know how many additional exceptions are required.

I know for now that the position is influence by the target (function, record, field, parameter), attribute type and attribute syntax. To make matters worse, some attributes can be used for different targets. E.g. FinalAttr can be used for methods and records.

I suggest to keep things simple, stay on a function approach and see how complexity is evolving with future patches. Then we have the best knowledge to find a good tblgen solution.

259

Thinking out loud: perhaps an approach to solving this is to sort the attributes by source location. So all the before attributes are written in the same order as they were in source, as are all of the after attributes. So long as we're skipping over implicit attributes, this seems like it should keep the order of the attributes correct.

I also thought about that approach to decided on the location if it is placed before or after. I do a lot of AST modification where the location is lost or wrong. So for me that would not work in general.

283

Yes, ok

286

Yes, you are fully right. The goal was to keep the patch simple.

To address the space problem, I think the best way would be to extend tblgen and add an optional bool parameter to printPritty function that allows suppressing the extra space. That could be addressed in a subsequent patch.

[strimo378]

Added more test cases and considering __declspec

[strimo378]

clang/lib/AST/DeclPrinter.cpp

283

I checked isStandardAttributeSyntax(). I cannot use it since it also includes the alignas keyword for some strange reason.

clang/lib/AST/DeclPrinter.cpp

namespace {
 
   public:
     DeclPrinter(raw_ostream &Out, const PrintingPolicy &Policy,
                 const ASTContext &Context, unsigned Indentation = 0,
                 bool PrintInstantiation = false)
         : Out(Out), Policy(Policy), Context(Context), Indentation(Indentation),
           PrintInstantiation(PrintInstantiation) {}
 
+    enum class AttrLocation {
+      Unspecified,
+      Pragma,
+      BeforeDecl,
+      AfterDecl,
+      Ignore,
+    };
+
     void VisitDeclContext(DeclContext *DC, bool Indent = true);
 
     void VisitTranslationUnitDecl(TranslationUnitDecl *D);
     void VisitTypedefDecl(TypedefDecl *D);
     void VisitTypeAliasDecl(TypeAliasDecl *D);
     void VisitEnumDecl(EnumDecl *D);
     void VisitRecordDecl(RecordDecl *D);
     void VisitEnumConstantDecl(EnumConstantDecl *D);
public:
     void VisitHLSLBufferDecl(HLSLBufferDecl *D);
 
     void printTemplateParameters(const TemplateParameterList *Params,
                                  bool OmitTemplateKW = false);
     void printTemplateArguments(llvm::ArrayRef<TemplateArgument> Args,
                                 const TemplateParameterList *Params);
     void printTemplateArguments(llvm::ArrayRef<TemplateArgumentLoc> Args,
                                 const TemplateParameterList *Params);
-    void prettyPrintAttributes(Decl *D);
+    AttrLocation getAttrLocation(Decl *D, Attr *A);
+    void prettyPrintAttributes(Decl *D,
+                               AttrLocation AL = AttrLocation::Unspecified);
     void prettyPrintPragmas(Decl *D);
     void printDeclType(QualType T, StringRef DeclName, bool Pack = false);
   };
 }
 
 void Decl::print(raw_ostream &Out, unsigned Indentation,
                  bool PrintInstantiation) const {
   print(Out, getASTContext().getPrintingPolicy(), Indentation, PrintInstantiation);

 }
 
 raw_ostream& DeclPrinter::Indent(unsigned Indentation) {
   for (unsigned i = 0; i != Indentation; ++i)
     Out << "  ";
   return Out;
 }
 
-void DeclPrinter::prettyPrintAttributes(Decl *D) {
-  if (Policy.PolishForDeclaration)
-    return;
+DeclPrinter::AttrLocation DeclPrinter::getAttrLocation(Decl *D, Attr *A) {
+  auto S = A->getSyntax();
+  if (S == Attr::AS_Pragma)
+    return AttrLocation::Pragma;
 
-  if (D->hasAttrs()) {
-    AttrVec &Attrs = D->getAttrs();
-    for (auto *A : Attrs) {
-      if (A->isInherited() || A->isImplicit())
-        continue;
-      switch (A->getKind()) {
-#define ATTR(X)
-#define PRAGMA_SPELLING_ATTR(X) case attr::X:
-#include "clang/Basic/AttrList.inc"
-        break;
-      default:
-        A->printPretty(Out, Policy);
-        break;
-      }
+    return AttrLocation::Ignore;
+
+  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
+    case attr::AsmLabel:
+    case attr::Final:
+    case attr::Override:
+      return AttrLocation::AfterDecl;
+
+
+    // C2x/C++11-style attributes must appear before the declarator.
+    if (S == Attr::AS_CXX11 || S == Attr::AS_C2x)
+      return AttrLocation::BeforeDecl;
+
+    // The __declspec keywords should be placed at the beginning of a simple
+    // declaration, see
+    // https://learn.microsoft.com/en-us/cpp/cpp/declspec?view=msvc-170
+    if (S == Attr::AS_Declspec)
+      return AttrLocation::BeforeDecl;
+
+    if (FD->doesThisDeclarationHaveABody()) {
+      return AttrLocation::BeforeDecl;
+    } else {
+      return AttrLocation::AfterDecl;
     }
+  } else {
+    return AttrLocation::Unspecified;
   }
 }
 
-void DeclPrinter::prettyPrintPragmas(Decl *D) {
+void DeclPrinter::prettyPrintAttributes(Decl *D, AttrLocation AL) {
   if (Policy.PolishForDeclaration)
     return;
 
   if (D->hasAttrs()) {
     AttrVec &Attrs = D->getAttrs();
+    bool PrintAttr = false;
     for (auto *A : Attrs) {
-      switch (A->getKind()) {
-#define ATTR(X)
-#define PRAGMA_SPELLING_ATTR(X) case attr::X:
-#include "clang/Basic/AttrList.inc"
-        A->printPretty(Out, Policy);
+      if (getAttrLocation(D, A) != AL)
+        continue;
+
+      if (AL == AttrLocation::Pragma)
         Indent();
-        break;
-      default:
-        break;
-      }
-    }
-  }
+      PrintAttr = true;
+
+    if (PrintAttr && AL == AttrLocation::BeforeDecl)
+      Out << " ";
+
+void DeclPrinter::prettyPrintPragmas(Decl *D) {
+  prettyPrintAttributes(D, AttrLocation::Pragma);
 }
 
 void DeclPrinter::printDeclType(QualType T, StringRef DeclName, bool Pack) {
   // Normally, a PackExpansionType is written as T[3]... (for instance, as a
   // template argument), but if it is the type of a declaration, the ellipsis
   // is placed before the name being declared.
   if (auto *PET = T->getAs<PackExpansionType>()) {
     Pack = true;
void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
   if (D->isFunctionTemplateSpecialization())
     Out << "template<> ";
   else if (!D->getDescribedFunctionTemplate()) {
     for (unsigned I = 0, NumTemplateParams = D->getNumTemplateParameterLists();
          I < NumTemplateParams; ++I)
       printTemplateParameters(D->getTemplateParameterList(I));
   }
 
+  // [[...]] attributes must be printed before static, inline, virtual, etc.
+  prettyPrintAttributes(D, AttrLocation::BeforeDecl);
+
   CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(D);
   CXXConversionDecl *ConversionDecl = dyn_cast<CXXConversionDecl>(D);
   CXXDeductionGuideDecl *GuideDecl = dyn_cast<CXXDeductionGuideDecl>(D);
   if (!Policy.SuppressSpecifiers) {
     switch (D->getStorageClass()) {
     case SC_None: break;
     case SC_Extern: Out << "extern "; break;
     case SC_Static: Out << "static "; break;
if (Expr *TrailingRequiresClause = D->getTrailingRequiresClause()) {
       Out << " requires ";
       TrailingRequiresClause->printPretty(Out, nullptr, SubPolicy, Indentation,
                                           "\n", &Context);
     }
   } else {
     Ty.print(Out, Policy, Proto);
   }
 
-  prettyPrintAttributes(D);
+  prettyPrintAttributes(D, AttrLocation::AfterDecl);
 
   if (D->isPure())
     Out << " = 0";
   else if (D->isDeletedAsWritten())
     Out << " = delete";
   else if (D->isExplicitlyDefaulted())
     Out << " = default";
   else if (D->doesThisDeclarationHaveABody()) {

clang/test/AST/ast-print-method-decl.cpp

-// RUN: %clang_cc1 -ast-print -triple i386-linux-gnu %s -o - -std=c++20 | FileCheck %s
+// RUN: %clang_cc1 -ast-print -triple i386-linux-gnu -fdeclspec %s -o - -std=c++20 | FileCheck %s
 
 // CHECK: struct DelegatingCtor1 {
 struct DelegatingCtor1 {
   // CHECK-NEXT: DelegatingCtor1();
   DelegatingCtor1();
 
   // CHECK-NEXT: DelegatingCtor1(int) : DelegatingCtor1() {
   DelegatingCtor1(int) : DelegatingCtor1() {
struct ImplicitCtorInit2 : ImplicitCtorInit1 {
 
   // CHECK-NEXT: ImplicitCtorInit2(int **) : ImplicitCtorInit1() {
   ImplicitCtorInit2(int **) : ImplicitCtorInit1() {
   // CHECK-NEXT: }
   }
 
   // CHECK-NEXT: };
 };
+
+
+// CHECK: struct MethodAttr1 {
+struct MethodAttr1 {
+  // CHECK-NEXT: virtual void f1() & = 0;
+  virtual void f1() & = 0;
+
+  // CHECK-NEXT: virtual void f2();
+  virtual void f2();
+
+  // CHECK-NEXT: };
+};
+
+  // CHECK-NEXT: struct MethodAttr2 : MethodAttr1 {
+struct MethodAttr2 : MethodAttr1 {
+  // CHECK-NEXT: MethodAttr2() = default;
+  MethodAttr2() = default;
+
+  // CHECK-NEXT: explicit MethodAttr2(int);
+  explicit MethodAttr2(int);
+
+  // CHECK-NEXT: void f1() & override;
+  void f1() & override;
+
+  // CHECK-NEXT: virtual void f2() final;
+  virtual void f2() final;
+
+  // CHECK-NEXT: static void f3();
+  static void f3();
+
+  // CHECK-NEXT: {{\[\[}}noreturn]] static inline void f4();
+  [[noreturn]] static inline void f4();
+
+  // CHECK-NEXT: void f5() noexcept(10 > 1);
+  void f5() noexcept(10 > 1);
+
+  // CHECK-NEXT: void f6() asm("f6.2");
+  void f6() asm("f6.2");
+
+  // FIXME: Noreturn attribute is attached to FunctionProtoType and not print
+  // CHECK-NEXT: void f7();
+  void f7() __attribute__((noreturn));
+
+  // CHECK-NEXT: __declspec(deprecated("bad")) void f8();
+  __declspec(deprecated("bad")) void f8();
+
+  // CHECK-NEXT: };
+};

clang/test/AST/ast-print-no-sanitize.cpp

 // RUN: %clang_cc1 -std=c++11 -ast-print %s -o - | FileCheck %s
 
 void should_not_crash_1() __attribute__((no_sanitize_memory));
 [[clang::no_sanitize_memory]] void should_not_crash_2();
 
 // CHECK: void should_not_crash_1() __attribute__((no_sanitize("memory")));
-// CHECK: void should_not_crash_2() {{\[\[}}clang::no_sanitize("memory"){{\]\]}};
+// CHECK: {{\[\[}}clang::no_sanitize("memory"){{\]\]}} void should_not_crash_2();

clang/test/OpenMP/assumes_codegen.cpp

 
 #pragma omp begin assumes ext_lambda_assumption
 int lambda_outer() {
   auto lambda_inner = []() { return 42; };
   return lambda_inner();
 }
 #pragma omp end assumes
 
-// AST:      void foo() __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) {
+// AST:      __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) void foo() {
 // AST-NEXT: }
 // AST-NEXT: class BAR {
 // AST-NEXT: public:
-// AST-NEXT:     BAR() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) BAR()  {
 // AST-NEXT:     }
-// AST-NEXT:     void bar1() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) void bar1() {
 // AST-NEXT:     }
-// AST-NEXT:     static void bar2() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) static void bar2() {
 // AST-NEXT:     }
 // AST-NEXT: };
-// AST-NEXT: void bar() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) {
+// AST-NEXT: __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) void bar() {
 // AST-NEXT:     BAR b;
 // AST-NEXT: }
 // AST-NEXT: void baz() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")));
 // AST-NEXT: template <typename T> class BAZ {
 // AST-NEXT: public:
-// AST-NEXT:     BAZ<T>() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) BAZ<T>() {
 // AST-NEXT:     }
-// AST-NEXT:     void baz1() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) void baz1() {
 // AST-NEXT:     }
-// AST-NEXT:     static void baz2() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))     {
+// AST-NEXT:     __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) static void baz2() {
 // AST-NEXT:     }
 // AST-NEXT: };
 // AST-NEXT: template<> class BAZ<float> {
 // AST-NEXT: public:
-// AST-NEXT:     BAZ() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")))    {
+// AST-NEXT:     __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) BAZ() {
 // AST-NEXT:     }
 // AST-NEXT:     void baz1() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")));
 // AST-NEXT:     static void baz2() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp")));
 // AST-NEXT: };
-// AST-NEXT: void baz() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) {
+// AST-NEXT: __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) void baz() {
 // AST-NEXT:     BAZ<float> b;
 // AST-NEXT: }
-// AST-NEXT: int lambda_outer() __attribute__((assume("ompx_lambda_assumption"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) {
+// AST-NEXT: __attribute__((assume("ompx_lambda_assumption"))) __attribute__((assume("omp_no_openmp_routines,ompx_another_warning,ompx_after_invalid_clauses"))) __attribute__((assume("omp_no_openmp"))) int lambda_outer() {
 // AST-NEXT:     auto lambda_inner = []() {
 // AST-NEXT:         return 42;
 // AST-NEXT:     };
 // AST-NEXT:     return lambda_inner();
 // AST-NEXT: }
 
 #endif
 

clang/test/OpenMP/assumes_print.cpp

 #pragma omp begin assumes ext_not_seen
 #pragma omp end assumes
 
 #pragma omp begin assumes ext_1234
 void baz() {
 }
 #pragma omp end assumes
 
-// CHECK: void foo() __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp")))
-// CHECK: void bar() __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp")))
-// CHECK: void baz() __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp")))
+// CHECK: __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp"))) void foo()
+// CHECK: __attribute__((assume("ompx_range_bar_only"))) __attribute__((assume("ompx_range_bar_only_2"))) __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp"))) void bar()
+// CHECK: __attribute__((assume("ompx_1234"))) __attribute__((assume("omp_no_openmp_routines"))) __attribute__((assume("omp_no_openmp"))) void baz()
 
 #endif

clang/test/OpenMP/assumes_template_print.cpp

 
 #ifndef HEADER
 #define HEADER
 
 template <typename T>
 struct S {
   int a;
 // CHECK: template <typename T> struct S {
-// CHECK:     void foo() __attribute__((assume("ompx_global_assumption")))     {
+// CHECK:     __attribute__((assume("ompx_global_assumption")))  void foo()   {
   void foo() {
     #pragma omp parallel
     {}
   }
 };
 
 // CHECK: template<> struct S<int> {
-// CHECK:     void foo() __attribute__((assume("ompx_global_assumption")))     {
+// CHECK:     __attribute__((assume("ompx_global_assumption")))  void foo()    {
 
 #pragma omp begin assumes no_openmp
-// CHECK: void S_with_assumes_no_call() __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) void S_with_assumes_no_call() {
 void S_with_assumes_no_call() {
   S<int> s;
   s.a = 0;
 }
-// CHECK: void S_with_assumes_call() __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) void S_with_assumes_call() {
 void S_with_assumes_call() {
   S<int> s;
   s.a = 0;
   // If this is executed we have UB!
   s.foo();
 }
 #pragma omp end assumes
 
-// CHECK: void S_without_assumes() __attribute__((assume("ompx_global_assumption"))) {
+// CHECK:  __attribute__((assume("ompx_global_assumption"))) void S_without_assumes() {
 void S_without_assumes() {
   S<int> s;
   s.foo();
 }
 
 #pragma omp assumes ext_global_assumption
 
 // Same as the struct S above but the order in which we instantiate P is different, first outside of an assumes.
 template <typename T>
 struct P {
 // CHECK: template <typename T> struct P {
-// CHECK:     void foo() __attribute__((assume("ompx_global_assumption")))     {
+// CHECK:     __attribute__((assume("ompx_global_assumption")))  void foo()    {
   int a;
   void foo() {
     #pragma omp parallel
     {}
   }
 };
 
 // TODO: Avoid the duplication here:
 
 // CHECK: template<> struct P<int> {
-// CHECK:     void foo() __attribute__((assume("ompx_global_assumption"))) __attribute__((assume("ompx_global_assumption")))     {
+// CHECK:     __attribute__((assume("ompx_global_assumption"))) __attribute__((assume("ompx_global_assumption")))  void foo()    {
 
-// CHECK: void P_without_assumes() __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: __attribute__((assume("ompx_global_assumption"))) void P_without_assumes() {
 void P_without_assumes() {
   P<int> p;
   p.foo();
 }
 
 #pragma omp begin assumes no_openmp
-// CHECK: void P_with_assumes_no_call() __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) void P_with_assumes_no_call() {
 void P_with_assumes_no_call() {
   P<int> p;
   p.a = 0;
 }
-// CHECK: void P_with_assumes_call() __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) {
+// CHECK: __attribute__((assume("omp_no_openmp"))) __attribute__((assume("ompx_global_assumption"))) void P_with_assumes_call() {
 void P_with_assumes_call() {
   P<int> p;
   p.a = 0;
   // If this is executed we have UB!
   p.foo();
 }
 #pragma omp end assumes
 
 #endif

clang/test/OpenMP/declare_simd_ast_print.cpp

void h(int *hp, int *hp2, int *hq, int *lin)
   // Implicit specialization with <C=float>.
   // This is special case where the directive is stored by Sema and is
   // generated together with the (pending) function instatiation.
   h((float*) hp, (float*) hp2, (float*) hq, (float*) lin);
 }
 
 class VV {
   // CHECK: #pragma omp declare simd uniform(this, a) linear(val(b): a)
-  // CHECK-NEXT: int add(int a, int b) __attribute__((cold))    {
+  // CHECK-NEXT: __attribute__((cold)) int add(int a, int b)  {
   // CHECK-NEXT: return a + b;
   // CHECK-NEXT: }
   #pragma omp declare simd uniform(this, a) linear(val(b): a)
   int add(int a, int b) __attribute__((cold)) { return a + b; }
 
   // CHECK: #pragma omp declare simd aligned(b: 4) aligned(a) linear(ref(b): 4) linear(val(this)) linear(val(a))
   // CHECK-NEXT: float taddpf(float *a, float *&b)     {
   // CHECK-NEXT: return *a + *b;

clang/test/SemaCXX/attr-no-sanitize.cpp

 
 // DUMP-LABEL: FunctionDecl {{.*}} f3
 // DUMP: NoSanitizeAttr {{.*}} address
 // PRINT: int f3() __attribute__((no_sanitize("address")))
 int f3() __attribute__((no_sanitize("address")));
 
 // DUMP-LABEL: FunctionDecl {{.*}} f4
 // DUMP: NoSanitizeAttr {{.*}} thread
-// PRINT: int f4() {{\[\[}}clang::no_sanitize("thread")]]
+// PRINT: {{\[\[}}clang::no_sanitize("thread")]] int f4()
 [[clang::no_sanitize("thread")]] int f4();
 
 // DUMP-LABEL: FunctionDecl {{.*}} f4
 // DUMP: NoSanitizeAttr {{.*}} hwaddress
-// PRINT: int f4() {{\[\[}}clang::no_sanitize("hwaddress")]]
+// PRINT: {{\[\[}}clang::no_sanitize("hwaddress")]] int f4()
 [[clang::no_sanitize("hwaddress")]] int f4();
 
 // DUMP-LABEL: FunctionDecl {{.*}} f5
 // DUMP: NoSanitizeAttr {{.*}} address thread hwaddress
 // PRINT: int f5() __attribute__((no_sanitize("address", "thread", "hwaddress")))
 int f5() __attribute__((no_sanitize("address", "thread", "hwaddress")));
 
 // DUMP-LABEL: FunctionDecl {{.*}} f6
 // DUMP: NoSanitizeAttr {{.*}} unknown
 // PRINT: int f6() __attribute__((no_sanitize("unknown")))
 int f6() __attribute__((no_sanitize("unknown"))); // expected-warning{{unknown sanitizer 'unknown' ignored}}
 
 // DUMP-LABEL: FunctionDecl {{.*}} f7
 // DUMP: NoSanitizeAttr {{.*}} memtag
-// PRINT: int f7() {{\[\[}}clang::no_sanitize("memtag")]]
+// PRINT: {{\[\[}}clang::no_sanitize("memtag")]] int f7()
 [[clang::no_sanitize("memtag")]] int f7();

clang/test/SemaCXX/cxx11-attr-print.cpp

 // CHECK: void bar() __attribute__((__const));
 void bar() __attribute__((__const));
 
 // FIXME: It's unfortunate that the string literal prints with the below three
 // cases given that the string is only exposed via the [[nodiscard]] spelling.
 // CHECK: int f1() __attribute__((warn_unused_result("")));
 int f1() __attribute__((warn_unused_result));
 
-// CHECK: {{\[}}[clang::warn_unused_result("")]];
+// CHECK: {{\[}}[clang::warn_unused_result("")]]
 int f2 [[clang::warn_unused_result]] ();
 
-// CHECK: {{\[}}[gnu::warn_unused_result("")]];
+// CHECK: {{\[}}[gnu::warn_unused_result("")]]
 int f3 [[gnu::warn_unused_result]] ();
 
 // FIXME: ast-print need to print C++11
 // attribute after function declare-id.
-// CHECK: {{\[}}[noreturn]];
+// CHECK: {{\[}}[noreturn]]
 void f4 [[noreturn]] ();
 
 // CHECK: __attribute__((gnu_inline));
 inline void f6() __attribute__((gnu_inline));
 
-// CHECK: {{\[}}[gnu::gnu_inline]];
+// CHECK: {{\[}}[gnu::gnu_inline]]
 inline void f7 [[gnu::gnu_inline]] ();
 
 // arguments printing
 // CHECK: __attribute__((format(printf, 2, 3)));
 void f8 (void *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
 
 // CHECK: int m __attribute__((aligned(4
 // CHECK: int n alignas(4
 // CHECK: int p alignas(int
-// CHECK: static int f() __attribute__((pure))
-// CHECK: static int g() {{\[}}[gnu::pure]]
+// CHECK: __attribute__((pure)) static int f()
+// CHECK: {{\[}}[gnu::pure]] static int g()
 template <typename T> struct S {
   __attribute__((aligned(4))) int m;
   alignas(4) int n;
   alignas(int) int p;
   __attribute__((pure)) static int f() {
     return 0;
   }
   [[gnu::pure]] static int g() {
     return 1;
   }
 };
 
 // CHECK: int m __attribute__((aligned(4
 // CHECK: int n alignas(4
-// CHECK: static int f() __attribute__((pure))
-// CHECK: static int g() {{\[}}[gnu::pure]]
+// CHECK: __attribute__((pure)) static int f()
+// CHECK: {{\[}}[gnu::pure]] static int g()
 template struct S<int>;
 
 // CHECK: using Small2 {{\[}}[gnu::mode(byte)]] = int;
 using Small2 [[gnu::mode(byte)]] = int;