Support macro deprecation #pragma clang deprecated

[beanz]

Summary

This patch adds #pragma clang deprecated to enable deprecation of
preprocessor macros.

The macro must be defined before #pragma clang deprecated. When
deprecating a macro a custom message may be optionally provided.

Warnings are emitted at the use site of a deprecated macro, and can be
controlled via the -Wdeprecated warning group.

This patch takes some rough inspiration and a few lines of code from
https://reviews.llvm.org/D67935.

[beanz]

Updating comment about remaining bits.

Rather than subtracting one, I re-added up the bits. The bitfield is now at
40 bits, so it only has 24 bits remaining (someone please check my math).

[aaron.ballman]

Thank you for working on this, I think it's really useful functionality!

clang/docs/LanguageExtensions.rst

3898

Rather than use a string literal, did you consider using an unexpanded identifier token?

clang/include/clang/Basic/DiagnosticLexKinds.td

523–524

We have an existing diagnostic for this -- diag::err_expected.

526

I think we should consider reusing (and renaming) err_pp_visibility_non_macro for this purpose. I think it should be an error to try to deprecate a macro that doesn't exist because that feels like a really confusing situation for programmers (what does it mean?), but I don't feel strongly. However, I don't think this is an ExtWarn situation (pragmas are a bit weird; when I took a look, we're wildly inconsistent here) because we wouldn't issue a "blah is a Clang extension" warning about it.

528–533

Can you get away with something along these lines so we only use a single diagnostic message?

clang/include/clang/Basic/IdentifierTable.h

127

I come up with the same number as you did. Thank you for updating this!

clang/include/clang/Lex/Preprocessor.h

2398

clang/lib/Lex/PPMacroExpansion.cpp

483

486

clang/lib/Lex/Pragma.cpp

1914

1918

The syntax looks off here, it doesn't mention the message.

1939

Can you explain why you're looking for a macro that's been undefined? I'm wondering what the expectations are for code like:

#define FOO 12
#undef FOO
#pragma clang deprecated("FOO")

The user can't expand FOO, so there's nothing there to deprecate. But if a user later does #define FOO 42, it's not clear to me that we *should* diagnose use of FOO as being deprecated at that point. Once the macro is undefined, that signals at least some intent "I'm done with this identifier as a macro" and so the deprecation seems like it should perhaps not hold?

clang/test/Lexer/deprecate-macro.c

2

Without the -verify, this doesn't test the expected diagnostics. Also, I don't think you need not there once you're verifying the results.

36

Some other useful test cases:

#define frobble 1
#pragma clang deprecated("frobble")

#undef frobble // Expect no diagnostics here

#define bobble 1
#pragma clang deprecated("bobble")

#define bobble 1 // Do we expect a diagnostic here?
#define frobble 1 // How about here given that this was undefined?

[beanz]

Will update the patch later today with your feedback.

clang/docs/LanguageExtensions.rst

3898

The Lexer expands preprocessor macros, so you wouldn't get an identifier token, you actually get the tokens inside the macro. I suspect this is why #pragma push_macro does the same thing and uses a string literal.

[aaron.ballman]

clang/docs/LanguageExtensions.rst

3898

You can lex in either mode. See LexUnexpandedToken().

[beanz]

Updates based on feedback from @aaron.ballman

[beanz]

Fixing handling of #ifdef, #ifndef, and defined()

All tests pass this time :)

[beanz]

Minor comment fix

[beanz]

All feedback should be addressed

[beanz]

Fix warning printing always having a : on the end.

[beanz]

Minor comment fixes... I swear, eventually I'll be done...

[beanz]

Missed one

[beanz]

One last fix for a test failure my change caused.

[aaron.ballman]

clang/test/Lexer/deprecate-macro.c

35–40

Some more test cases to add:

// Test that we diagnose on #elifdef.
#ifdef baz
#elifdef foo // expected-warning
#endif

// Test that we diagnose on #elifndef.
#ifdef baz
#elifndef foo // expected-warning
#endif

// Test that we diagnose both the taken branch and the skipped branch.
#ifdef foo // expected-warning
#elifdef bar // expected-warning
#endif

[beanz]

Covered taken #elif* directives per @aaron.ballmon's feedback.

Handling non-taken #elif directives is non-trivial because clang skips parsing the conditionals for non-taken directives. At present clang won't even error on malformed #elif directives if an earlier branch is taken.

Also with this update I refactored the error emitting code out to a function on the Preprocessor, since it is just getting copy and pasted over and over again, and this change would have added another copy.

