Add new `attribute push` matcher `function(is_definition)`

[jdoerfert]

Summary

This can also be used as a subject for attributes.

TODO: Tests are missing.

[jdoerfert]

Not needed anymore. Anyone should feel free to pick this up.

clang/include/clang/Basic/Attr.td

def NonStaticCXXMethod : SubsetSubject<CXXMethod,
                                        [{!S->isStatic()}],
                                        "non-static member functions">;
 
 def NonStaticNonConstCXXMethod
     : SubsetSubject<CXXMethod,
                     [{!S->isStatic() && !S->isConst()}],
                     "non-static non-const member functions">;
 
+def FunctionDefinition : SubsetSubject<Function,
+                                       [{S->isThisDeclarationADefinition()}],
+                                       "function definition">;
+
 def ObjCInstanceMethod : SubsetSubject<ObjCMethod,
                                        [{S->isInstanceMethod()}],
                                        "Objective-C instance methods">;
 
 def Struct : SubsetSubject<Record,
                            [{!S->isUnion()}], "structs">;
 
 def TLSVar : SubsetSubject<Var,
class AttrSubjectMatcherRule<string name, list<AttrSubject> subjects,
   // attribute to be applicable. If empty, no language options are required.
   list<LangOpt> LangOpts = [];
 }
 
 // function(is_member)
 def SubRuleForCXXMethod : AttrSubjectMatcherSubRule<"is_member", [CXXMethod]> {
   let LangOpts = [CPlusPlus];
 }
+// function(is_definition)
+def SubRuleForFunctionDefiniton
+    : AttrSubjectMatcherSubRule<"is_definition", [FunctionDefinition]> {}
 def SubjectMatcherForFunction : AttrSubjectMatcherRule<"function", [Function], [
-  SubRuleForCXXMethod
+  SubRuleForCXXMethod, SubRuleForFunctionDefiniton
 ]>;
 // hasType is abstract, it should be used with one of the sub-rules.
 def SubjectMatcherForType : AttrSubjectMatcherRule<"hasType", [], [
   AttrSubjectMatcherSubRule<"functionType", [FunctionLike]>
 
   // FIXME: There's a matcher ambiguity with objc methods and blocks since
   // functionType excludes them but functionProtoType includes them.
   // AttrSubjectMatcherSubRule<"functionProtoType", [HasFunctionProto]>

clang/lib/Sema/SemaDeclAttr.cpp

if (ND) {
           DeclApplyPragmaWeak(S, ND, W);
           WeakUndeclaredIdentifiers[Id] = W;
         }
       }
     }
   }
 }
 
+namespace {
+/// The `attribute push` matcher `function(is_definition)` needs to know if a
+/// function declaration is a definition but we might check before the relevant
+/// parts have been parsed. This RAII helper will set the `WillHaveBody` flag
+/// if appropriate to make the matcher possible.
+struct MarkDeclerationsForParamMatcherRAII {
+  FunctionDecl *FD;
+  bool OldWillHaveBody;
+  MarkDeclerationsForParamMatcherRAII(FunctionDecl *FD, const Declarator &PD)
+      : FD(FD), OldWillHaveBody(FD && FD->willHaveBody()) {
+    if (FD && PD.isFunctionDefinition())
+      FD->setWillHaveBody(true);
+  }
+  ~MarkDeclerationsForParamMatcherRAII() {
+    if (FD)
+      FD->setWillHaveBody(OldWillHaveBody);
+  }
+};
+} // namespace
+
 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
 /// it, apply them to D.  This is a bit tricky because PD can have attributes
 /// specified in many different places, and we need to find and apply them all.
 void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
   // Apply decl attributes from the DeclSpec if present.
   if (!PD.getDeclSpec().getAttributes().empty())
     ProcessDeclAttributeList(S, D, PD.getDeclSpec().getAttributes());
 
   // Walk the declarator structure, applying decl attributes that were in a type
   // position to the decl itself.  This handles cases like:
   //   int *__attr__(x)** D;
   // when X is a decl attribute.
   for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
     ProcessDeclAttributeList(S, D, PD.getTypeObject(i).getAttrs(),
                              /*IncludeCXX11Attributes=*/false);
 
   // Finally, apply any attributes on the decl itself.
   ProcessDeclAttributeList(S, D, PD.getAttributes());
 
   // Apply additional attributes specified by '#pragma clang attribute'.
+  {
+    MarkDeclerationsForParamMatcherRAII MDFPM(dyn_cast<FunctionDecl>(D), PD);
     AddPragmaAttributes(S, D);
   }
+}
 
 /// Is the given declaration allowed to use a forbidden type?
 /// If so, it'll still be annotated with an attribute that makes it
 /// illegal to actually use.
 static bool isForbiddenTypeAllowed(Sema &S, Decl *D,
                                    const DelayedDiagnostic &diag,
                                    UnavailableAttr::ImplicitReason &reason) {
   // Private ivars are always okay.  Unfortunately, people don't