Implement #pragma clang final extension

[beanz]

Summary

This patch adds a new preprocessor extension `#pragma clang final`
which enables warning on undefinition and re-definition of macros.

The intent of this warning is to extend beyond `-Wmacro-redefined` to
warn against any and all alterations to macros that are marked final.

This warning is part of the `-Wpedantic-macros` diagnostics group.

[aaron.ballman]

clang/docs/LanguageExtensions.rst

3947–3963

Design question: would it make sense to extend this slightly so that the macro does not have to be defined in order to be finalized? e.g., this could be used as a way for a library author to say "this identifier cannot be defined as a macro"?

3958

What happens if the redefinition is to the same token sequence as the original definition? e.g.,

#define FINAL_MACRO 1+1
#pragma clang final(FINAL_MACRO)
#define FINAL_MACRO 1+1 // ok?
#define FINAL_MACRO (1+1) // Whoa...slow your roll there, champ!

clang/include/clang/Basic/DiagnosticLexKinds.td

559

Heh, I like your approach, but a goal of %select is to ease translation of our diagnostics to other languages (in theory, anyway).

clang/include/clang/Basic/IdentifierTable.h

196

clang/include/clang/Lex/Preprocessor.h

823–824

clang/lib/Lex/Pragma.cpp

2083

This should cause the macro name to be properly quoted in the diagnostic.

[beanz]

clang/docs/LanguageExtensions.rst

3947–3963

That's an interesting thought. I can look into that. Since the current implementation relies on the identifier info I'm not sure how much work it would be to support that.

3958

-Wmacro-redefined currently warns on redefinitions even if they are the same as the existing definition.

The implementation in this patch only triggers on redefining macros that have been undef'd and relies on -Wmacro-redefined to catch masking redefinitions. Although I should probably change that so that final catches on both.

clang/include/clang/Basic/DiagnosticLexKinds.td

559

Ha... Okay... Can do :)

[beanz]

Updates based on feedback from @aaron.ballman.

[aaron.ballman]

clang/docs/LanguageExtensions.rst

3958

-Wmacro-redefined currently warns on redefinitions even if they are the same as the existing definition.

Okay, SGTM.

The implementation in this patch only triggers on redefining macros that have been undef'd and relies on -Wmacro-redefined to catch masking redefinitions. Although I should probably change that so that final catches on both.

+1

clang/test/Lexer/final-macro.c

6–9

99% sure I got the syntax right, but you can specify a number to avoid duplicating the diagnostic multiple times and I'm pretty sure it works with the @+N syntax as well, but I don't recall trying in recent history.

11–12

If the goal is to test that mention of the macro here does not cause diagnostics, I'd recommend adding this to the end of the file instead of the beginning -- from there it's more obvious that none of the preceding diagnostics are triggered because of those pragmas.

15

This previous definition marker looks wrong to me -- it should be pointing to line 4, right?

19

Should we suppress this diagnostic when we know we're already issuing the previous one? I get why they both are issued, but it does seem a bit unclean to have two warnings that are basically both "you are redefining this macro and maybe you should reconsider that" diagnostics. (I don't feel strongly, mostly wondering out loud.)

[beanz]

Will push updates in a second.

clang/test/Lexer/final-macro.c

15

Since the macro is redefined here, when the later warning gets hit the note pops up here, which makes sense. This itself being a redefinition is amusing, but I think this is probably the way we want it to work. I don't have strong opinions though...

19

I can see this going both ways. I tend to err toward listing _all_ the warnings in case someone wants to try and suppress them for a specific use case. Otherwise they have to build multiple times in a cycle to suppress everything.

[beanz]

Updates based on feedback from @aaron.ballman.

[aaron.ballman]

This LGTM, but please wait a bit before landing in case @rsmith has concerns.

clang/test/Lexer/final-macro.c

15

Ohhhh! I see it now. There were two diagnostics for Foo and this is the note for the most recent previous definition. Got it, thanks!

19

I think the current behavior is defensible; if a user has a real world problem with it, we can address it at that point.

[sberg]

Final macros will always warn on redefinition, including situations with identical bodies and in system headers.

But

#define NULL syntax error
#pragma clang final(NULL)
#include <stddef.h>
void * p = NULL;

does not produce any warnings/errors for me and indicates that NULL silently gets redefined as a null pointer constant in stddef.h. Is that intended?

[beanz]

In D108567#3110925, @sberg wrote:

does not produce any warnings/errors for me and indicates that NULL silently gets redefined as a null pointer constant in stddef.h. Is that intended?