[beanz]

Moving the warning emission later.

[aaron.ballman]

In D106732#2911552, @beanz wrote:

Covered taken #elif* directives per @aaron.ballmon's feedback.

Thanks!

Handling non-taken #elif directives is non-trivial because clang skips parsing the conditionals for non-taken directives. At present clang won't even error on malformed #elif directives if an earlier branch is taken.

Yeah, that's what I was worried about. Can you add some FIXME comments into Preprocessor::SkipExcludedConditionalBlock() about wanting to diagnose this situation, and add some test cases with FIXME comments showing we know we don't handle this case perfectly yet?

Also with this update I refactored the error emitting code out to a function on the Preprocessor, since it is just getting copy and pasted over and over again, and this change would have added another copy.

Thank you, that's a nice cleanup!

clang/include/clang/Lex/Preprocessor.h

2409

clang/lib/Lex/Preprocessor.cpp

1416

clang/test/Lexer/deprecate-macro.c

63

[beanz]

Addressing @aaron.ballman's feedback.

I've added FIXMEs and test cases with not-expected annotations so that in the future if the underlying issue gets fixed, the tests should only need updating from not-expected to expected.

[aaron.ballman]

LGTM, thank you! I am excited to start using this shortly. :-)

clang/docs/LanguageExtensions.rst

void copy_into_buffer(size_t size) {
     // __builtin___strlcpy_chk(buffer, "some string", strlen("some string"), __builtin_object_size(buffer, 0))
   }
 
 Since the size of ``buffer`` can't be known at compile time, Clang will fold
 ``__builtin_object_size(buffer, 0)`` into ``-1``. However, if this was written
 as ``__builtin_dynamic_object_size(buffer, 0)``, Clang will fold it into
 ``size``, providing some extra runtime safety.
 
+Deprecating Macros
+==================
+
+Clang supports the pragma ``#pragma clang deprecated``, which can be used to
+provide deprecation warnings for macro uses. For example:
+
+.. code-block:: c
+   #define MIN(x, y) x < y ? x : y
+   #pragma clang deprecated(MIN, "use std::min instead")
+
+   void min(int a, int b) {
+     return MIN(a, b); // warning: MIN is deprecated: use std::min instead
+   }
+
+``#pragma clang deprecated`` should be preferred for this purpose over
+``#pragma GCC warning`` because the warning can be controlled with
+``-Wdeprecated``.
+
 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 DeprecatedDynamicExceptionSpec
     : DiagGroup<"deprecated-dynamic-exception-spec">;
 def DeprecatedImplementations :DiagGroup<"deprecated-implementations">;
 def DeprecatedIncrementBool : DiagGroup<"deprecated-increment-bool">;
 def DeprecatedRegister : DiagGroup<"deprecated-register">;
 def DeprecatedThisCapture : DiagGroup<"deprecated-this-capture">;
 def DeprecatedVolatile : DiagGroup<"deprecated-volatile">;
 def DeprecatedWritableStr : DiagGroup<"deprecated-writable-strings",
                                       [CXX11CompatDeprecatedWritableStr]>;
+def DeprecatedPragma : DiagGroup<"deprecated-pragma">;
 // FIXME: Why is DeprecatedImplementations not in this group?
 def Deprecated : DiagGroup<"deprecated", [DeprecatedAnonEnumEnumConversion,
                                           DeprecatedArrayCompare,
                                           DeprecatedAttributes,
                                           DeprecatedCommaSubscript,
                                           DeprecatedCopy,
                                           DeprecatedCopyWithDtor,
                                           DeprecatedDeclarations,
                                           DeprecatedDynamicExceptionSpec,
                                           DeprecatedEnumCompare,
                                           DeprecatedEnumCompareConditional,
                                           DeprecatedEnumEnumConversion,
                                           DeprecatedEnumFloatConversion,
                                           DeprecatedIncrementBool,
+                                          DeprecatedPragma,
                                           DeprecatedRegister,
                                           DeprecatedThisCapture,
                                           DeprecatedVolatile,
                                           DeprecatedWritableStr]>,
                  DiagCategory<"Deprecations">;
 
 def CXX20Designator : DiagGroup<"c++20-designator">;
 // Allow -Wno-c99-designator to be used to turn off all warnings on valid C99

clang/include/clang/Basic/DiagnosticLexKinds.td

