def Weak : InheritableAttr {
let Spellings = [GNU<"weak">, CXX11<"gnu", "weak">];
-// let Subjects = SubjectList<[Var, Function, CXXRecord]>;
+ let Subjects = SubjectList<[Var, Function, CXXRecord]>;
}
def WeakImport : InheritableAttr {
"variables and fields|variables, data members and tag types|"
"types and namespaces|Objective-C interfaces|methods and properties|"
"struct or union|struct, union or class|types|"
- "Objective-C instance methods}1">,
+ "Objective-C instance methods|variables, functions and classes}1">,
InGroup<IgnoredAttributes>;
def err_attribute_wrong_decl_type : Error<
"%0 attribute only applies to %select{functions|unions|"
"variables and fields|variables, data members and tag types|"
"types and namespaces|Objective-C interfaces|methods and properties|"
"struct or union|struct, union or class|types|"
- "Objective-C instance methods}1">;
+ "Objective-C instance methods|variables, functions and classes}1">;
def warn_type_attribute_wrong_type : Warning<
"'%0' only applies to %select{function|pointer|"
"Objective-C object or block pointer}1 types; type here is %2">,
ExpectedStructOrUnion,
ExpectedStructOrUnionOrClass,
ExpectedType,
- ExpectedObjCInstanceMethod
+ ExpectedObjCInstanceMethod,
+ ExpectedFunctionVariableOrClass
};
} // end namespace clang
Attr.getAttributeSpellingListIndex()));
}
-static void handleWeakAttr(Sema &S, Decl *D, const AttributeList &Attr) {
- if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
- if (isa<CXXRecordDecl>(D)) {
- D->addAttr(::new (S.Context) WeakAttr(Attr.getRange(), S.Context));
- return;
- }
- S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
- << Attr.getName() << ExpectedVariableOrFunction;
- return;
- }
-
- NamedDecl *nd = cast<NamedDecl>(D);
-
- nd->addAttr(::new (S.Context)
- WeakAttr(Attr.getRange(), S.Context,
- Attr.getAttributeSpellingListIndex()));
-}
-
static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
// weak_import only applies to variable & function declarations.
bool isDef = false;
handleSimpleAttribute<WarnUnusedAttr>(S, D, Attr); break;
case AttributeList::AT_WarnUnusedResult: handleWarnUnusedResult(S, D, Attr);
break;
- case AttributeList::AT_Weak: handleWeakAttr (S, D, Attr); break;
+ case AttributeList::AT_Weak:
+ handleSimpleAttribute<WeakAttr>(S, D, Attr); break;
case AttributeList::AT_WeakRef: handleWeakRefAttr (S, D, Attr); break;
case AttributeList::AT_WeakImport: handleWeakImportAttr (S, D, Attr); break;
case AttributeList::AT_TransparentUnion:
static int test0 __attribute__((weak)); // expected-error {{weak declaration cannot have internal linkage}}
static void test1() __attribute__((weak)); // expected-error {{weak declaration cannot have internal linkage}}
-namespace test2 __attribute__((weak)) { // expected-warning {{'weak' attribute only applies to variables and functions}}
+namespace test2 __attribute__((weak)) { // expected-warning {{'weak' attribute only applies to variables, functions and classes}}
}
namespace {
namespace { class Internal; }
template struct Test7<Internal>;
template struct Test7<int>;
+
+class __attribute__((weak)) Test8 {}; // OK
case Func | FuncTemplate:
case Func | ObjCMethod: return "ExpectedFunctionOrMethod";
case Func | Var: return "ExpectedVariableOrFunction";
+
+ // If not compiling for C++, the class portion does not apply.
+ case Func | Var | Class:
+ return "(S.getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass : "
+ "ExpectedVariableOrFunction)";
+
case ObjCMethod | ObjCProp: return "ExpectedMethodOrProperty";
case Field | Var: return "ExpectedFieldOrGlobalVar";
}