Improve dumps of attributes

[giulianobelinassi]

Summary

Clang has several cases where attribute dumpings gets into
undesired places, or even is completely incorrect.

Therefore, this commit improves many cases, as listed below:

1- Variable with attributes have its attribute dumped before its value.

input:

int var __attribute__((unused)) = 0;

output before this commit:

int var = 0 __attribute__((unused)); // Compilation error.

after this patch:

int var __attribute__((unused)) = 0;

2- __declspec attributes are dumped on the left side of the declaration,

as recommended by MSVC docs:

input:

__declspec(thread) int var = 0;

output before this commit:

int var __declspec(thread) = 0;

output after this commit:

__declspec(thread) int var = 0;

3- Functions with body has its attributes dumped on the right side of

the declaration instead of left side when possible.  The point of
this is to (1) avoid attribute placement confusion in K&R C
functions and (2) keep compatibility with GCC.

input

int f(void) __attribute__((unused)) {}

output before this commit:

int f(void) __attribute__((unused)) {}

output after this commit:

__attribute__((unused)) int f(void) {}

The interesting case is with input:

int f(i) int i __attribute__((unused)); {}

output before this commit (incorrect):

int f(i) __attribute__((unused)) int i; {}

output after this commit (correct)

int f(i) int i __attribute__((unused));

And in cases where the attribute is not accepted on the left side of
the declaration is output on the right side of the declaration:

intput:

int f(int i) __attribute__((diagnose_if(i < 0, "oh no", "warning"))) {}

output before and after this commit:

int f(int i) __attribute__((diagnose_if(i < 0, "oh no", "warning"))) {}

The reason behind thius is because GCC does not accept diagnose_if and
i must be declared in order to be referenced in this attribute.

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

Signed-off-by: Giuliano Belinassi <[e-mail]>

[giulianobelinassi]

This was open by mistake.

[giulianobelinassi]

Fix warning in MSVC

Summary:
Currently there is no PrintOnLeft attribute set, which results in an
empty switch-case. When compiling this, MSVC issues a warning saying
that the switch-case is empty. Fix this by using a macro and checking
if this macro is defined or not.

Links to D141714

Reviewers: aaron.ballman, erichkeane

Differential Revision: https://reviews.llvm.org/D157191

clang/lib/AST/DeclPrinter.cpp

 }
 
 raw_ostream& DeclPrinter::Indent(unsigned Indentation) {
   for (unsigned i = 0; i != Indentation; ++i)
     Out << "  ";
   return Out;
 }
 
+// For CLANG_ATTR_LIST_CanPrintOnLeft macro.
+#include "clang/Basic/AttrLeftSideCanPrintList.inc"
+
+// For CLANG_ATTR_LIST_PrintOnLeft macro.
+#include "clang/Basic/AttrLeftSideMustPrintList.inc"
+
 static bool canPrintOnLeftSide(attr::Kind kind) {
+#ifdef CLANG_ATTR_LIST_CanPrintOnLeft
   switch (kind) {
-#include "clang/Basic/AttrLeftSideCanPrintList.inc"
+  CLANG_ATTR_LIST_CanPrintOnLeft
     return true;
   default:
     return false;
   }
+#else
+  return false;
+#endif
 }
 
 static bool canPrintOnLeftSide(const Attr *A) {
   if (A->isStandardAttributeSyntax())
     return false;
 
   return canPrintOnLeftSide(A->getKind());
 }
 
 static bool mustPrintOnLeftSide(attr::Kind kind) {
   switch (kind) {
-#include "clang/Basic/AttrLeftSideMustPrintList.inc"
+#ifdef CLANG_ATTR_LIST_PrintOnLeft
+  switch (kind) {
+  CLANG_ATTR_LIST_PrintOnLeft
     return true;
   default:
     return false;
   }
+#else
+  return false;
+#endif
 }
 
 static bool mustPrintOnLeftSide(const Attr *A) {
   if (A->isDeclspecAttribute())
     return true;
 
   return mustPrintOnLeftSide(A->getKind());
 }
for (auto *A : Attrs) {
 
           // In case it is a variable declaration with a ctor, then allow
           // printing on the left side for readbility.
         else if (const VarDecl *VD = dyn_cast<VarDecl>(D);
                    VD && VD->getInit() &&
                    VD->getInitStyle() == VarDecl::CallInit)
           AttrLoc = AttrPrintLoc::Left;
       }
-
       // Only print the side matches the user requested.
       if ((Loc & AttrLoc) != AttrPrintLoc::None)
         A->printPretty(Out, Policy);
     }
   }
 }
 
 void DeclPrinter::prettyPrintPragmas(Decl *D) {

clang/utils/TableGen/ClangAttrEmitter.cpp

void EmitClangAttrPrintList(const std::string &FieldName, RecordKeeper &Records,
                             raw_ostream &OS) {
   emitSourceFileHeader(
       "List of attributes that can be print on the left side of a decl", OS);
 
   AttrClassHierarchy Hierarchy(Records);
 
   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
   std::vector<Record *> PragmaAttrs;
+  bool first = false;
+
   for (auto *Attr : Attrs) {
     if (!Attr->getValueAsBit("ASTNode"))
       continue;
 
     if (!Attr->getValueAsBit(FieldName))
       continue;
 
-    OS << "case attr::" << Attr->getName() << ":\n";
+    if (!first) {
+      first = true;
+      OS << "#define CLANG_ATTR_LIST_" << FieldName;
+    }
+
+    OS << " \\\n case attr::" << Attr->getName() << ":";
   }
+
+  OS << '\n';
 }
 
 // Emits the enumeration list for attributes.
 void EmitClangAttrSubjectMatchRuleList(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader(
       "List of all attribute subject matching rules that Clang recognizes", OS);
   PragmaClangAttributeSupport &PragmaAttributeSupport =
       getPragmaAttributeSupport(Records);