def warn_pragma_warning_spec_invalid :
   InGroup<UnknownPragmas>;
 def warn_pragma_warning_push_level :
   ExtWarn<"#pragma warning(push, level) requires a level between 0 and 4">,
   InGroup<UnknownPragmas>;
 def warn_pragma_warning_expected_number :
   ExtWarn<"#pragma warning expected a warning number">,
   InGroup<UnknownPragmas>;
 
+// - #pragma deprecated(...)
+def warn_pragma_deprecated_macro_use :
+  ExtWarn<"macro %0 has been marked as deprecated%select{|: %2}1">,
+  InGroup<DeprecatedPragma>;
+
 // - #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>;
 def warn_pragma_exec_charset_push_invalid :
    ExtWarn<"#pragma execution_character_set invalid value '%0', only 'UTF-8' is supported">,
    InGroup<UnknownPragmas>;
 
 def err__Pragma_malformed : Error<
   "_Pragma takes a parenthesized string literal">;
 def err_pragma_message_malformed : Error<
   "pragma %select{message|warning|error}0 requires parenthesized string">;

clang/include/clang/Basic/IdentifierTable.h

class alignas(IdentifierInfoAlignment) IdentifierInfo {
   unsigned OutOfDate : 1;
 
   // True if this is the 'import' contextual keyword.
   unsigned IsModulesImport : 1;
 
   // True if this is a mangled OpenMP variant name.
   unsigned IsMangledOpenMPVariantName : 1;
 
-  // 28 bits left in a 64-bit word.
+  // True if this is a deprecated macro
+  unsigned IsDeprecatedMacro : 1;
+
+  // 24 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) {}
+        IsModulesImport(false), IsMangledOpenMPVariantName(false),
+        IsDeprecatedMacro(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.
void setHasMacroDefinition(bool Val) {
     if (HasMacro == Val) return;
 
     HasMacro = Val;
     if (Val) {
       NeedsHandleIdentifier = true;
       HadMacro = true;
     } else {
       RecomputeNeedsHandleIdentifier();
+      setIsDeprecatedMacro(false);
     }
   }
   /// 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;
   }
 
+  bool isDeprecatedMacro() const { return IsDeprecatedMacro; }
+
+  void setIsDeprecatedMacro(bool Val) {
+    if (IsDeprecatedMacro == Val)
+      return;
+    IsDeprecatedMacro = Val;
+    if (Val)
+      NeedsHandleIdentifier = true;
+    else
+      RecomputeNeedsHandleIdentifier();
+  }
+
   /// 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:
   /// We store just their SourceLocations instead of
   /// something like MacroInfo*. The benefit of this is that when we are
   /// deserializing from PCH, we don't need to deserialize identifier & macros
   /// just so that we can report that they are unused, we just warn using
   /// the SourceLocations of this set (that will be filled by the ASTReader).
   using WarnUnusedMacroLocsTy = llvm::SmallDenseSet<SourceLocation, 32>;
   WarnUnusedMacroLocsTy WarnUnusedMacroLocs;
 
+  /// Deprecation messages for macros provided in #pragma clang deprecated
+  llvm::DenseMap<const IdentifierInfo *, std::string> MacroDeprecationMsgs;
+
   /// 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 *>>
       PragmaPushMacroInfo;
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 emitMacroExpansionWarnings(const Token &Identifier);
+
 private:
   Optional<unsigned>
   getSkippedRangeForExcludedConditionalBlock(SourceLocation HashLoc);
 