Nope, that's a bug. Fixed in 3e7ad1f2b2c0a753749eaba88d369d6032a50764. Thank you!

clang/docs/LanguageExtensions.rst

.. code-block:: c
    #if TARGET_ARM // No warning in main source file
    X_TYPE uint32_t
    #else
    X_TYPE uint64_t
    #endif
 
 This warning is controlled by ``-Wpedantic-macros``.
 
+Final Macros
+============
+
+Clang supports the pragma ``#pragma clang final``, which can be used to
+mark macros as final, meaning they cannot be undef'd or re-defined. For example:
+
+.. code-block:: c
+   #define FINAL_MACRO 1
+   #pragma clang final(FINAL_MACRO)
+
+   #define FINAL_MACRO // warning: FINAL_MACRO is marked final and should not be redefined
+   #undef FINAL_MACRO  // warning: FINAL_MACRO is marked final and should not be undefined
+
+This is useful for enforcing system-provided macros that should not be altered
+in user headers or code. This is controlled by ``-Wpedantic-macros``. Final 
+macros will always warn on redefinition, including situations with identical
+bodies and in system headers.
+
 Extended Integer Types
 ======================
 
 Clang supports a set of extended integer types under the syntax ``_ExtInt(N)``
 where ``N`` is an integer that specifies the number of bits that are used to represent
 the type, including the sign bit. The keyword ``_ExtInt`` is a type specifier, thus
 it can be used in any place a type can, including as a non-type-template-parameter,
 as the type of a bitfield, and as the underlying type of an enumeration.

clang/include/clang/Basic/DiagnosticGroups.td

 def : DiagGroup<"sequence-point", [Unsequenced]>;
 
 // Preprocessor warnings.
 def AmbiguousMacro : DiagGroup<"ambiguous-macro">;
 def KeywordAsMacro : DiagGroup<"keyword-macro">;
 def ReservedIdAsMacro : DiagGroup<"reserved-macro-identifier">;
 def ReservedIdAsMacroAlias : DiagGroup<"reserved-id-macro", [ReservedIdAsMacro]>;
 def RestrictExpansionMacro : DiagGroup<"restrict-expansion">;
+def FinalMacro : DiagGroup<"final-macro">;
 
 // Just silence warnings about -Wstrict-aliasing for now.
 def : DiagGroup<"strict-aliasing=0">;
 def : DiagGroup<"strict-aliasing=1">;
 def : DiagGroup<"strict-aliasing=2">;
 def : DiagGroup<"strict-aliasing">;
 
 // Just silence warnings about -Wstrict-overflow for now.

 
 def OpenCLCoreFeaturesDiagGroup : DiagGroup<"pedantic-core-features">;
 
 // Warnings and extensions to make preprocessor macro usage pedantic.
 def PedanticMacros : DiagGroup<"pedantic-macros",
                     [DeprecatedPragma,
                      MacroRedefined,
                      BuiltinMacroRedefined,
-                     RestrictExpansionMacro]>;
+                     RestrictExpansionMacro,
+                     FinalMacro]>;

clang/include/clang/Basic/DiagnosticLexKinds.td

 // - #pragma clang restrict_expansion(...)
 def warn_pragma_restrict_expansion_macro_use :
   ExtWarn<"macro %0 has been marked as unsafe for use in headers"
           "%select{|: %2}1">,
   InGroup<RestrictExpansionMacro>;
 
 // - Note for macro annotations.
 def note_pp_macro_annotation :
-  Note<"macro marked '%select{deprecated|restrict_expansion}0' here">;
+  Note<"macro marked '%select{deprecated|restrict_expansion|final}0' here">;
+
+// - #pragma clang final(...)
+def warn_pragma_final_macro :
+  ExtWarn<"macro %0 has been marked as final and should not be "
+          "%select{undefined|redefined}1">,
+  InGroup<FinalMacro>;
 
 // - #pragma execution_character_set(...)
 def warn_pragma_exec_charset_expected :
   ExtWarn<"#pragma execution_character_set expected '%0'">,
   InGroup<UnknownPragmas>;
 def warn_pragma_exec_charset_spec_invalid :
   ExtWarn<"#pragma execution_character_set expected 'push' or 'pop'">,
   InGroup<UnknownPragmas>;

clang/include/clang/Basic/IdentifierTable.h

class alignas(IdentifierInfoAlignment) IdentifierInfo {
   unsigned IsMangledOpenMPVariantName : 1;
 
