[Consumed] Narrow Subject for some attributes

[comex]

Summary

This is the former second part of https://reviews.llvm.org/D67740 that was split out (and rewritten).

Error out when the callable_when, set_typestate and test_typestate attributes are applied to a constructor or static method; previously Clang would ignore them or crash, depending on the attribute.

[dblaikie]

Looks good - thanks!

include/clang/Basic/Attr.td

 def NonBitField : SubsetSubject<Field,
                                 [{!S->isBitField()}],
                                 "non-bit-field non-static data members">;
 
 def NonStaticCXXMethod : SubsetSubject<CXXMethod,
                                        [{!S->isStatic()}],
                                        "non-static member functions">;
 
+def NonStaticNonConstructorCXXMethod
+    : SubsetSubject<CXXMethod,
+                    [{!S->isStatic() && !isa<CXXConstructorDecl>(S)}],
+                    "non-static non-constructor member functions">;
+
 def NonStaticNonConstCXXMethod
     : SubsetSubject<CXXMethod,
                     [{!S->isStatic() && !S->isConst()}],
                     "non-static non-const member functions">;
 
 def ObjCInstanceMethod : SubsetSubject<ObjCMethod,
                                        [{S->isInstanceMethod()}],
                                        "Objective-C instance methods">;
def ConsumableSetOnRead : InheritableAttr {
   let Documentation = [Undocumented];
 }
 
 def CallableWhen : InheritableAttr {
   // This attribute does not have a C [[]] spelling because it only appertains
   // to C++ function (but doesn't require it to be a member function).
   // FIXME: should this attribute have a CPlusPlus language option?
   let Spellings = [Clang<"callable_when", 0>];
-  let Subjects = SubjectList<[CXXMethod]>;
+  let Subjects = SubjectList<[NonStaticNonConstructorCXXMethod]>;
   let Args = [VariadicEnumArgument<"CallableStates", "ConsumedState",
                                    ["unknown", "consumed", "unconsumed"],
                                    ["Unknown", "Consumed", "Unconsumed"]>];
   let Documentation = [CallableWhenDocs];
 }
 
 def ParamTypestate : InheritableAttr {
   // This attribute does not have a C [[]] spelling because it only appertains
def ReturnTypestate : InheritableAttr {
   let Documentation = [ReturnTypestateDocs];
 }
 
 def SetTypestate : InheritableAttr {
   // This attribute does not have a C [[]] spelling because it only appertains
   // to C++ function (but doesn't require it to be a member function).
   // FIXME: should this attribute have a CPlusPlus language option?
   let Spellings = [Clang<"set_typestate", 0>];
-  let Subjects = SubjectList<[CXXMethod]>;
+  let Subjects = SubjectList<[NonStaticNonConstructorCXXMethod]>;
   let Args = [EnumArgument<"NewState", "ConsumedState",
                            ["unknown", "consumed", "unconsumed"],
                            ["Unknown", "Consumed", "Unconsumed"]>];
   let Documentation = [SetTypestateDocs];
 }
 
 def TestTypestate : InheritableAttr {
   // This attribute does not have a C [[]] spelling because it only appertains
   // to C++ function (but doesn't require it to be a member function).
   // FIXME: should this attribute have a CPlusPlus language option?
   let Spellings = [Clang<"test_typestate", 0>];
-  let Subjects = SubjectList<[CXXMethod]>;
+  let Subjects = SubjectList<[NonStaticNonConstructorCXXMethod]>;
   let Args = [EnumArgument<"TestState", "ConsumedState",
                            ["consumed", "unconsumed"],
                            ["Consumed", "Unconsumed"]>];
   let Documentation = [TestTypestateDocs];
 }
 
 // Type safety attributes for `void *' pointers and type tags.
 

test/SemaCXX/warn-consumed-parsing.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wconsumed -std=c++11 %s
 
 #define CALLABLE_WHEN(...)      __attribute__ ((callable_when(__VA_ARGS__)))
 #define CONSUMABLE(state)       __attribute__ ((consumable(state)))
 #define SET_TYPESTATE(state)    __attribute__ ((set_typestate(state)))
 #define RETURN_TYPESTATE(state) __attribute__ ((return_typestate(state)))
 #define TEST_TYPESTATE(state)   __attribute__ ((test_typestate(state)))
 
 class AttrTester0 {
   void consumes()       __attribute__ ((set_typestate())); // expected-error {{'set_typestate' attribute takes one argument}}
   bool testUnconsumed() __attribute__ ((test_typestate())); // expected-error {{'test_typestate' attribute takes one argument}}
   void callableWhen()   __attribute__ ((callable_when())); // expected-error {{'callable_when' attribute takes at least 1 argument}}
 };
 
-int var0 SET_TYPESTATE(consumed); // expected-warning {{'set_typestate' attribute only applies to functions}}
+int var0 SET_TYPESTATE(consumed); // expected-warning {{'set_typestate' attribute only applies to non-static non-constructor member functions}}
 int var1 TEST_TYPESTATE(consumed); // expected-warning {{'test_typestate' attribute only applies to}}
 int var2 CALLABLE_WHEN("consumed"); // expected-warning {{'callable_when' attribute only applies to}}
 int var3 CONSUMABLE(consumed); // expected-warning {{'consumable' attribute only applies to classes}}
 int var4 RETURN_TYPESTATE(consumed); // expected-warning {{'return_typestate' attribute only applies to functions}}
 
 void function0() SET_TYPESTATE(consumed); // expected-warning {{'set_typestate' attribute only applies to}}
 void function1() TEST_TYPESTATE(consumed); // expected-warning {{'test_typestate' attribute only applies to}}
 void function2() CALLABLE_WHEN("consumed"); // expected-warning {{'callable_when' attribute only applies to}}

 };
 
 int returnTypestateForUnconsumable() RETURN_TYPESTATE(consumed); // expected-warning {{attribute 'return_typestate' invalid for return value of type 'int': expected a consumable class type as a value, reference, or rvalue reference}}
 int returnTypestateForUnconsumable() {
   return 0;
 }
 
 struct CONSUMABLE(unknown) UselessAttrs {
+  static void x() SET_TYPESTATE(consumed); // expected-warning {{'set_typestate' attribute only applies to non-static non-constructor member functions}}
+  UselessAttrs() SET_TYPESTATE(consumed); // expected-warning {{'set_typestate' attribute only applies to non-static non-constructor member functions}}
+  UselessAttrs(int) CALLABLE_WHEN(consumed); // expected-warning {{'callable_when' attribute only applies to non-static non-constructor member functions}}
   void operator+(UselessAttrs) SET_TYPESTATE(consumed); // OK
+  static void *operator new(unsigned long) SET_TYPESTATE(consumed); // expected-warning {{'set_typestate' attribute only applies to non-static non-constructor member functions}}
   template <typename T>
   void a([[clang::param_typestate(consumed)]] const int &) {} // expected-warning {{attribute 'param_typestate' invalid for parameter of type 'const int &': expected a consumable class type as a value, reference, or rvalue reference}}
   void b([[clang::return_typestate(consumed)]] UselessAttrs *) {} // expected-warning {{attribute 'return_typestate' invalid for parameter of type 'UselessAttrs *': expected a consumable class type as a value, reference, or rvalue reference}}
   template <typename T>
   void c([[clang::return_typestate(consumed)]] T) {} // expected-warning {{attribute 'return_typestate' invalid for parameter of type 'int': expected a consumable class type as a value, reference, or rvalue reference}}
   template <> // test a template specialization
   void c<long>([[clang::return_typestate(consumed)]] long); // expected-warning {{attribute 'return_typestate' invalid for parameter of type 'long': expected a consumable class type as a value, reference, or rvalue reference}}
   void instantiate() {
     a<int>(42);
     c(42);
   }
 };
-void operator-(UselessAttrs, UselessAttrs) SET_TYPESTATE(consumed); // expected-warning {{'set_typestate' attribute only applies to functions}}
+void operator-(UselessAttrs, UselessAttrs) SET_TYPESTATE(consumed); // expected-warning {{'set_typestate' attribute only applies to non-static non-constructor member functions}}
 
 template <typename T, typename U>
 struct CONSUMABLE(unknown) ClassTemplateSpecialization;
 template <typename T>
 struct ClassTemplateSpecialization<T, int> {
   [[clang::return_typestate(consumed)]] ClassTemplateSpecialization(); // expected-warning {{attribute 'return_typestate' invalid for return value of type 'ClassTemplateSpecialization<long, int>': expected a consumable class type as a value, reference, or rvalue reference}}
   void a([[clang::return_typestate(consumed)]] T) {} // expected-warning {{attribute 'return_typestate' invalid for parameter of type 'long': expected a consumable class type as a value, reference, or rvalue reference}}
 };
 void testTS() { ClassTemplateSpecialization<long, int>().a(1); } // expected-note {{in instantiation of template class 'ClassTemplateSpecialization<long, int>' requested here}}