   /// Contains the currently active skipped range mappings for skipping excluded
   /// conditional directives.
   ExcludedPreprocessorDirectiveSkipMapping
       *ExcludedConditionalDirectiveSkipMappings;

clang/lib/Lex/PPDirectives.cpp

if (Directive.startswith("if")) {
 
         // If this is a #elif with a #else before it, report the error.
         if (CondInfo.FoundElse)
           Diag(Tok, diag::pp_err_elif_after_else) << PED_Elif;
 
         // If this is in a skipping block or if we're already handled this #if
         // block, don't bother parsing the condition.
         if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
+          // FIXME: We should probably do at least some minimal parsing of the
+          // condition to verify that it is well-formed. The current state
+          // allows #elif* directives with completely malformed (or missing)
+          // conditions.
           DiscardUntilEndOfDirective();
         } else {
           // Restore the value of LexingRawMode so that identifiers are
           // looked up, etc, inside the #elif expression.
           assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");
           CurPPLexer->LexingRawMode = false;
           IdentifierInfo *IfNDefMacro = nullptr;
           DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);
if (Directive.startswith("if")) {
         // If this is a #elif with a #else before it, report the error.
         if (CondInfo.FoundElse)
           Diag(Tok, diag::pp_err_elif_after_else)
               << (IsElifDef ? PED_Elifdef : PED_Elifndef);
 
         // If this is in a skipping block or if we're already handled this #if
         // block, don't bother parsing the condition.
         if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
+          // FIXME: We should probably do at least some minimal parsing of the
+          // condition to verify that it is well-formed. The current state
+          // allows #elif* directives with completely malformed (or missing)
+          // conditions.
           DiscardUntilEndOfDirective();
         } else {
           // Restore the value of LexingRawMode so that identifiers are
           // looked up, etc, inside the #elif[n]def expression.
           assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");
           CurPPLexer->LexingRawMode = false;
           Token MacroNameTok;
           ReadMacroName(MacroNameTok);
           CurPPLexer->LexingRawMode = true;
 
           // If the macro name token is tok::eod, there was an error that was
           // already reported.
           if (MacroNameTok.is(tok::eod)) {
             // Skip code until we get to #endif.  This helps with recovery by
             // not emitting an error when the #endif is reached.
             continue;
           }
 
+          emitMacroExpansionWarnings(MacroNameTok);
+
           CheckEndOfDirective(IsElifDef ? "elifdef" : "elifndef");
 
           IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
           auto MD = getMacroDefinition(MII);
           MacroInfo *MI = MD.getMacroInfo();
 
           if (Callbacks) {
             if (IsElifDef) {
if (MacroNameTok.is(tok::eod)) {
     // Skip code until we get to #endif.  This helps with recovery by not
     // emitting an error when the #endif is reached.
     SkipExcludedConditionalBlock(HashToken.getLocation(),
                                  DirectiveTok.getLocation(),
                                  /*Foundnonskip*/ false, /*FoundElse*/ false);
     return;
   }
 
+  emitMacroExpansionWarnings(MacroNameTok);
+
   // Check to see if this is the last token on the #if[n]def line.
   CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef");
 
   IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
   auto MD = getMacroDefinition(MII);
   MacroInfo *MI = MD.getMacroInfo();
 
   if (CurPPLexer->getConditionalStackDepth() == 0) {

clang/lib/Lex/PPExpressions.cpp

static bool EvaluateDefined(PPValue &Result, Token &PeekTok, DefinedTracker &DT,
 
   // Otherwise, we got an identifier, is it defined to something?
   IdentifierInfo *II = PeekTok.getIdentifierInfo();
   MacroDefinition Macro = PP.getMacroDefinition(II);
   Result.Val = !!Macro;
   Result.Val.setIsUnsigned(false); // Result is signed intmax_t.
   DT.IncludedUndefinedIds = !Macro;
 
+  PP.emitMacroExpansionWarnings(PeekTok);
+
   // If there is a macro, mark it used.
   if (Result.Val != 0 && ValueLive)
     PP.markMacroAsUsed(Macro.getMacroInfo());
 
   // Save macro token for callback.
   Token macroToken(PeekTok);
 
   // If we are in parens, ensure we have a trailing ).

clang/lib/Lex/PPMacroExpansion.cpp

bool Preprocessor::isNextPPTokenLParen() {
   // translation unit.  In either case, return false.
   return Val == 1;
 }
 
 /// HandleMacroExpandedIdentifier - If an identifier token is read that is to be
 /// expanded as a macro, handle it and return the next token as 'Identifier'.
 bool Preprocessor::HandleMacroExpandedIdentifier(Token &Identifier,
                                                  const MacroDefinition &M) {
+  emitMacroExpansionWarnings(Identifier);
+
   MacroInfo *MI = M.getMacroInfo();
 
   // If this is a macro expansion in the "#if !defined(x)" line for the file,
   // then the macro could expand to different things in other contexts, we need
   // to disable the optimization in this case.
   if (CurPPLexer) CurPPLexer->MIOpt.ExpandedMacro();
 
   // If this is a builtin macro, like __LINE__ or _Pragma, handle it specially.
   if (MI->isBuiltinMacro()) {
     if (Callbacks)
       Callbacks->MacroExpands(Identifier, M, Identifier.getLocation(),
                               /*Args=*/nullptr);
     ExpandBuiltinMacro(Identifier);
     return true;

clang/lib/Lex/Pragma.cpp

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &NameTok) override {
     // #pragma region: endregion matches can be verified
     // __pragma(region): no sense, but ignored by msvc
     // _Pragma is not valid for MSVC, but there isn't any point
     // to handle a _Pragma differently.
   }
 };
 
+/// "\#pragma clang deprecated(...)"
+///
+/// The syntax is
+/// \code
+///   #pragma clang deprecate(MACRO_NAME [, Message])
+/// \endcode
+struct PragmaDeprecatedHandler : public PragmaHandler {
+  PragmaDeprecatedHandler() : PragmaHandler("deprecated") {}
+
+  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
+                    Token &Tok) override {
+    std::string Macro, MessageString;
+
+    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->getName();
+      return;
+    }
+
+    PP.Lex(Tok);
+    if (Tok.is(tok::comma)) {
+      PP.Lex(Tok);
+      if (!PP.FinishLexStringLiteral(Tok, MessageString,
+                                     "#pragma clang deprecated",
+                                     /*AllowMacroExpansion=*/true))
+        return;
+    }
+
+    if (Tok.isNot(tok::r_paren)) {
+      PP.Diag(Tok, diag::err_expected) << ")";
+      return;
+    }
+
+    II->setIsDeprecatedMacro(true);
+    if (!MessageString.empty())
+      PP.addMacroDeprecationMsg(II, std::move(MessageString));
+  }
+};
+
 } // 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() {
   // #pragma clang ...
   AddPragmaHandler("clang", new PragmaPoisonHandler());
   AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
   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());
 
   // #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::emitMacroExpansionWarnings(const Token &Identifier) {
+  if (Identifier.getIdentifierInfo()->isDeprecatedMacro()) {
+    auto DepMsg = getMacroDeprecationMsg(Identifier.getIdentifierInfo());
+    if (!DepMsg)
+      Diag(Identifier, diag::warn_pragma_deprecated_macro_use)
+          << Identifier.getIdentifierInfo() << 0;
+    else
+      Diag(Identifier, diag::warn_pragma_deprecated_macro_use)
+          << Identifier.getIdentifierInfo() << 1 << *DepMsg;
+  }
+}
+
 ModuleLoader::~ModuleLoader() = default;
 
