Add message to attribute(deprecated).

attribute(unavailable) to do next.
// rdar:// 6734520.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@115842 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td
index ae533372ad9a252bf8c347a3707efc7d2d76ac0a..fbbaec27661a0b12dc2464518e9eec25332baff5 100644 (file)
--- a/include/clang/Basic/Attr.td
+++ b/include/clang/Basic/Attr.td
@@ -172,6 +172,7 @@ def Constructor : Attr {
 
 def Deprecated : Attr {
   let Spellings = ["deprecated"];
+  let Args = [StringArgument<"Message">];
 }
 
 def Destructor : Attr {

diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index c6582d9acea3f25d1ff57b980bcc33aafef34adf..e43c837680352cdcfb03f2dbe6c748f4832ce048 100644 (file)
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -1745,6 +1745,8 @@ def note_dependent_var_use : Note<"must qualify identifier to find this "
 def err_undeclared_use : Error<"use of undeclared %0">;
 def warn_deprecated : Warning<"%0 is deprecated">,
     InGroup<DeprecatedDeclarations>;
+def warn_deprecated_message : Warning<"%0 is deprecated: %1">,
+    InGroup<DeprecatedDeclarations>;
 def err_unavailable : Error<"%0 is unavailable">;
 def note_unavailable_here : Note<
   "function has been explicitly marked %select{unavailable|deleted}0 here">;

diff --git a/include/clang/Sema/DelayedDiagnostic.h b/include/clang/Sema/DelayedDiagnostic.h
index 6a9a1bf5b608e14ae58ba0d8d254e29e21c43051..aedff4828fc75db5bdc69113c2ee3187d0bc2257 100644 (file)
--- a/include/clang/Sema/DelayedDiagnostic.h
+++ b/include/clang/Sema/DelayedDiagnostic.h
@@ -121,7 +121,7 @@ public:
 
   union {
     /// Deprecation.
-    struct { NamedDecl *Decl; } DeprecationData;
+    struct { NamedDecl *Decl; const char* Message; } DeprecationData;
 
     /// Access control.
     char AccessData[sizeof(AccessedEntity)];
@@ -135,12 +135,14 @@ public:
   }
 
   static DelayedDiagnostic makeDeprecation(SourceLocation Loc,
-                                           NamedDecl *D) {
+                                           NamedDecl *D,
+                                           const char *Msg) {
     DelayedDiagnostic DD;
     DD.Kind = Deprecation;
     DD.Triggered = false;
     DD.Loc = Loc;
     DD.DeprecationData.Decl = D;
+    DD.DeprecationData.Message = Msg;
     return DD;
   }
 

diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index 6cead4f28da91b2550cc874eb97a2b7a91d654dd..08645dcee4164933e463130bf4c38dbb48af8e09 100644 (file)
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -1649,7 +1649,8 @@ public:
 
   ParsingDeclStackState PushParsingDeclaration();
   void PopParsingDeclaration(ParsingDeclStackState S, Decl *D);
-  void EmitDeprecationWarning(NamedDecl *D, SourceLocation Loc);
+  void EmitDeprecationWarning(NamedDecl *D, const char *Message,
+                              SourceLocation Loc);
 
   void HandleDelayedDeprecationCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
 

diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp
index 9800db09e30251a2a1b21e339ed00f7d4db2bbbe..1376472eec0a4a8d8c68277853a118500d28a62b 100644 (file)
--- a/lib/Sema/SemaDeclAttr.cpp
+++ b/lib/Sema/SemaDeclAttr.cpp
@@ -903,12 +903,28 @@ static void HandleDestructorAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 
 static void HandleDeprecatedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
   // check the attribute arguments.
-  if (Attr.getNumArgs() != 0) {
-    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
-    return;
+  int noArgs = Attr.getNumArgs();
+  if (noArgs > 1) {
+    S.Diag(Attr.getLoc(), 
+           diag::err_attribute_wrong_number_arguments) << "0 or 1";
+    return;
+  }
+  // Handle the case where deprecated attribute has a text message.
+  StringLiteral *SE;
+  if (noArgs == 1) {
+    Expr *ArgExpr = static_cast<Expr *>(Attr.getArg(0));
+    SE = dyn_cast<StringLiteral>(ArgExpr);
+    if (!SE) {
+      S.Diag(ArgExpr->getLocStart(), 
+             diag::err_attribute_not_string) << "deprecated";
+      return;
+    }
   }
+  else
+    SE = StringLiteral::CreateEmpty(S.Context, 1);
 
-  d->addAttr(::new (S.Context) DeprecatedAttr(Attr.getLoc(), S.Context));
+  d->addAttr(::new (S.Context) DeprecatedAttr(Attr.getLoc(), S.Context,
+                                              SE->getString()));
 }
 
 static void HandleUnavailableAttr(Decl *d, const AttributeList &Attr, Sema &S) {
@@ -2536,20 +2552,30 @@ void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD,
     return;
 
   DD.Triggered = true;
-  Diag(DD.Loc, diag::warn_deprecated)
-    << DD.DeprecationData.Decl->getDeclName();
+  if (strlen(DD.DeprecationData.Message))
+    Diag(DD.Loc, diag::warn_deprecated_message)
+      << DD.DeprecationData.Decl->getDeclName() 
+      << DD.DeprecationData.Message;
+  else
+    Diag(DD.Loc, diag::warn_deprecated)
+      << DD.DeprecationData.Decl->getDeclName();
 }
 
-void Sema::EmitDeprecationWarning(NamedDecl *D, SourceLocation Loc) {
+void Sema::EmitDeprecationWarning(NamedDecl *D, const char * Message,
+                                  SourceLocation Loc) {
   // Delay if we're currently parsing a declaration.
   if (ParsingDeclDepth) {
-    DelayedDiagnostics.push_back(DelayedDiagnostic::makeDeprecation(Loc, D));
+    DelayedDiagnostics.push_back(DelayedDiagnostic::makeDeprecation(Loc, D, 
+                                                                    Message));
     return;
   }
 
   // Otherwise, don't warn if our current context is deprecated.
   if (isDeclDeprecated(cast<Decl>(CurContext)))
     return;
-
-  Diag(Loc, diag::warn_deprecated) << D->getDeclName();
+  if (strlen(Message))
+    Diag(Loc, diag::warn_deprecated_message) << D->getDeclName() 
+                                             << Message;
+  else
+    Diag(Loc, diag::warn_deprecated) << D->getDeclName();
 }

diff --git a/lib/Sema/SemaDeclObjC.cpp b/lib/Sema/SemaDeclObjC.cpp
index 89ae18fc39fe2dc90477dd6146c466c7b497172c..09502a49233e368fb19c6c530d77fd60273d6dcb 100644 (file)
--- a/lib/Sema/SemaDeclObjC.cpp
+++ b/lib/Sema/SemaDeclObjC.cpp
@@ -1622,9 +1622,13 @@ Decl *Sema::ActOnMethodDeclaration(
   // If the interface declared this method, and it was deprecated there,
   // mark it deprecated here.
   if (InterfaceMD)
-   if (Attr *DA = InterfaceMD->getAttr<DeprecatedAttr>())
-    ObjCMethod->addAttr(::new (Context) DeprecatedAttr(DA->getLocation(),
-                                                       Context));
+   if (Attr *DA = InterfaceMD->getAttr<DeprecatedAttr>()) {
+    StringLiteral *SE = StringLiteral::CreateEmpty(Context, 1);
+    ObjCMethod->addAttr(::new (Context) 
+                        DeprecatedAttr(DA->getLocation(),
+                                       Context, 
+                                       SE->getString()));
+   }
 
   return ObjCMethod;
 }

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index ef21a2719b6d010ef2888af9df1727d069e230bb..d54a85822100da98d910aa697e764bcbbce7fd04 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -57,8 +57,10 @@ using namespace sema;
 ///
 bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc) {
   // See if the decl is deprecated.
-  if (D->getAttr<DeprecatedAttr>()) {
-    EmitDeprecationWarning(D, Loc);
+  if (const DeprecatedAttr *DA = D->getAttr<DeprecatedAttr>()) {
+    const char *Message = 
+      DA->getMessage().empty() ? "" : DA->getMessage().data();
+    EmitDeprecationWarning(D, Message, Loc);
   }
 
   // See if the decl is unavailable

diff --git a/test/Sema/attr-deprecated-message.c b/test/Sema/attr-deprecated-message.c
new file mode 100644 (file)
index 0000000..5de31d0
--- /dev/null
+++ b/test/Sema/attr-deprecated-message.c
@@ -0,0 +1,31 @@
+// RUN: %clang_cc1 %s -verify -fsyntax-only
+// rdar: // 6734520
+
+typedef int INT1 __attribute__((deprecated("Please avoid INT1")));
+
+typedef INT1 INT2 __attribute__ ((__deprecated__("Please avoid INT2")));
+
+typedef INT1 INT1a; // expected-warning {{'INT1' is deprecated: Please avoid INT1}}
+
+typedef INT1 INT1b __attribute__ ((deprecated("Please avoid INT1b")));
+
+INT1 should_be_unavailable; // expected-warning {{'INT1' is deprecated: Please avoid INT1}}
+INT1a should_not_be_deprecated;
+
+INT1 f1(void) __attribute__ ((deprecated("Please avoid f1"))); 
+INT1 f2(void); // expected-warning {{'INT1' is deprecated: Please avoid INT1}}
+
+typedef enum {red, green, blue} Color __attribute__((deprecated("Please avoid Color")));
+ 
+
+Color c1; // expected-warning {{'Color' is deprecated: Please avoid Color}}
+
+int g1;
+int g2 __attribute__ ((deprecated("Please avoid g2")));
+
+int func1()
+{
+   int (*pf)() = f1; // expected-warning {{'f1' is deprecated: Please avoid f1}}
+   int i = f2();
+   return g1 + g2; // expected-warning {{'g2' is deprecated: Please avoid g2}}
+}