   // True if this is a deprecated macro.
   unsigned IsDeprecatedMacro : 1;
 
   // True if this macro is unsafe in headers.
   unsigned IsRestrictExpansion : 1;
 
-  // 23 bits left in a 64-bit word.
+  // True if this macro is final.
+  unsigned IsFinal : 1;
+
+  // 22 bits left in a 64-bit word.
 
   // Managed by the language front-end.
   void *FETokenInfo = nullptr;
 
   llvm::StringMapEntry<IdentifierInfo *> *Entry = nullptr;
 
   IdentifierInfo()
       : TokenID(tok::identifier), ObjCOrBuiltinID(0), HasMacro(false),
         HadMacro(false), IsExtension(false), IsFutureCompatKeyword(false),
         IsPoisoned(false), IsCPPOperatorKeyword(false),
         NeedsHandleIdentifier(false), IsFromAST(false), ChangedAfterLoad(false),
         FEChangedAfterLoad(false), RevertedTokenID(false), OutOfDate(false),
         IsModulesImport(false), IsMangledOpenMPVariantName(false),
-        IsDeprecatedMacro(false), IsRestrictExpansion(false) {}
+        IsDeprecatedMacro(false), IsRestrictExpansion(false), IsFinal(false) {}
 
 public:
   IdentifierInfo(const IdentifierInfo &) = delete;
   IdentifierInfo &operator=(const IdentifierInfo &) = delete;
   IdentifierInfo(IdentifierInfo &&) = delete;
   IdentifierInfo &operator=(IdentifierInfo &&) = delete;
 
   /// Return true if this is the identifier for the specified string.
public:
   void setHasMacroDefinition(bool Val) {
     if (HasMacro == Val) return;
 
     HasMacro = Val;
     if (Val) {
       NeedsHandleIdentifier = true;
       HadMacro = true;
     } else {
+      // If this is a final macro, make the deprecation and header unsafe bits
+      // stick around after the undefinition so they apply to any redefinitions.
+      if (!IsFinal) {
         // Because calling the setters of these calls recomputes, just set them
         // manually to avoid recomputing a bunch of times.
         IsDeprecatedMacro = false;
         IsRestrictExpansion = false;
+      }
       RecomputeNeedsHandleIdentifier();
     }
   }
   /// Returns true if this identifier was \#defined to some value at any
   /// moment. In this case there should be an entry for the identifier in the
   /// macro history table in Preprocessor.
   bool hadMacroDefinition() const {
     return HadMacro;
if (IsRestrictExpansion == Val)
       return;
     IsRestrictExpansion = Val;
     if (Val)
       NeedsHandleIdentifier = true;
     else
       RecomputeNeedsHandleIdentifier();
   }
 
+  bool isFinal() const { return IsFinal; }
+
+  void setIsFinal(bool Val) { IsFinal = Val; }
+
   /// If this is a source-language token (e.g. 'for'), this API
   /// can be used to cause the lexer to map identifiers to source-language
   /// tokens.
   tok::TokenKind getTokenID() const { return (tok::TokenKind)TokenID; }
 
   /// True if revertTokenIDToIdentifier() was called.
   bool hasRevertedTokenIDToIdentifier() const { return RevertedTokenID; }
 

clang/include/clang/Lex/Preprocessor.h

private:
   WarnUnusedMacroLocsTy WarnUnusedMacroLocs;
 
   /// This is a pair of an optional message and source location used for pragmas
   /// that annotate macros like pragma clang restrict_expansion and pragma clang
   /// deprecated. This pair stores the optional message and the location of the
   /// annotation pragma for use producing diagnostics and notes.
   using MsgLocationPair = std::pair<std::string, SourceLocation>;
 
-  /// Deprecation messages for macros provided in #pragma clang deprecated.
-  llvm::DenseMap<const IdentifierInfo *, std::string> MacroDeprecationMsgs;
+  struct MacroAnnotationInfo {
+    SourceLocation Location;
+    std::string Message;
+  };
+
+  struct MacroAnnotations {
+    llvm::Optional<MacroAnnotationInfo> DeprecationInfo;
+    llvm::Optional<MacroAnnotationInfo> RestrictExpansionInfo;
+    llvm::Optional<SourceLocation> FinalAnnotationLoc;
+
+    static MacroAnnotations makeDeprecation(SourceLocation Loc,
+                                            std::string Msg) {
+      return MacroAnnotations{MacroAnnotationInfo{Loc, std::move(Msg)},
+                              llvm::None, llvm::None};
+    }
+
+    static MacroAnnotations makeRestrictExpansion(SourceLocation Loc,
+                                                  std::string Msg) {
+      return MacroAnnotations{
+          llvm::None, MacroAnnotationInfo{Loc, std::move(Msg)}, llvm::None};
+    }
+
+    static MacroAnnotations makeFinal(SourceLocation Loc) {
+      return MacroAnnotations{llvm::None, llvm::None, Loc};
+    }
+  };
 
-  /// Usage warning for macros marked by #pragma clang restrict_expansion.
-  llvm::DenseMap<const IdentifierInfo *, MsgLocationPair>
-      RestrictExpansionMacroMsgs;
+  /// Warning information for macro annotations.
+  llvm::DenseMap<const IdentifierInfo *, MacroAnnotations> AnnotationInfos;
 