 CommentHandler::~CommentHandler() = default;
 
 EmptylineHandler::~EmptylineHandler() = default;
 
 CodeCompletionHandler::~CodeCompletionHandler() = default;
 
 void Preprocessor::createPreprocessingRecord() {
   if (Record)
     return;
 
   Record = new PreprocessingRecord(getSourceManager());
   addPPCallbacks(std::unique_ptr<PPCallbacks>(Record));
 }

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}}
+#pragma clang deprecated(foo)
+
+#define bar 1
+#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
+#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}}
+#pragma clang deprecated(main)
+
+  // expected-warning@+1{{macro 'foo' has been marked as deprecated}}
+  return foo;
+}
+
+#define frobble 1
+#pragma clang deprecated(frobble)
+
+// not-expected-warning@+1{{macro 'frobble' has been marked as deprecated}}
+#undef frobble // Expect no diagnostics here
+
+// not-expected-warning@+1{{macro 'frobble' has been marked as deprecated}}
+#define frobble 1 // How about here given that this was undefined?
+
+// not-expected-warning@+1{{macro 'frobble' has been marked as deprecated}}
+#if defined(frobble)
+#endif
+
+// Test that we diagnose on #elif.
+#if 0
+#elif foo
+// expected-warning@-1{{macro 'foo' has been marked as deprecated}}
+#endif
+
+
+// Test that we diagnose on #elifdef.
+#ifdef baz
+#elifdef foo
+// expected-warning@-1{{macro 'foo' has been marked as deprecated}}
+#endif
+
+// Test that we diagnose on #elifndef.
+#ifdef baz
+#elifndef foo
+#endif
+// expected-warning@-2{{macro 'foo' has been marked as deprecated}}
+
+// FIXME: These cases are currently not handled because clang doesn't expand
+// conditions on skipped #elif* blocks. See the FIXME notes in
+// Preprocessor::SkipExcludedConditionalBlock.
+
+#ifdef frobble
+// not-expected-warning@+1{{macro 'foo' has been marked as deprecated}}
+#elifndef foo
+#endif
+
+#ifdef frobble
+// not-expected-warning@+1{{macro 'foo' has been marked as deprecated}}
+#elifdef foo
+#endif
+
+#if 1
+// not-expected-warning@+1{{macro 'foo' has been marked as deprecated}}
+#elif foo
+#endif