Fix -Wreserved-identifier in presence of system macro

[serge-sans-paille]

Summary

Do not warn on reserved identifiers resulting from expansion of system macros.
Also properly test -Wreserved-identifier wrt. system headers.

Should fix #49592

[aaron.ballman]

LGTM with a minor nit

clang/lib/Sema/SemaDecl.cpp

5720

clang/lib/Sema/SemaDecl.cpp

for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
     CXXScopeSpec &SS = Chunk.Mem.Scope();
     if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
       return true;
   }
 
   return false;
 }
 
+/// Returns true if the declaration is declared in a system header or from a
+/// system macro.
+static bool isFromSystemHeader(SourceManager &SM, const Decl *D) {
+  return SM.isInSystemHeader(D->getLocation()) ||
+         SM.isInSystemMacro(D->getLocation());
+}
+
 void Sema::warnOnReservedIdentifier(const NamedDecl *D) {
   // Avoid warning twice on the same identifier, and don't warn on redeclaration
   // of system decl.
   if (D->getPreviousDecl() || D->isImplicit())
     return;
   ReservedIdentifierStatus Status = D->isReserved(getLangOpts());
   if (Status != ReservedIdentifierStatus::NotReserved &&
-      !Context.getSourceManager().isInSystemHeader(D->getLocation()))
+      !isFromSystemHeader(Context.getSourceManager(), D)) {
     Diag(D->getLocation(), diag::warn_reserved_extern_symbol)
         << D << static_cast<int>(Status);
   }
+}
 
 Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) {
   D.setFunctionDefinitionKind(FunctionDefinitionKind::Declaration);
   Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
 
   if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
       Dcl && Dcl->getDeclContext()->isFileContext())
     Dcl->setTopLevelDeclInObjCContainer();

clang/test/Sema/Inputs/reserved-identifier.h

+int __i_come_from_a_system_header; // no-warning
+#define __I_AM_A_SYSTEM_MACRO()    // no-warning
+
+#define SOME_SYSTEM_MACRO() int __i_come_from_a_system_macro

clang/test/Sema/reserved-identifier.c

-// RUN: %clang_cc1 -fsyntax-only -verify -Wreserved-identifier -Wno-visibility %s
+// RUN: %clang_cc1 -isystem %S/Inputs -fsyntax-only -verify -Wreserved-identifier -Wno-visibility %s
+
+#include <reserved-identifier.h>
+
+__I_AM_A_SYSTEM_MACRO() // no-warning
+
+void test_system_macro_expansion() {
+  SOME_SYSTEM_MACRO(); // no-warning
+}
 
 #define __oof foo__ // expected-warning {{macro name is a reserved identifier}}
 
 int foo__bar() { return 0; }    // no-warning
 static int _bar() { return 0; } // expected-warning {{identifier '_bar' is reserved because it starts with '_' at global scope}}
 static int _Bar() { return 0; } // expected-warning {{identifier '_Bar' is reserved because it starts with '_' followed by a capital letter}}
 int _foo() { return 0; }        // expected-warning {{identifier '_foo' is reserved because it starts with '_' at global scope}}
 

 
 // FIXME: According to clang declaration context layering, _preserved belongs to
 // the translation unit, so we emit a warning. It's unclear that's what the
 // standard mandate, but it's such a corner case we can live with it.
 void func(struct _preserved { int a; } r) {} // expected-warning {{identifier '_preserved' is reserved because it starts with '_' at global scope}}
 
 extern char *_strdup(const char *); // expected-warning {{identifier '_strdup' is reserved because it starts with '_' at global scope}}
 
-// Don't warn on redecleration
+// Don't warn on redeclaration
 extern char *_strdup(const char *); // no-warning
 
 void ok() {
   void _ko();           // expected-warning {{identifier '_ko' is reserved because it starts with '_' at global scope}}
   extern int _ko_again; // expected-warning {{identifier '_ko_again' is reserved because it starts with '_' at global scope}}
 }