   /// A "freelist" of MacroArg objects that can be
   /// reused for quick allocation.
   MacroArgs *MacroArgCache = nullptr;
 
   /// For each IdentifierInfo used in a \#pragma push_macro directive,
   /// we keep a MacroInfo stack used to restore the previous macro value.
   llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>
public:
   // Return true and store the first token only if any CommentHandler
   // has inserted some tokens and getCommentRetentionState() is false.
   bool HandleComment(Token &result, SourceRange Comment);
 
   /// A macro is used, update information about macros that need unused
   /// warnings.
   void markMacroAsUsed(MacroInfo *MI);
 
-  void addMacroDeprecationMsg(const IdentifierInfo *II, std::string Msg) {
-    MacroDeprecationMsgs.insert(std::make_pair(II, Msg));
-  }
-
-  llvm::Optional<std::string> getMacroDeprecationMsg(const IdentifierInfo *II) {
-    auto MsgEntry = MacroDeprecationMsgs.find(II);
-    if (MsgEntry == MacroDeprecationMsgs.end())
-      return llvm::None;
-    return MsgEntry->second;
+  void addMacroDeprecationMsg(const IdentifierInfo *II, std::string Msg,
+                              SourceLocation AnnotationLoc) {
+    auto Annotations = AnnotationInfos.find(II);
+    if (Annotations == AnnotationInfos.end())
+      AnnotationInfos.insert(std::make_pair(
+          II,
+          MacroAnnotations::makeDeprecation(AnnotationLoc, std::move(Msg))));
+    else
+      Annotations->second.DeprecationInfo =
+          MacroAnnotationInfo{AnnotationLoc, std::move(Msg)};
   }
 
   void addRestrictExpansionMsg(const IdentifierInfo *II, std::string Msg,
                                SourceLocation AnnotationLoc) {
-    RestrictExpansionMacroMsgs.insert(
-        std::make_pair(II, std::make_pair(std::move(Msg), AnnotationLoc)));
+    auto Annotations = AnnotationInfos.find(II);
+    if (Annotations == AnnotationInfos.end())
+      AnnotationInfos.insert(
+          std::make_pair(II, MacroAnnotations::makeRestrictExpansion(
+                                 AnnotationLoc, std::move(Msg))));
+    else
+      Annotations->second.RestrictExpansionInfo =
+          MacroAnnotationInfo{AnnotationLoc, std::move(Msg)};
+  }
+
+  void addFinalLoc(const IdentifierInfo *II, SourceLocation AnnotationLoc) {
+    auto Annotations = AnnotationInfos.find(II);
+    if (Annotations == AnnotationInfos.end())
+      AnnotationInfos.insert(
+          std::make_pair(II, MacroAnnotations::makeFinal(AnnotationLoc)));
+    else
+      Annotations->second.FinalAnnotationLoc = AnnotationLoc;
   }
 
-  MsgLocationPair getRestrictExpansionMsg(const IdentifierInfo *II) {
-    return RestrictExpansionMacroMsgs.find(II)->second;
+  const MacroAnnotations &getMacroAnnotations(const IdentifierInfo *II) const {
+    return AnnotationInfos.find(II)->second;
   }
 
-  void emitMacroExpansionWarnings(const Token &Identifier) {
+  void emitMacroExpansionWarnings(const Token &Identifier) const {
     if (Identifier.getIdentifierInfo()->isDeprecatedMacro())
       emitMacroDeprecationWarning(Identifier);
 
     if (Identifier.getIdentifierInfo()->isRestrictExpansion() &&
         !SourceMgr.isInMainFile(Identifier.getLocation()))
-      emitMacroUnsafeHeaderWarning(Identifier);
+      emitRestrictExpansionWarning(Identifier);
   }
 
 private:
-  void emitMacroDeprecationWarning(const Token &Identifier);
-  void emitMacroUnsafeHeaderWarning(const Token &Identifier);
+  void emitMacroDeprecationWarning(const Token &Identifier) const;
+  void emitRestrictExpansionWarning(const Token &Identifier) const;
+  void emitFinalMacroWarning(const Token &Identifier, bool IsUndef) const;
 
   Optional<unsigned>
   getSkippedRangeForExcludedConditionalBlock(SourceLocation HashLoc);
 
   /// Contains the currently active skipped range mappings for skipping excluded
   /// conditional directives.
   ExcludedPreprocessorDirectiveSkipMapping
       *ExcludedConditionalDirectiveSkipMappings;

clang/lib/Lex/PPDirectives.cpp

void Preprocessor::HandleDefineDirective(
   Token MacroNameTok;
   bool MacroShadowsKeyword;
   ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);
 
   // Error reading macro name?  If so, diagnostic already issued.
   if (MacroNameTok.is(tok::eod))
     return;
 
+  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
+  // Issue a final pragma warning if we're defining a macro that was has been
+  // undefined and is being redefined.
+  if (!II->hasMacroDefinition() && II->hadMacroDefinition() && II->isFinal())
+    emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/false);
+
   // If we are supposed to keep comments in #defines, reenable comment saving
   // mode.
   if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);
 
   MacroInfo *const MI = ReadOptionalMacroParameterListAndBody(
       MacroNameTok, ImmediatelyAfterHeaderGuard);
 
   if (!MI) return;
if (SkippingUntilPCHThroughHeader) {
     // Issue the diagnostic but allow the change if msvc extensions are enabled
     if (!LangOpts.MicrosoftExt)
       return;
   }
 
   // Finally, if this identifier already had a macro defined for it, verify that
   // the macro bodies are identical, and issue diagnostics if they are not.
   if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) {
+    // Final macros are hard-mode: they always warn. Even if the bodies are
+    // identical. Even if they are in system headers. Even if they are things we
+    // would silently allow in the past.
+    if (MacroNameTok.getIdentifierInfo()->isFinal())
+      emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/false);
+
     // In Objective-C, ignore attempts to directly redefine the builtin
     // definitions of the ownership qualifiers.  It's still possible to
     // #undef them.
     auto isObjCProtectedMacro = [](const IdentifierInfo *II) -> bool {
       return II->isStr("__strong") ||
              II->isStr("__weak") ||
              II->isStr("__unsafe_unretained") ||
              II->isStr("__autoreleasing");
if (getLangOpts().ObjC &&
       return;
     }
 
     // It is very common for system headers to have tons of macro redefinitions
     // and for warnings to be disabled in system headers.  If this is the case,
     // then don't bother calling MacroInfo::isIdenticalTo.
     if (!getDiagnostics().getSuppressSystemWarnings() ||
         !SourceMgr.isInSystemHeader(DefineTok.getLocation())) {
+
       if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused())
         Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);
 
       // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and
       // C++ [cpp.predefined]p4, but allow it as an extension.
       if (OtherMI->isBuiltinMacro())
         Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro);
       // Macros must be identical.  This means all tokens and whitespace
void Preprocessor::HandleUndefDirective() {
   // Check to see if this is the last token on the #undef line.
   CheckEndOfDirective("undef");
 
   // Okay, we have a valid identifier to undef.
   auto *II = MacroNameTok.getIdentifierInfo();
   auto MD = getMacroDefinition(II);
   UndefMacroDirective *Undef = nullptr;
 
+  if (II->isFinal())
+    emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/true);
+
   // If the macro is not defined, this is a noop undef.
   if (const MacroInfo *MI = MD.getMacroInfo()) {
     if (!MI->isUsed() && MI->isWarnIfUnused())
       Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
 
     if (MI->isWarnIfUnused())
       WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
 

clang/lib/Lex/Pragma.cpp

static IdentifierInfo *HandleMacroAnnotationPragma(Preprocessor &PP, Token &Tok,
   PP.LexUnexpandedToken(Tok);
   if (!Tok.is(tok::identifier)) {
     PP.Diag(Tok, diag::err_expected) << tok::identifier;
     return nullptr;
   }
   IdentifierInfo *II = Tok.getIdentifierInfo();
 
   if (!II->hasMacroDefinition()) {
-    PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II->getName();
+    PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;
     return nullptr;
   }
 
   PP.Lex(Tok);
   if (Tok.is(tok::comma)) {
     PP.Lex(Tok);
     if (!PP.FinishLexStringLiteral(Tok, MessageString, Pragma,
                                    /*AllowMacroExpansion=*/true))
struct PragmaDeprecatedHandler : public PragmaHandler {
 
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &Tok) override {
     std::string MessageString;
 
     if (IdentifierInfo *II = HandleMacroAnnotationPragma(
             PP, Tok, "#pragma clang deprecated", MessageString)) {
       II->setIsDeprecatedMacro(true);
-      if (!MessageString.empty())
-        PP.addMacroDeprecationMsg(II, std::move(MessageString));
+      PP.addMacroDeprecationMsg(II, std::move(MessageString),
+                                Tok.getLocation());
     }
   }
 };
 
 /// "\#pragma clang restrict_expansion(...)"
 ///
 /// The syntax is
 /// \code
if (IdentifierInfo *II = HandleMacroAnnotationPragma(
             PP, Tok, "#pragma clang restrict_expansion", MessageString)) {
       II->setIsRestrictExpansion(true);
       PP.addRestrictExpansionMsg(II, std::move(MessageString),
                                  Tok.getLocation());
     }
   }
 };
 
+/// "\#pragma clang final(...)"
+///
+/// The syntax is
+/// \code
+///   #pragma clang final(MACRO_NAME)
+/// \endcode
+struct PragmaFinalHandler : public PragmaHandler {
+  PragmaFinalHandler() : PragmaHandler("final") {}
+
+  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
+                    Token &Tok) override {
+    std::string Macro;
+
+    PP.Lex(Tok);
+    if (Tok.isNot(tok::l_paren)) {
+      PP.Diag(Tok, diag::err_expected) << "(";
+      return;
+    }
+
+    PP.LexUnexpandedToken(Tok);
+    if (!Tok.is(tok::identifier)) {
+      PP.Diag(Tok, diag::err_expected) << tok::identifier;
+      return;
+    }
+    IdentifierInfo *II = Tok.getIdentifierInfo();
+
+    if (!II->hasMacroDefinition()) {
+      PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;
+      return;
+    }
+
+    PP.Lex(Tok);
+    if (Tok.isNot(tok::r_paren)) {
+      PP.Diag(Tok, diag::err_expected) << ")";
+      return;
+    }
+    II->setIsFinal(true);
+    PP.addFinalLoc(II, Tok.getLocation());
+  }
+};
+
 } // namespace
 
 /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
 /// \#pragma GCC poison/system_header/dependency and \#pragma once.
 void Preprocessor::RegisterBuiltinPragmas() {
   AddPragmaHandler(new PragmaOnceHandler());
   AddPragmaHandler(new PragmaMarkHandler());
   AddPragmaHandler(new PragmaPushMacroHandler());
void Preprocessor::RegisterBuiltinPragmas() {
   AddPragmaHandler("clang", new PragmaIncludeInsteadHandler());
   AddPragmaHandler("clang", new PragmaDebugHandler());
   AddPragmaHandler("clang", new PragmaDependencyHandler());
   AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
   AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
   AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());
   AddPragmaHandler("clang", new PragmaDeprecatedHandler());
   AddPragmaHandler("clang", new PragmaRestrictExpansionHandler());
+  AddPragmaHandler("clang", new PragmaFinalHandler());
 
   // #pragma clang module ...
   auto *ModuleHandler = new PragmaNamespace("module");
   AddPragmaHandler("clang", ModuleHandler);
   ModuleHandler->AddPragma(new PragmaModuleImportHandler());
   ModuleHandler->AddPragma(new PragmaModuleBeginHandler());
   ModuleHandler->AddPragma(new PragmaModuleEndHandler());
   ModuleHandler->AddPragma(new PragmaModuleBuildHandler());

clang/lib/Lex/Preprocessor.cpp

if ((*H)->HandleComment(*this, Comment))
       AnyPendingTokens = true;
   }
   if (!AnyPendingTokens || getCommentRetentionState())
     return false;
   Lex(result);
   return true;
 }
 
-void Preprocessor::emitMacroDeprecationWarning(const Token &Identifier) {
-  auto DepMsg = getMacroDeprecationMsg(Identifier.getIdentifierInfo());
-  if (!DepMsg)
+void Preprocessor::emitMacroDeprecationWarning(const Token &Identifier) const {
+  const MacroAnnotations &A =
+      getMacroAnnotations(Identifier.getIdentifierInfo());
+  assert(A.DeprecationInfo &&
+         "Macro deprecation warning without recorded annotation!");
+  const MacroAnnotationInfo &Info = *A.DeprecationInfo;
+  if (Info.Message.empty())
     Diag(Identifier, diag::warn_pragma_deprecated_macro_use)
         << Identifier.getIdentifierInfo() << 0;
   else
     Diag(Identifier, diag::warn_pragma_deprecated_macro_use)
-        << Identifier.getIdentifierInfo() << 1 << *DepMsg;
+        << Identifier.getIdentifierInfo() << 1 << Info.Message;
+  Diag(Info.Location, diag::note_pp_macro_annotation) << 0;
 }
 
-void Preprocessor::emitMacroUnsafeHeaderWarning(const Token &Identifier) {
-  auto DepMsg = getRestrictExpansionMsg(Identifier.getIdentifierInfo());
-  if (DepMsg.first.empty())
+void Preprocessor::emitRestrictExpansionWarning(const Token &Identifier) const {
+  const MacroAnnotations &A =
+      getMacroAnnotations(Identifier.getIdentifierInfo());
+  assert(A.RestrictExpansionInfo &&
+         "Macro restricted expansion warning without recorded annotation!");
+  const MacroAnnotationInfo &Info = *A.RestrictExpansionInfo;
+  if (Info.Message.empty())
     Diag(Identifier, diag::warn_pragma_restrict_expansion_macro_use)
         << Identifier.getIdentifierInfo() << 0;
   else
     Diag(Identifier, diag::warn_pragma_restrict_expansion_macro_use)
-        << Identifier.getIdentifierInfo() << 1 << DepMsg.first;
-  Diag(DepMsg.second, diag::note_pp_macro_annotation) << 1;
+        << Identifier.getIdentifierInfo() << 1 << Info.Message;
+  Diag(Info.Location, diag::note_pp_macro_annotation) << 1;
+}
+
+void Preprocessor::emitFinalMacroWarning(const Token &Identifier,
+                                         bool IsUndef) const {
+  const MacroAnnotations &A =
+      getMacroAnnotations(Identifier.getIdentifierInfo());
+  assert(A.FinalAnnotationLoc &&
+         "Final macro warning without recorded annotation!");
+
+  Diag(Identifier, diag::warn_pragma_final_macro)
+      << Identifier.getIdentifierInfo() << (IsUndef ? 0 : 1);
+  Diag(*A.FinalAnnotationLoc, diag::note_pp_macro_annotation) << 2;
 }
 
 ModuleLoader::~ModuleLoader() = default;
 
 CommentHandler::~CommentHandler() = default;
 
 EmptylineHandler::~EmptylineHandler() = default;
 

clang/test/Lexer/Inputs/final-macro.h

+// expected-warning@+2{{macro 'Foo' has been marked as deprecated}}
+// expected-warning@+1{{macro 'Foo' has been marked as unsafe for use in headers}}
+#if Foo
+#endif

clang/test/Lexer/Inputs/unsafe-macro.h

 // expected-error@+1{{expected (}}
 #pragma clang restrict_expansion
 
 // expected-error@+1{{expected identifier}}
 #pragma clang restrict_expansion(4
 
-// expected-error@+1{{no macro named foo}}
+// expected-error@+1{{no macro named 'foo'}}
 #pragma clang restrict_expansion(foo)
 
 
 #define UNSAFE_MACRO 1
 // expected-note@+8{{macro marked 'restrict_expansion' here}}
 // expected-note@+7{{macro marked 'restrict_expansion' here}}
 // expected-note@+6{{macro marked 'restrict_expansion' here}}
 // expected-note@+5{{macro marked 'restrict_expansion' here}}

clang/test/Lexer/deprecate-macro.c

 // RUN: %clang_cc1 -Wdeprecated %s -fsyntax-only -verify
 
 // expected-error@+1{{expected (}}
 #pragma clang deprecated
 
 // expected-error@+1{{expected identifier}}
 #pragma clang deprecated(4
 
-// expected-error@+1{{no macro named foo}}
+// expected-error@+1{{no macro named 'foo'}}
 #pragma clang deprecated(foo)
 
 #define bar 1
+// expected-note@+1{{macro marked 'deprecated' here}} 
 #pragma clang deprecated(bar, "bar is deprecated use 1")
 
 // expected-warning@+1{{macro 'bar' has been marked as deprecated: bar is deprecated use 1}}
 #if bar
 #endif
 
 #define foo 1
+// expected-note@+8{{macro marked 'deprecated' here}} 
+// expected-note@+7{{macro marked 'deprecated' here}} 
+// expected-note@+6{{macro marked 'deprecated' here}} 
+// expected-note@+5{{macro marked 'deprecated' here}} 
+// expected-note@+4{{macro marked 'deprecated' here}} 
+// expected-note@+3{{macro marked 'deprecated' here}} 
+// expected-note@+2{{macro marked 'deprecated' here}} 
+// expected-note@+1{{macro marked 'deprecated' here}} 
 #pragma clang deprecated(foo)
 
 // expected-error@+1{{expected )}}
 #pragma clang deprecated(foo
 
 // expected-warning@+1{{macro 'foo' has been marked as deprecated}}
 #if foo
 #endif
 
 // expected-warning@+1{{macro 'foo' has been marked as deprecated}}
 #if defined(foo)
 #endif
 
 // expected-warning@+1{{macro 'foo' has been marked as deprecated}}
 #ifdef foo
 #endif
 
 // expected-warning@+1{{macro 'foo' has been marked as deprecated}}
 #ifndef foo
 #endif
 
 int main(int argc, char** argv) {
-  // expected-error@+1{{no macro named main}}
+// expected-error@+1{{no macro named 'main'}}
 #pragma clang deprecated(main)
 
   // expected-warning@+1{{macro 'foo' has been marked as deprecated}}
   return foo;
 }
 
 #define frobble 1
 #pragma clang deprecated(frobble)

clang/test/Lexer/final-macro.c

+// RUN: %clang_cc1 -Wfinal-macro %s -fsyntax-only -verify
+
+// Test warning production
+#define Foo 1
+// expected-note@+1 4{{macro marked 'final' here}}
+#pragma clang final(Foo)
+
+// expected-warning@+2{{macro 'Foo' has been marked as final and should not be redefined}}
+// expected-note@+1{{previous definition is here}}
+#define Foo 1
+
+// expected-warning@+2{{macro 'Foo' has been marked as final and should not be redefined}}
+// expected-warning@+1{{'Foo' macro redefined}}
+#define Foo 2
+
+// expected-warning@+1{{redefining builtin macro}}
+#define __TIME__ 1
+
+// expected-warning@+1{{undefining builtin macro}}
+#undef __TIMESTAMP__
+
+// expected-warning@+1{{macro 'Foo' has been marked as final and should not be undefined}}
+#undef Foo
+// expected-warning@+1{{macro 'Foo' has been marked as final and should not be redefined}}
+#define Foo 3
+
+// Test parse errors
+// expected-error@+1{{expected (}}
+#pragma clang final
+
+// expected-error@+1{{expected )}}
+#pragma clang final(Foo
+
+// expected-error@+1{{no macro named 'Baz'}}
+#pragma clang final(Baz)
+
+// expected-error@+1{{expected identifier}}
+#pragma clang final(4)
+
+// expected-error@+1{{expected (}}
+#pragma clang final Baz
+
+// no diagnostics triggered by these pragmas.
+#pragma clang deprecated(Foo)
+#pragma clang restrict_expansion(Foo)

clang/test/Lexer/pedantic-macro-interplay.c

 // RUN: %clang_cc1 -Wpedantic-macros %s -fsyntax-only -verify
 
 // This test verifies that the -Wpedantic-macros warnings don't fire in the
 // annotation pragmas themselves. This ensures you can annotate macros with
 // more than one of the pragmas without spewing warnings all over the code.
 
 #include "Inputs/pedantic-macro-interplay.h"
 
 #define UNSAFE_MACRO_2 1
 #pragma clang deprecated(UNSAFE_MACRO_2, "Don't use this!")
 // not-expected-warning@+1{{macro 'UNSAFE_MACRO_2' has been marked as deprecated: Don't use this!}}
 #pragma clang restrict_expansion(UNSAFE_MACRO_2, "Don't use this!")
 
-// expected-no-diagnostics
+
+#define Foo 1
+#pragma clang final(Foo)
+// expected-note@+2{{macro marked 'deprecated' here}}
+// expected-note@+1{{macro marked 'deprecated' here}}
+#pragma clang deprecated(Foo)
+// expected-note@+1{{macro marked 'restrict_expansion' here}}
+#pragma clang restrict_expansion(Foo)
+
+// Test that unsafe_header and deprecated markings stick around after the undef
+#include "Inputs/final-macro.h"
+
+// expected-warning@+1{{macro 'Foo' has been marked as deprecated}}
+const int X = Foo;