plotfi updated this revision to Diff 256931.
plotfi added a comment.
Move ObjCPropertyAttributeKind to namespace ObjCPropertyAttribute { enum Kind {
... }}
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D77233/new/
https://reviews.llvm.org/D77233
Files:
clang/include/clang-c/Index.h
clang/include/clang/AST/DeclObjC.h
clang/include/clang/AST/DeclObjCCommon.h
clang/include/clang/Sema/DeclSpec.h
clang/lib/ARCMigrate/TransGCAttrs.cpp
clang/lib/ARCMigrate/TransProperties.cpp
clang/lib/ARCMigrate/TransZeroOutPropsInDealloc.cpp
clang/lib/AST/ASTContext.cpp
clang/lib/AST/DeclObjC.cpp
clang/lib/AST/DeclPrinter.cpp
clang/lib/AST/JSONNodeDumper.cpp
clang/lib/AST/TextNodeDumper.cpp
clang/lib/Analysis/BodyFarm.cpp
clang/lib/CodeGen/CGObjC.cpp
clang/lib/CodeGen/CGObjCGNU.cpp
clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp
clang/lib/Frontend/Rewrite/RewriteObjC.cpp
clang/lib/Parse/ParseObjc.cpp
clang/lib/Sema/SemaChecking.cpp
clang/lib/Sema/SemaCodeComplete.cpp
clang/lib/Sema/SemaExprObjC.cpp
clang/lib/Sema/SemaObjCProperty.cpp
clang/lib/Sema/SemaPseudoObject.cpp
clang/lib/Serialization/ASTReaderDecl.cpp
clang/tools/c-index-test/c-index-test.c
clang/tools/libclang/CIndex.cpp
llvm/include/llvm/BinaryFormat/Dwarf.def
llvm/include/llvm/BinaryFormat/Dwarf.h
Index: llvm/include/llvm/BinaryFormat/Dwarf.h
===================================================================
--- llvm/include/llvm/BinaryFormat/Dwarf.h
+++ llvm/include/llvm/BinaryFormat/Dwarf.h
@@ -357,7 +357,7 @@
};
/// Constants for the DW_APPLE_PROPERTY_attributes attribute.
-/// Keep this list in sync with clang's DeclSpec.h ObjCPropertyAttributeKind!
+/// Keep this list in sync with clang's DeclSpec.h ObjCPropertyAttribute::Kind!
enum ApplePropertyAttributes {
#define HANDLE_DW_APPLE_PROPERTY(ID, NAME) DW_APPLE_PROPERTY_##NAME = ID,
#include "llvm/BinaryFormat/Dwarf.def"
Index: llvm/include/llvm/BinaryFormat/Dwarf.def
===================================================================
--- llvm/include/llvm/BinaryFormat/Dwarf.def
+++ llvm/include/llvm/BinaryFormat/Dwarf.def
@@ -897,7 +897,7 @@
HANDLE_DW_CFA_PRED(0x2e, GNU_args_size, SELECT_X86)
// Apple Objective-C Property Attributes.
-// Keep this list in sync with clang's DeclSpec.h ObjCPropertyAttributeKind!
+// Keep this list in sync with clang's DeclSpec.h ObjCPropertyAttribute::Kind!
HANDLE_DW_APPLE_PROPERTY(0x01, readonly)
HANDLE_DW_APPLE_PROPERTY(0x02, getter)
HANDLE_DW_APPLE_PROPERTY(0x04, assign)
Index: clang/tools/libclang/CIndex.cpp
===================================================================
--- clang/tools/libclang/CIndex.cpp
+++ clang/tools/libclang/CIndex.cpp
@@ -22,6 +22,7 @@
#include "CursorVisitor.h"
#include "clang-c/FatalErrorHandler.h"
#include "clang/AST/Attr.h"
+#include "clang/AST/DeclObjCCommon.h"
#include "clang/AST/Mangle.h"
#include "clang/AST/OpenMPClause.h"
#include "clang/AST/StmtVisitor.h"
@@ -8143,11 +8144,10 @@
unsigned Result = CXObjCPropertyAttr_noattr;
const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(getCursorDecl(C));
- ObjCPropertyDecl::PropertyAttributeKind Attr =
- PD->getPropertyAttributesAsWritten();
+ ObjCPropertyAttribute::Kind Attr = PD->getPropertyAttributesAsWritten();
#define SET_CXOBJCPROP_ATTR(A) \
- if (Attr & ObjCPropertyDecl::OBJC_PR_##A) \
+ if (Attr & ObjCPropertyAttribute::Kind::A) \
Result |= CXObjCPropertyAttr_##A
SET_CXOBJCPROP_ATTR(readonly);
SET_CXOBJCPROP_ATTR(getter);
@@ -8161,7 +8161,7 @@
SET_CXOBJCPROP_ATTR(weak);
SET_CXOBJCPROP_ATTR(strong);
SET_CXOBJCPROP_ATTR(unsafe_unretained);
- SET_CXOBJCPROP_ATTR(class);
+ SET_CXOBJCPROP_ATTR(classattr);
#undef SET_CXOBJCPROP_ATTR
return Result;
Index: clang/tools/c-index-test/c-index-test.c
===================================================================
--- clang/tools/c-index-test/c-index-test.c
+++ clang/tools/c-index-test/c-index-test.c
@@ -1104,7 +1104,7 @@
PRINT_PROP_ATTR(weak);
PRINT_PROP_ATTR(strong);
PRINT_PROP_ATTR(unsafe_unretained);
- PRINT_PROP_ATTR(class);
+ PRINT_PROP_ATTR(classattr);
printf("]");
}
}
Index: clang/lib/Serialization/ASTReaderDecl.cpp
===================================================================
--- clang/lib/Serialization/ASTReaderDecl.cpp
+++ clang/lib/Serialization/ASTReaderDecl.cpp
@@ -1279,10 +1279,9 @@
QualType T = Record.readType();
TypeSourceInfo *TSI = readTypeSourceInfo();
D->setType(T, TSI);
- D->setPropertyAttributes(
- (ObjCPropertyDecl::PropertyAttributeKind)Record.readInt());
+ D->setPropertyAttributes((ObjCPropertyAttribute::Kind)Record.readInt());
D->setPropertyAttributesAsWritten(
- (ObjCPropertyDecl::PropertyAttributeKind)Record.readInt());
+ (ObjCPropertyAttribute::Kind)Record.readInt());
D->setPropertyImplementation(
(ObjCPropertyDecl::PropertyControl)Record.readInt());
DeclarationName GetterName = Record.readDeclarationName();
Index: clang/lib/Sema/SemaPseudoObject.cpp
===================================================================
--- clang/lib/Sema/SemaPseudoObject.cpp
+++ clang/lib/Sema/SemaPseudoObject.cpp
@@ -585,7 +585,7 @@
QualType T;
if (RefExpr->isExplicitProperty()) {
const ObjCPropertyDecl *Prop = RefExpr->getExplicitProperty();
- if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak)
+ if (Prop->getPropertyAttributes() & ObjCPropertyAttribute::weak)
return true;
T = Prop->getType();
Index: clang/lib/Sema/SemaObjCProperty.cpp
===================================================================
--- clang/lib/Sema/SemaObjCProperty.cpp
+++ clang/lib/Sema/SemaObjCProperty.cpp
@@ -35,24 +35,23 @@
///
/// Returns OCL_None if the attributes as stated do not imply an ownership.
/// Never returns OCL_Autoreleasing.
-static Qualifiers::ObjCLifetime getImpliedARCOwnership(
- ObjCPropertyDecl::PropertyAttributeKind attrs,
- QualType type) {
+static Qualifiers::ObjCLifetime
+getImpliedARCOwnership(ObjCPropertyAttribute::Kind attrs, QualType type) {
// retain, strong, copy, weak, and unsafe_unretained are only legal
// on properties of retainable pointer type.
- if (attrs & (ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_strong |
- ObjCPropertyDecl::OBJC_PR_copy)) {
+ if (attrs & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong |
+ ObjCPropertyAttribute::copy)) {
return Qualifiers::OCL_Strong;
- } else if (attrs & ObjCPropertyDecl::OBJC_PR_weak) {
+ } else if (attrs & ObjCPropertyAttribute::weak) {
return Qualifiers::OCL_Weak;
- } else if (attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained) {
+ } else if (attrs & ObjCPropertyAttribute::unsafe_unretained) {
return Qualifiers::OCL_ExplicitNone;
}
// assign can appear on other types, so we have to check the
// property type.
- if (attrs & ObjCPropertyDecl::OBJC_PR_assign &&
+ if (attrs & ObjCPropertyAttribute::assign &&
type->isObjCRetainableType()) {
return Qualifiers::OCL_ExplicitNone;
}
@@ -66,8 +65,7 @@
ObjCPropertyDecl *property) {
if (property->isInvalidDecl()) return;
- ObjCPropertyDecl::PropertyAttributeKind propertyKind
- = property->getPropertyAttributes();
+ ObjCPropertyAttribute::Kind propertyKind = property->getPropertyAttributes();
Qualifiers::ObjCLifetime propertyLifetime
= property->getType().getObjCLifetime();
@@ -80,14 +78,14 @@
// attribute. That's okay, but restore reasonable invariants by
// setting the property attribute according to the lifetime
// qualifier.
- ObjCPropertyDecl::PropertyAttributeKind attr;
+ ObjCPropertyAttribute::Kind attr;
if (propertyLifetime == Qualifiers::OCL_Strong) {
- attr = ObjCPropertyDecl::OBJC_PR_strong;
+ attr = ObjCPropertyAttribute::strong;
} else if (propertyLifetime == Qualifiers::OCL_Weak) {
- attr = ObjCPropertyDecl::OBJC_PR_weak;
+ attr = ObjCPropertyAttribute::weak;
} else {
assert(propertyLifetime == Qualifiers::OCL_ExplicitNone);
- attr = ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
+ attr = ObjCPropertyAttribute::unsafe_unretained;
}
property->setPropertyAttributes(attr);
return;
@@ -130,18 +128,19 @@
static unsigned deducePropertyOwnershipFromType(Sema &S, QualType T) {
// In GC mode, just look for the __weak qualifier.
if (S.getLangOpts().getGC() != LangOptions::NonGC) {
- if (T.isObjCGCWeak()) return ObjCDeclSpec::DQ_PR_weak;
+ if (T.isObjCGCWeak())
+ return ObjCPropertyAttribute::weak;
- // In ARC/MRC, look for an explicit ownership qualifier.
- // For some reason, this only applies to __weak.
+ // In ARC/MRC, look for an explicit ownership qualifier.
+ // For some reason, this only applies to __weak.
} else if (auto ownership = T.getObjCLifetime()) {
switch (ownership) {
case Qualifiers::OCL_Weak:
- return ObjCDeclSpec::DQ_PR_weak;
+ return ObjCPropertyAttribute::weak;
case Qualifiers::OCL_Strong:
- return ObjCDeclSpec::DQ_PR_strong;
+ return ObjCPropertyAttribute::strong;
case Qualifiers::OCL_ExplicitNone:
- return ObjCDeclSpec::DQ_PR_unsafe_unretained;
+ return ObjCPropertyAttribute::unsafe_unretained;
case Qualifiers::OCL_Autoreleasing:
case Qualifiers::OCL_None:
return 0;
@@ -153,22 +152,22 @@
}
static const unsigned OwnershipMask =
- (ObjCPropertyDecl::OBJC_PR_assign |
- ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_copy |
- ObjCPropertyDecl::OBJC_PR_weak |
- ObjCPropertyDecl::OBJC_PR_strong |
- ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
+ (ObjCPropertyAttribute::assign |
+ ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::copy |
+ ObjCPropertyAttribute::weak |
+ ObjCPropertyAttribute::strong |
+ ObjCPropertyAttribute::unsafe_unretained);
static unsigned getOwnershipRule(unsigned attr) {
unsigned result = attr & OwnershipMask;
// From an ownership perspective, assign and unsafe_unretained are
// identical; make sure one also implies the other.
- if (result & (ObjCPropertyDecl::OBJC_PR_assign |
- ObjCPropertyDecl::OBJC_PR_unsafe_unretained)) {
- result |= ObjCPropertyDecl::OBJC_PR_assign |
- ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
+ if (result & (ObjCPropertyAttribute::assign |
+ ObjCPropertyAttribute::unsafe_unretained)) {
+ result |= ObjCPropertyAttribute::assign |
+ ObjCPropertyAttribute::unsafe_unretained;
}
return result;
@@ -183,15 +182,17 @@
tok::ObjCKeywordKind MethodImplKind,
DeclContext *lexicalDC) {
unsigned Attributes = ODS.getPropertyAttributes();
- FD.D.setObjCWeakProperty((Attributes & ObjCDeclSpec::DQ_PR_weak) != 0);
+ FD.D.setObjCWeakProperty(
+ (Attributes & ObjCPropertyAttribute::weak) != 0);
TypeSourceInfo *TSI = GetTypeForDeclarator(FD.D, S);
QualType T = TSI->getType();
if (!getOwnershipRule(Attributes)) {
Attributes |= deducePropertyOwnershipFromType(*this, T);
}
- bool isReadWrite = ((Attributes & ObjCDeclSpec::DQ_PR_readwrite) ||
- // default is readwrite!
- !(Attributes & ObjCDeclSpec::DQ_PR_readonly));
+ bool isReadWrite =
+ ((Attributes & ObjCPropertyAttribute::readwrite) ||
+ // default is readwrite!
+ !(Attributes & ObjCPropertyAttribute::readonly));
// Proceed with constructing the ObjCPropertyDecls.
ObjCContainerDecl *ClassDecl = cast<ObjCContainerDecl>(CurContext);
@@ -277,39 +278,39 @@
return Res;
}
-static ObjCPropertyDecl::PropertyAttributeKind
+static ObjCPropertyAttribute::Kind
makePropertyAttributesAsWritten(unsigned Attributes) {
unsigned attributesAsWritten = 0;
- if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readonly;
- if (Attributes & ObjCDeclSpec::DQ_PR_readwrite)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readwrite;
- if (Attributes & ObjCDeclSpec::DQ_PR_getter)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_getter;
- if (Attributes & ObjCDeclSpec::DQ_PR_setter)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_setter;
- if (Attributes & ObjCDeclSpec::DQ_PR_assign)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_assign;
- if (Attributes & ObjCDeclSpec::DQ_PR_retain)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_retain;
- if (Attributes & ObjCDeclSpec::DQ_PR_strong)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_strong;
- if (Attributes & ObjCDeclSpec::DQ_PR_weak)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_weak;
- if (Attributes & ObjCDeclSpec::DQ_PR_copy)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_copy;
- if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
- if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_nonatomic;
- if (Attributes & ObjCDeclSpec::DQ_PR_atomic)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_atomic;
- if (Attributes & ObjCDeclSpec::DQ_PR_class)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_class;
- if (Attributes & ObjCDeclSpec::DQ_PR_direct)
- attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_direct;
-
- return (ObjCPropertyDecl::PropertyAttributeKind)attributesAsWritten;
+ if (Attributes & ObjCPropertyAttribute::readonly)
+ attributesAsWritten |= ObjCPropertyAttribute::readonly;
+ if (Attributes & ObjCPropertyAttribute::readwrite)
+ attributesAsWritten |= ObjCPropertyAttribute::readwrite;
+ if (Attributes & ObjCPropertyAttribute::getter)
+ attributesAsWritten |= ObjCPropertyAttribute::getter;
+ if (Attributes & ObjCPropertyAttribute::setter)
+ attributesAsWritten |= ObjCPropertyAttribute::setter;
+ if (Attributes & ObjCPropertyAttribute::assign)
+ attributesAsWritten |= ObjCPropertyAttribute::assign;
+ if (Attributes & ObjCPropertyAttribute::retain)
+ attributesAsWritten |= ObjCPropertyAttribute::retain;
+ if (Attributes & ObjCPropertyAttribute::strong)
+ attributesAsWritten |= ObjCPropertyAttribute::strong;
+ if (Attributes & ObjCPropertyAttribute::weak)
+ attributesAsWritten |= ObjCPropertyAttribute::weak;
+ if (Attributes & ObjCPropertyAttribute::copy)
+ attributesAsWritten |= ObjCPropertyAttribute::copy;
+ if (Attributes & ObjCPropertyAttribute::unsafe_unretained)
+ attributesAsWritten |= ObjCPropertyAttribute::unsafe_unretained;
+ if (Attributes & ObjCPropertyAttribute::nonatomic)
+ attributesAsWritten |= ObjCPropertyAttribute::nonatomic;
+ if (Attributes & ObjCPropertyAttribute::atomic)
+ attributesAsWritten |= ObjCPropertyAttribute::atomic;
+ if (Attributes & ObjCPropertyAttribute::classattr)
+ attributesAsWritten |= ObjCPropertyAttribute::classattr;
+ if (Attributes & ObjCPropertyAttribute::direct)
+ attributesAsWritten |= ObjCPropertyAttribute::direct;
+
+ return (ObjCPropertyAttribute::Kind)attributesAsWritten;
}
static bool LocPropertyAttribute( ASTContext &Context, const char *attrName,
@@ -347,12 +348,10 @@
ObjCPropertyDecl *NewProperty,
bool PropagateAtomicity) {
// If the atomicity of both matches, we're done.
- bool OldIsAtomic =
- (OldProperty->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
- == 0;
- bool NewIsAtomic =
- (NewProperty->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
- == 0;
+ bool OldIsAtomic = (OldProperty->getPropertyAttributes() &
+ ObjCPropertyAttribute::nonatomic) == 0;
+ bool NewIsAtomic = (NewProperty->getPropertyAttributes() &
+ ObjCPropertyAttribute::nonatomic) == 0;
if (OldIsAtomic == NewIsAtomic) return;
// Determine whether the given property is readonly and implicitly
@@ -360,14 +359,16 @@
auto isImplicitlyReadonlyAtomic = [](ObjCPropertyDecl *Property) -> bool {
// Is it readonly?
auto Attrs = Property->getPropertyAttributes();
- if ((Attrs & ObjCPropertyDecl::OBJC_PR_readonly) == 0) return false;
+ if ((Attrs & ObjCPropertyAttribute::readonly) == 0)
+ return false;
// Is it nonatomic?
- if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic) return false;
+ if (Attrs & ObjCPropertyAttribute::nonatomic)
+ return false;
// Was 'atomic' specified directly?
if (Property->getPropertyAttributesAsWritten() &
- ObjCPropertyDecl::OBJC_PR_atomic)
+ ObjCPropertyAttribute::atomic)
return false;
return true;
@@ -375,16 +376,16 @@
// If we're allowed to propagate atomicity, and the new property did
// not specify atomicity at all, propagate.
- const unsigned AtomicityMask =
- (ObjCPropertyDecl::OBJC_PR_atomic | ObjCPropertyDecl::OBJC_PR_nonatomic);
+ const unsigned AtomicityMask = (ObjCPropertyAttribute::atomic |
+ ObjCPropertyAttribute::nonatomic);
if (PropagateAtomicity &&
((NewProperty->getPropertyAttributesAsWritten() & AtomicityMask) == 0)) {
unsigned Attrs = NewProperty->getPropertyAttributes();
Attrs = Attrs & ~AtomicityMask;
if (OldIsAtomic)
- Attrs |= ObjCPropertyDecl::OBJC_PR_atomic;
+ Attrs |= ObjCPropertyAttribute::atomic;
else
- Attrs |= ObjCPropertyDecl::OBJC_PR_nonatomic;
+ Attrs |= ObjCPropertyAttribute::nonatomic;
NewProperty->overwritePropertyAttributes(Attrs);
return;
@@ -438,8 +439,9 @@
return nullptr;
}
- bool isClassProperty = (AttributesAsWritten & ObjCDeclSpec::DQ_PR_class) ||
- (Attributes & ObjCDeclSpec::DQ_PR_class);
+ bool isClassProperty =
+ (AttributesAsWritten & ObjCPropertyAttribute::classattr) ||
+ (Attributes & ObjCPropertyAttribute::classattr);
// Find the property in the extended class's primary class or
// extensions.
@@ -464,11 +466,11 @@
// This is a common error where the user often intended the original
// declaration to be readonly.
unsigned diag =
- (Attributes & ObjCDeclSpec::DQ_PR_readwrite) &&
- (PIDecl->getPropertyAttributesAsWritten() &
- ObjCPropertyDecl::OBJC_PR_readwrite)
- ? diag::err_use_continuation_class_redeclaration_readwrite
- : diag::err_use_continuation_class;
+ (Attributes & ObjCPropertyAttribute::readwrite) &&
+ (PIDecl->getPropertyAttributesAsWritten() &
+ ObjCPropertyAttribute::readwrite)
+ ? diag::err_use_continuation_class_redeclaration_readwrite
+ : diag::err_use_continuation_class;
Diag(AtLoc, diag)
<< CCPrimary->getDeclName();
Diag(PIDecl->getLocation(), diag::note_property_declare);
@@ -478,15 +480,15 @@
// Check for consistency of getters.
if (PIDecl->getGetterName() != GetterSel) {
// If the getter was written explicitly, complain.
- if (AttributesAsWritten & ObjCDeclSpec::DQ_PR_getter) {
- Diag(AtLoc, diag::warn_property_redecl_getter_mismatch)
- << PIDecl->getGetterName() << GetterSel;
- Diag(PIDecl->getLocation(), diag::note_property_declare);
- }
+ if (AttributesAsWritten & ObjCPropertyAttribute::getter) {
+ Diag(AtLoc, diag::warn_property_redecl_getter_mismatch)
+ << PIDecl->getGetterName() << GetterSel;
+ Diag(PIDecl->getLocation(), diag::note_property_declare);
+ }
// Always adopt the getter from the original declaration.
GetterSel = PIDecl->getGetterName();
- Attributes |= ObjCDeclSpec::DQ_PR_getter;
+ Attributes |= ObjCPropertyAttribute::getter;
}
// Check consistency of ownership.
@@ -505,9 +507,9 @@
}
// If the redeclaration is 'weak' but the original property is not,
- if ((Attributes & ObjCPropertyDecl::OBJC_PR_weak) &&
- !(PIDecl->getPropertyAttributesAsWritten()
- & ObjCPropertyDecl::OBJC_PR_weak) &&
+ if ((Attributes & ObjCPropertyAttribute::weak) &&
+ !(PIDecl->getPropertyAttributesAsWritten() &
+ ObjCPropertyAttribute::weak) &&
PIDecl->getType()->getAs<ObjCObjectPointerType>() &&
PIDecl->getType().getObjCLifetime() == Qualifiers::OCL_None) {
Diag(AtLoc, diag::warn_property_implicitly_mismatched);
@@ -584,8 +586,8 @@
// Property defaults to 'assign' if it is readwrite, unless this is ARC
// and the type is retainable.
bool isAssign;
- if (Attributes & (ObjCDeclSpec::DQ_PR_assign |
- ObjCDeclSpec::DQ_PR_unsafe_unretained)) {
+ if (Attributes & (ObjCPropertyAttribute::assign |
+ ObjCPropertyAttribute::unsafe_unretained)) {
isAssign = true;
} else if (getOwnershipRule(Attributes) || !isReadWrite) {
isAssign = false;
@@ -596,8 +598,8 @@
// Issue a warning if property is 'assign' as default and its
// object, which is gc'able conforms to NSCopying protocol
- if (getLangOpts().getGC() != LangOptions::NonGC &&
- isAssign && !(Attributes & ObjCDeclSpec::DQ_PR_assign)) {
+ if (getLangOpts().getGC() != LangOptions::NonGC && isAssign &&
+ !(Attributes & ObjCPropertyAttribute::assign)) {
if (const ObjCObjectPointerType *ObjPtrTy =
T->getAs<ObjCObjectPointerType>()) {
ObjCInterfaceDecl *IDecl = ObjPtrTy->getObjectType()->getInterface();
@@ -625,8 +627,9 @@
PropertyId, AtLoc,
LParenLoc, T, TInfo);
- bool isClassProperty = (AttributesAsWritten & ObjCDeclSpec::DQ_PR_class) ||
- (Attributes & ObjCDeclSpec::DQ_PR_class);
+ bool isClassProperty =
+ (AttributesAsWritten & ObjCPropertyAttribute::classattr) ||
+ (Attributes & ObjCPropertyAttribute::classattr);
// Class property and instance property can have the same name.
if (ObjCPropertyDecl *prevDecl = ObjCPropertyDecl::findPropertyDecl(
DC, PropertyId, ObjCPropertyDecl::getQueryKind(isClassProperty))) {
@@ -654,68 +657,72 @@
PDecl->setPropertyAttributesAsWritten(
makePropertyAttributesAsWritten(AttributesAsWritten));
- if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
+ if (Attributes & ObjCPropertyAttribute::readonly)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::readonly);
- if (Attributes & ObjCDeclSpec::DQ_PR_getter)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter);
+ if (Attributes & ObjCPropertyAttribute::getter)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::getter);
- if (Attributes & ObjCDeclSpec::DQ_PR_setter)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter);
+ if (Attributes & ObjCPropertyAttribute::setter)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::setter);
if (isReadWrite)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::readwrite);
- if (Attributes & ObjCDeclSpec::DQ_PR_retain)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
+ if (Attributes & ObjCPropertyAttribute::retain)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::retain);
- if (Attributes & ObjCDeclSpec::DQ_PR_strong)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
+ if (Attributes & ObjCPropertyAttribute::strong)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::strong);
- if (Attributes & ObjCDeclSpec::DQ_PR_weak)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_weak);
+ if (Attributes & ObjCPropertyAttribute::weak)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::weak);
- if (Attributes & ObjCDeclSpec::DQ_PR_copy)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
+ if (Attributes & ObjCPropertyAttribute::copy)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::copy);
- if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
+ if (Attributes & ObjCPropertyAttribute::unsafe_unretained)
+ PDecl->setPropertyAttributes(
+ ObjCPropertyAttribute::unsafe_unretained);
if (isAssign)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::assign);
// In the semantic attributes, one of nonatomic or atomic is always set.
- if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic);
+ if (Attributes & ObjCPropertyAttribute::nonatomic)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::nonatomic);
else
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_atomic);
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::atomic);
// 'unsafe_unretained' is alias for 'assign'.
- if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
+ if (Attributes & ObjCPropertyAttribute::unsafe_unretained)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::assign);
if (isAssign)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
+ PDecl->setPropertyAttributes(
+ ObjCPropertyAttribute::unsafe_unretained);
if (MethodImplKind == tok::objc_required)
PDecl->setPropertyImplementation(ObjCPropertyDecl::Required);
else if (MethodImplKind == tok::objc_optional)
PDecl->setPropertyImplementation(ObjCPropertyDecl::Optional);
- if (Attributes & ObjCDeclSpec::DQ_PR_nullability)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nullability);
+ if (Attributes & ObjCPropertyAttribute::nullability)
+ PDecl->setPropertyAttributes(
+ ObjCPropertyAttribute::nullability);
- if (Attributes & ObjCDeclSpec::DQ_PR_null_resettable)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_null_resettable);
+ if (Attributes & ObjCPropertyAttribute::null_resettable)
+ PDecl->setPropertyAttributes(
+ ObjCPropertyAttribute::null_resettable);
- if (Attributes & ObjCDeclSpec::DQ_PR_class)
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_class);
+ if (Attributes & ObjCPropertyAttribute::classattr)
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::classattr);
- if ((Attributes & ObjCDeclSpec::DQ_PR_direct) ||
+ if ((Attributes & ObjCPropertyAttribute::direct) ||
CDecl->hasAttr<ObjCDirectMembersAttr>()) {
if (isa<ObjCProtocolDecl>(CDecl)) {
Diag(PDecl->getLocation(), diag::err_objc_direct_on_protocol) << true;
} else if (getLangOpts().ObjCRuntime.allowsDirectDispatch()) {
- PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_direct);
+ PDecl->setPropertyAttributes(ObjCPropertyAttribute::direct);
} else {
Diag(PDecl->getLocation(), diag::warn_objc_direct_property_ignored)
<< PDecl->getDeclName();
@@ -781,10 +788,9 @@
case Qualifiers::OCL_ExplicitNone:
S.Diag(ivar->getLocation(), diag::err_arc_assign_property_ownership)
- << property->getDeclName()
- << ivar->getDeclName()
- << ((property->getPropertyAttributesAsWritten()
- & ObjCPropertyDecl::OBJC_PR_assign) != 0);
+ << property->getDeclName() << ivar->getDeclName()
+ << ((property->getPropertyAttributesAsWritten() &
+ ObjCPropertyAttribute::assign) != 0);
break;
case Qualifiers::OCL_Autoreleasing:
@@ -815,21 +821,20 @@
if (!ivar) {
// if no backing ivar, make property 'strong'.
- property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
+ property->setPropertyAttributes(ObjCPropertyAttribute::strong);
return;
}
// property assumes owenership of backing ivar.
QualType ivarType = ivar->getType();
Qualifiers::ObjCLifetime ivarLifetime = ivarType.getObjCLifetime();
if (ivarLifetime == Qualifiers::OCL_Strong)
- property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
+ property->setPropertyAttributes(ObjCPropertyAttribute::strong);
else if (ivarLifetime == Qualifiers::OCL_Weak)
- property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_weak);
+ property->setPropertyAttributes(ObjCPropertyAttribute::weak);
}
-static bool
-isIncompatiblePropertyAttribute(unsigned Attr1, unsigned Attr2,
- ObjCPropertyDecl::PropertyAttributeKind Kind) {
+static bool isIncompatiblePropertyAttribute(unsigned Attr1, unsigned Attr2,
+ ObjCPropertyAttribute::Kind Kind) {
return (Attr1 & Kind) != (Attr2 & Kind);
}
@@ -912,30 +917,34 @@
};
// The ownership might be incompatible unless the property has no explicit
// ownership.
- bool HasOwnership = (Attr & (ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_strong |
- ObjCPropertyDecl::OBJC_PR_copy |
- ObjCPropertyDecl::OBJC_PR_assign |
- ObjCPropertyDecl::OBJC_PR_unsafe_unretained |
- ObjCPropertyDecl::OBJC_PR_weak)) != 0;
- if (HasOwnership &&
- isIncompatiblePropertyAttribute(OriginalAttributes, Attr,
- ObjCPropertyDecl::OBJC_PR_copy)) {
- Diag(OriginalAttributes & ObjCPropertyDecl::OBJC_PR_copy, "copy");
+ bool HasOwnership =
+ (Attr & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong |
+ ObjCPropertyAttribute::copy |
+ ObjCPropertyAttribute::assign |
+ ObjCPropertyAttribute::unsafe_unretained |
+ ObjCPropertyAttribute::weak)) != 0;
+ if (HasOwnership && isIncompatiblePropertyAttribute(
+ OriginalAttributes, Attr,
+ ObjCPropertyAttribute::copy)) {
+ Diag(OriginalAttributes & ObjCPropertyAttribute::copy,
+ "copy");
continue;
}
if (HasOwnership && areIncompatiblePropertyAttributes(
OriginalAttributes, Attr,
- ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_strong)) {
- Diag(OriginalAttributes & (ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_strong),
+ ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong)) {
+ Diag(OriginalAttributes & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong),
"retain (or strong)");
continue;
}
- if (isIncompatiblePropertyAttribute(OriginalAttributes, Attr,
- ObjCPropertyDecl::OBJC_PR_atomic)) {
- Diag(OriginalAttributes & ObjCPropertyDecl::OBJC_PR_atomic, "atomic");
+ if (isIncompatiblePropertyAttribute(
+ OriginalAttributes, Attr,
+ ObjCPropertyAttribute::atomic)) {
+ Diag(OriginalAttributes & ObjCPropertyAttribute::atomic,
+ "atomic");
continue;
}
}
@@ -1126,8 +1135,8 @@
return nullptr;
}
unsigned PIkind = property->getPropertyAttributesAsWritten();
- if ((PIkind & (ObjCPropertyDecl::OBJC_PR_atomic |
- ObjCPropertyDecl::OBJC_PR_nonatomic) ) == 0) {
+ if ((PIkind & (ObjCPropertyAttribute::atomic |
+ ObjCPropertyAttribute::nonatomic)) == 0) {
if (AtLoc.isValid())
Diag(AtLoc, diag::warn_implicit_atomic_property);
else
@@ -1143,10 +1152,8 @@
return nullptr;
}
}
- if (Synthesize&&
- (PIkind & ObjCPropertyDecl::OBJC_PR_readonly) &&
- property->hasAttr<IBOutletAttr>() &&
- !AtLoc.isValid()) {
+ if (Synthesize && (PIkind & ObjCPropertyAttribute::readonly) &&
+ property->hasAttr<IBOutletAttr>() && !AtLoc.isValid()) {
bool ReadWriteProperty = false;
// Search into the class extensions and see if 'readonly property is
// redeclared 'readwrite', then no warning is to be issued.
@@ -1155,7 +1162,7 @@
if (!R.empty())
if (ObjCPropertyDecl *ExtProp = dyn_cast<ObjCPropertyDecl>(R[0])) {
PIkind = ExtProp->getPropertyAttributesAsWritten();
- if (PIkind & ObjCPropertyDecl::OBJC_PR_readwrite) {
+ if (PIkind & ObjCPropertyAttribute::readwrite) {
ReadWriteProperty = true;
break;
}
@@ -1232,16 +1239,15 @@
if (getLangOpts().ObjCAutoRefCount &&
(property->getPropertyAttributesAsWritten() &
- ObjCPropertyDecl::OBJC_PR_readonly) &&
+ ObjCPropertyAttribute::readonly) &&
PropertyIvarType->isObjCRetainableType()) {
setImpliedPropertyAttributeForReadOnlyProperty(property, Ivar);
}
- ObjCPropertyDecl::PropertyAttributeKind kind
- = property->getPropertyAttributes();
+ ObjCPropertyAttribute::Kind kind = property->getPropertyAttributes();
bool isARCWeak = false;
- if (kind & ObjCPropertyDecl::OBJC_PR_weak) {
+ if (kind & ObjCPropertyAttribute::weak) {
// Add GC __weak to the ivar type if the property is weak.
if (getLangOpts().getGC() != LangOptions::NonGC) {
assert(!getLangOpts().ObjCAutoRefCount);
@@ -1312,7 +1318,7 @@
// It's an error if we have to do this and the user didn't
// explicitly write an ownership attribute on the property.
if (!hasWrittenStorageAttribute(property, QueryKind) &&
- !(kind & ObjCPropertyDecl::OBJC_PR_strong)) {
+ !(kind & ObjCPropertyAttribute::strong)) {
Diag(PropertyDiagLoc,
diag::err_arc_objc_property_default_assign_on_object);
Diag(property->getLocation(), diag::note_property_declare);
@@ -1551,7 +1557,7 @@
ExprResult Res = BuildBinOp(S, PropertyDiagLoc,
BO_Assign, lhs, rhs);
if (property->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_atomic) {
+ ObjCPropertyAttribute::atomic) {
Expr *callExpr = Res.getAs<Expr>();
if (const CXXOperatorCallExpr *CXXCE =
dyn_cast_or_null<CXXOperatorCallExpr>(callExpr))
@@ -1651,10 +1657,8 @@
ObjCPropertyDecl *SuperProperty,
const IdentifierInfo *inheritedName,
bool OverridingProtocolProperty) {
- ObjCPropertyDecl::PropertyAttributeKind CAttr =
- Property->getPropertyAttributes();
- ObjCPropertyDecl::PropertyAttributeKind SAttr =
- SuperProperty->getPropertyAttributes();
+ ObjCPropertyAttribute::Kind CAttr = Property->getPropertyAttributes();
+ ObjCPropertyAttribute::Kind SAttr = SuperProperty->getPropertyAttributes();
// We allow readonly properties without an explicit ownership
// (assign/unsafe_unretained/weak/retain/strong/copy) in super class
@@ -1663,21 +1667,21 @@
!getOwnershipRule(SAttr) && getOwnershipRule(CAttr))
;
else {
- if ((CAttr & ObjCPropertyDecl::OBJC_PR_readonly)
- && (SAttr & ObjCPropertyDecl::OBJC_PR_readwrite))
+ if ((CAttr & ObjCPropertyAttribute::readonly) &&
+ (SAttr & ObjCPropertyAttribute::readwrite))
Diag(Property->getLocation(), diag::warn_readonly_property)
<< Property->getDeclName() << inheritedName;
- if ((CAttr & ObjCPropertyDecl::OBJC_PR_copy)
- != (SAttr & ObjCPropertyDecl::OBJC_PR_copy))
+ if ((CAttr & ObjCPropertyAttribute::copy) !=
+ (SAttr & ObjCPropertyAttribute::copy))
Diag(Property->getLocation(), diag::warn_property_attribute)
<< Property->getDeclName() << "copy" << inheritedName;
- else if (!(SAttr & ObjCPropertyDecl::OBJC_PR_readonly)){
+ else if (!(SAttr & ObjCPropertyAttribute::readonly)) {
unsigned CAttrRetain =
- (CAttr &
- (ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
+ (CAttr & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong));
unsigned SAttrRetain =
- (SAttr &
- (ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
+ (SAttr & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong));
bool CStrong = (CAttrRetain != 0);
bool SStrong = (SAttrRetain != 0);
if (CStrong != SStrong)
@@ -1885,7 +1889,8 @@
ObjCPropertyDecl *Prop) {
bool SuperClassImplementsGetter = false;
bool SuperClassImplementsSetter = false;
- if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readonly)
+ if (Prop->getPropertyAttributes() &
+ ObjCPropertyAttribute::readonly)
SuperClassImplementsSetter = true;
while (IDecl->getSuperClass()) {
@@ -1928,7 +1933,8 @@
continue;
ObjCMethodDecl *ImpMethod = IMPDecl->getInstanceMethod(Prop->getGetterName());
if (ImpMethod && !ImpMethod->getBody()) {
- if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readonly)
+ if (Prop->getPropertyAttributes() &
+ ObjCPropertyAttribute::readonly)
continue;
ImpMethod = IMPDecl->getInstanceMethod(Prop->getSetterName());
if (ImpMethod && !ImpMethod->getBody())
@@ -1965,16 +1971,16 @@
}
// If property to be implemented in the super class, ignore.
if (PropInSuperClass) {
- if ((Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readwrite) &&
+ if ((Prop->getPropertyAttributes() &
+ ObjCPropertyAttribute::readwrite) &&
(PropInSuperClass->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_readonly) &&
+ ObjCPropertyAttribute::readonly) &&
!IMPDecl->getInstanceMethod(Prop->getSetterName()) &&
!IDecl->HasUserDeclaredSetterMethod(Prop)) {
Diag(Prop->getLocation(), diag::warn_no_autosynthesis_property)
<< Prop->getIdentifier();
Diag(PropInSuperClass->getLocation(), diag::note_property_declare);
- }
- else {
+ } else {
Diag(Prop->getLocation(), diag::warn_autosynthesis_property_in_superclass)
<< Prop->getIdentifier();
Diag(PropInSuperClass->getLocation(), diag::note_property_declare);
@@ -2161,12 +2167,11 @@
const auto *property = propertyImpl->getPropertyDecl();
// Warn about null_resettable properties with synthesized setters,
// because the setter won't properly handle nil.
- if (propertyImpl->getPropertyImplementation()
- == ObjCPropertyImplDecl::Synthesize &&
+ if (propertyImpl->getPropertyImplementation() ==
+ ObjCPropertyImplDecl::Synthesize &&
(property->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_null_resettable) &&
- property->getGetterMethodDecl() &&
- property->getSetterMethodDecl()) {
+ ObjCPropertyAttribute::null_resettable) &&
+ property->getGetterMethodDecl() && property->getSetterMethodDecl()) {
auto *getterImpl = propertyImpl->getGetterMethodDecl();
auto *setterImpl = propertyImpl->getSetterMethodDecl();
if ((!getterImpl || getterImpl->isSynthesizedAccessorStub()) &&
@@ -2204,8 +2209,8 @@
unsigned Attributes = Property->getPropertyAttributes();
unsigned AttributesAsWritten = Property->getPropertyAttributesAsWritten();
- if (!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic) &&
- !(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_nonatomic)) {
+ if (!(AttributesAsWritten & ObjCPropertyAttribute::atomic) &&
+ !(AttributesAsWritten & ObjCPropertyAttribute::nonatomic)) {
GetterMethod = Property->isClassProperty() ?
IMPDecl->getClassMethod(Property->getGetterName()) :
IMPDecl->getInstanceMethod(Property->getGetterName());
@@ -2231,8 +2236,8 @@
}
// We only care about readwrite atomic property.
- if ((Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) ||
- !(Attributes & ObjCPropertyDecl::OBJC_PR_readwrite))
+ if ((Attributes & ObjCPropertyAttribute::nonatomic) ||
+ !(Attributes & ObjCPropertyAttribute::readwrite))
continue;
if (const ObjCPropertyImplDecl *PIDecl = IMPDecl->FindPropertyImplDecl(
Property->getIdentifier(), Property->getQueryKind())) {
@@ -2253,7 +2258,8 @@
<< (SetterMethod != nullptr);
// fixit stuff.
if (Property->getLParenLoc().isValid() &&
- !(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic)) {
+ !(AttributesAsWritten &
+ ObjCPropertyAttribute::atomic)) {
// @property () ... case.
SourceLocation AfterLParen =
getLocForEndOfToken(Property->getLParenLoc());
@@ -2269,8 +2275,7 @@
Diag(Property->getLocation(),
diag::note_atomic_property_fixup_suggest)
<< FixItHint::CreateInsertion(startLoc, "(nonatomic) ");
- }
- else
+ } else
Diag(MethodLoc, diag::note_atomic_property_fixup_suggest);
Diag(Property->getLocation(), diag::note_property_declare);
}
@@ -2498,7 +2503,7 @@
// If the property is null_resettable, the getter returns nonnull.
if (property->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_null_resettable) {
+ ObjCPropertyAttribute::null_resettable) {
QualType modifiedTy = resultTy;
if (auto nullability = AttributedType::stripOuterNullability(modifiedTy)) {
if (*nullability == NullabilityKind::Unspecified)
@@ -2577,7 +2582,7 @@
// If the property is null_resettable, the setter accepts a
// nullable value.
if (property->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_null_resettable) {
+ ObjCPropertyAttribute::null_resettable) {
QualType modifiedTy = paramTy;
if (auto nullability = AttributedType::stripOuterNullability(modifiedTy)){
if (*nullability == NullabilityKind::Unspecified)
@@ -2665,8 +2670,8 @@
if (!PDecl || PDecl->isInvalidDecl())
return;
- if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
- (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
+ if ((Attributes & ObjCPropertyAttribute::readonly) &&
+ (Attributes & ObjCPropertyAttribute::readwrite))
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "readonly" << "readwrite";
@@ -2674,104 +2679,110 @@
QualType PropertyTy = PropertyDecl->getType();
// Check for copy or retain on non-object types.
- if ((Attributes & (ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
- ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong)) &&
+ if ((Attributes & (ObjCPropertyAttribute::weak |
+ ObjCPropertyAttribute::copy |
+ ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong)) &&
!PropertyTy->isObjCRetainableType() &&
!PropertyDecl->hasAttr<ObjCNSObjectAttr>()) {
Diag(Loc, diag::err_objc_property_requires_object)
- << (Attributes & ObjCDeclSpec::DQ_PR_weak ? "weak" :
- Attributes & ObjCDeclSpec::DQ_PR_copy ? "copy" : "retain (or strong)");
- Attributes &= ~(ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
- ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong);
+ << (Attributes & ObjCPropertyAttribute::weak
+ ? "weak"
+ : Attributes & ObjCPropertyAttribute::copy
+ ? "copy"
+ : "retain (or strong)");
+ Attributes &= ~(ObjCPropertyAttribute::weak |
+ ObjCPropertyAttribute::copy |
+ ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong);
PropertyDecl->setInvalidDecl();
}
// Check for assign on object types.
- if ((Attributes & ObjCDeclSpec::DQ_PR_assign) &&
- !(Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) &&
+ if ((Attributes & ObjCPropertyAttribute::assign) &&
+ !(Attributes & ObjCPropertyAttribute::unsafe_unretained) &&
PropertyTy->isObjCRetainableType() &&
!PropertyTy->isObjCARCImplicitlyUnretainedType()) {
Diag(Loc, diag::warn_objc_property_assign_on_object);
}
// Check for more than one of { assign, copy, retain }.
- if (Attributes & ObjCDeclSpec::DQ_PR_assign) {
- if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
+ if (Attributes & ObjCPropertyAttribute::assign) {
+ if (Attributes & ObjCPropertyAttribute::copy) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "assign" << "copy";
- Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
+ Attributes &= ~ObjCPropertyAttribute::copy;
}
- if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
+ if (Attributes & ObjCPropertyAttribute::retain) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "assign" << "retain";
- Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
+ Attributes &= ~ObjCPropertyAttribute::retain;
}
- if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
+ if (Attributes & ObjCPropertyAttribute::strong) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "assign" << "strong";
- Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
+ Attributes &= ~ObjCPropertyAttribute::strong;
}
- if (getLangOpts().ObjCAutoRefCount &&
- (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
+ if (getLangOpts().ObjCAutoRefCount &&
+ (Attributes & ObjCPropertyAttribute::weak)) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "assign" << "weak";
- Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
+ Attributes &= ~ObjCPropertyAttribute::weak;
}
if (PropertyDecl->hasAttr<IBOutletCollectionAttr>())
Diag(Loc, diag::warn_iboutletcollection_property_assign);
- } else if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) {
- if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
+ } else if (Attributes &
+ ObjCPropertyAttribute::unsafe_unretained) {
+ if (Attributes & ObjCPropertyAttribute::copy) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "unsafe_unretained" << "copy";
- Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
+ Attributes &= ~ObjCPropertyAttribute::copy;
}
- if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
+ if (Attributes & ObjCPropertyAttribute::retain) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "unsafe_unretained" << "retain";
- Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
+ Attributes &= ~ObjCPropertyAttribute::retain;
}
- if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
+ if (Attributes & ObjCPropertyAttribute::strong) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "unsafe_unretained" << "strong";
- Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
+ Attributes &= ~ObjCPropertyAttribute::strong;
}
- if (getLangOpts().ObjCAutoRefCount &&
- (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
+ if (getLangOpts().ObjCAutoRefCount &&
+ (Attributes & ObjCPropertyAttribute::weak)) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "unsafe_unretained" << "weak";
- Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
+ Attributes &= ~ObjCPropertyAttribute::weak;
}
- } else if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
- if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
+ } else if (Attributes & ObjCPropertyAttribute::copy) {
+ if (Attributes & ObjCPropertyAttribute::retain) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "copy" << "retain";
- Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
+ Attributes &= ~ObjCPropertyAttribute::retain;
}
- if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
+ if (Attributes & ObjCPropertyAttribute::strong) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "copy" << "strong";
- Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
+ Attributes &= ~ObjCPropertyAttribute::strong;
}
- if (Attributes & ObjCDeclSpec::DQ_PR_weak) {
+ if (Attributes & ObjCPropertyAttribute::weak) {
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "copy" << "weak";
- Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
+ Attributes &= ~ObjCPropertyAttribute::weak;
}
- }
- else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
- (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
- Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
- << "retain" << "weak";
- Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
- }
- else if ((Attributes & ObjCDeclSpec::DQ_PR_strong) &&
- (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
- Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
- << "strong" << "weak";
- Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
+ } else if ((Attributes & ObjCPropertyAttribute::retain) &&
+ (Attributes & ObjCPropertyAttribute::weak)) {
+ Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) << "retain"
+ << "weak";
+ Attributes &= ~ObjCPropertyAttribute::retain;
+ } else if ((Attributes & ObjCPropertyAttribute::strong) &&
+ (Attributes & ObjCPropertyAttribute::weak)) {
+ Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) << "strong"
+ << "weak";
+ Attributes &= ~ObjCPropertyAttribute::weak;
}
- if (Attributes & ObjCDeclSpec::DQ_PR_weak) {
+ if (Attributes & ObjCPropertyAttribute::weak) {
// 'weak' and 'nonnull' are mutually exclusive.
if (auto nullability = PropertyTy->getNullability(Context)) {
if (*nullability == NullabilityKind::NonNull)
@@ -2780,41 +2791,41 @@
}
}
- if ((Attributes & ObjCDeclSpec::DQ_PR_atomic) &&
- (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)) {
- Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
- << "atomic" << "nonatomic";
- Attributes &= ~ObjCDeclSpec::DQ_PR_atomic;
+ if ((Attributes & ObjCPropertyAttribute::atomic) &&
+ (Attributes & ObjCPropertyAttribute::nonatomic)) {
+ Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) << "atomic"
+ << "nonatomic";
+ Attributes &= ~ObjCPropertyAttribute::atomic;
}
// Warn if user supplied no assignment attribute, property is
// readwrite, and this is an object type.
if (!getOwnershipRule(Attributes) && PropertyTy->isObjCRetainableType()) {
- if (Attributes & ObjCDeclSpec::DQ_PR_readonly) {
+ if (Attributes & ObjCPropertyAttribute::readonly) {
// do nothing
} else if (getLangOpts().ObjCAutoRefCount) {
// With arc, @property definitions should default to strong when
// not specified.
- PropertyDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
+ PropertyDecl->setPropertyAttributes(
+ ObjCPropertyAttribute::strong);
} else if (PropertyTy->isObjCObjectPointerType()) {
- bool isAnyClassTy =
- (PropertyTy->isObjCClassType() ||
- PropertyTy->isObjCQualifiedClassType());
- // In non-gc, non-arc mode, 'Class' is treated as a 'void *' no need to
- // issue any warning.
- if (isAnyClassTy && getLangOpts().getGC() == LangOptions::NonGC)
- ;
- else if (propertyInPrimaryClass) {
- // Don't issue warning on property with no life time in class
- // extension as it is inherited from property in primary class.
- // Skip this warning in gc-only mode.
- if (getLangOpts().getGC() != LangOptions::GCOnly)
- Diag(Loc, diag::warn_objc_property_no_assignment_attribute);
-
- // If non-gc code warn that this is likely inappropriate.
- if (getLangOpts().getGC() == LangOptions::NonGC)
- Diag(Loc, diag::warn_objc_property_default_assign_on_object);
- }
+ bool isAnyClassTy = (PropertyTy->isObjCClassType() ||
+ PropertyTy->isObjCQualifiedClassType());
+ // In non-gc, non-arc mode, 'Class' is treated as a 'void *' no need to
+ // issue any warning.
+ if (isAnyClassTy && getLangOpts().getGC() == LangOptions::NonGC)
+ ;
+ else if (propertyInPrimaryClass) {
+ // Don't issue warning on property with no life time in class
+ // extension as it is inherited from property in primary class.
+ // Skip this warning in gc-only mode.
+ if (getLangOpts().getGC() != LangOptions::GCOnly)
+ Diag(Loc, diag::warn_objc_property_no_assignment_attribute);
+
+ // If non-gc code warn that this is likely inappropriate.
+ if (getLangOpts().getGC() == LangOptions::NonGC)
+ Diag(Loc, diag::warn_objc_property_default_assign_on_object);
+ }
}
// FIXME: Implement warning dependent on NSCopying being
@@ -2823,18 +2834,18 @@
// (please trim this list while you are at it).
}
- if (!(Attributes & ObjCDeclSpec::DQ_PR_copy)
- &&!(Attributes & ObjCDeclSpec::DQ_PR_readonly)
- && getLangOpts().getGC() == LangOptions::GCOnly
- && PropertyTy->isBlockPointerType())
+ if (!(Attributes & ObjCPropertyAttribute::copy) &&
+ !(Attributes & ObjCPropertyAttribute::readonly) &&
+ getLangOpts().getGC() == LangOptions::GCOnly &&
+ PropertyTy->isBlockPointerType())
Diag(Loc, diag::warn_objc_property_copy_missing_on_block);
- else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
- !(Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
- !(Attributes & ObjCDeclSpec::DQ_PR_strong) &&
+ else if ((Attributes & ObjCPropertyAttribute::retain) &&
+ !(Attributes & ObjCPropertyAttribute::readonly) &&
+ !(Attributes & ObjCPropertyAttribute::strong) &&
PropertyTy->isBlockPointerType())
- Diag(Loc, diag::warn_objc_property_retain_of_block);
+ Diag(Loc, diag::warn_objc_property_retain_of_block);
- if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
- (Attributes & ObjCDeclSpec::DQ_PR_setter))
+ if ((Attributes & ObjCPropertyAttribute::readonly) &&
+ (Attributes & ObjCPropertyAttribute::setter))
Diag(Loc, diag::warn_objc_readonly_property_has_setter);
}
Index: clang/lib/Sema/SemaExprObjC.cpp
===================================================================
--- clang/lib/Sema/SemaExprObjC.cpp
+++ clang/lib/Sema/SemaExprObjC.cpp
@@ -1953,7 +1953,8 @@
if (const ObjCPropertyDecl *PDecl = Setter->findPropertyDecl()) {
// Do not warn if user is using property-dot syntax to make call to
// user named setter.
- if (!(PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter))
+ if (!(PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::setter))
Diag(MemberLoc,
diag::warn_property_access_suggest)
<< MemberName << QualType(OPT, 0) << PDecl->getName()
@@ -3257,8 +3258,8 @@
if (getLangOpts().ObjCWeak) {
if (!isImplicit && Method) {
if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) {
- bool IsWeak =
- Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak;
+ bool IsWeak = Prop->getPropertyAttributes() &
+ ObjCPropertyAttribute::weak;
if (!IsWeak && Sel.isUnarySelector())
IsWeak = ReturnType.getObjCLifetime() & Qualifiers::OCL_Weak;
if (IsWeak && !isUnevaluatedContext() &&
Index: clang/lib/Sema/SemaCodeComplete.cpp
===================================================================
--- clang/lib/Sema/SemaCodeComplete.cpp
+++ clang/lib/Sema/SemaCodeComplete.cpp
@@ -6513,22 +6513,26 @@
Attributes |= NewFlag;
// Check for collisions with "readonly".
- if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
- (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
+ if ((Attributes & ObjCPropertyAttribute::readonly) &&
+ (Attributes & ObjCPropertyAttribute::readwrite))
return true;
// Check for more than one of { assign, copy, retain, strong, weak }.
unsigned AssignCopyRetMask =
- Attributes &
- (ObjCDeclSpec::DQ_PR_assign | ObjCDeclSpec::DQ_PR_unsafe_unretained |
- ObjCDeclSpec::DQ_PR_copy | ObjCDeclSpec::DQ_PR_retain |
- ObjCDeclSpec::DQ_PR_strong | ObjCDeclSpec::DQ_PR_weak);
- if (AssignCopyRetMask && AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
- AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
- AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
- AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
- AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
- AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
+ Attributes & (ObjCPropertyAttribute::assign |
+ ObjCPropertyAttribute::unsafe_unretained |
+ ObjCPropertyAttribute::copy |
+ ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong |
+ ObjCPropertyAttribute::weak);
+ if (AssignCopyRetMask &&
+ AssignCopyRetMask != ObjCPropertyAttribute::assign &&
+ AssignCopyRetMask !=
+ ObjCPropertyAttribute::unsafe_unretained &&
+ AssignCopyRetMask != ObjCPropertyAttribute::copy &&
+ AssignCopyRetMask != ObjCPropertyAttribute::retain &&
+ AssignCopyRetMask != ObjCPropertyAttribute::strong &&
+ AssignCopyRetMask != ObjCPropertyAttribute::weak)
return true;
return false;
@@ -6544,32 +6548,42 @@
CodeCompleter->getCodeCompletionTUInfo(),
CodeCompletionContext::CCC_Other);
Results.EnterNewScope();
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::readonly))
Results.AddResult(CodeCompletionResult("readonly"));
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
- Results.AddResult(CodeCompletionResult("assign"));
if (!ObjCPropertyFlagConflicts(Attributes,
- ObjCDeclSpec::DQ_PR_unsafe_unretained))
+ ObjCPropertyAttribute::assign))
+ Results.AddResult(CodeCompletionResult("assign"));
+ if (!ObjCPropertyFlagConflicts(
+ Attributes, ObjCPropertyAttribute::unsafe_unretained))
Results.AddResult(CodeCompletionResult("unsafe_unretained"));
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::readwrite))
Results.AddResult(CodeCompletionResult("readwrite"));
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::retain))
Results.AddResult(CodeCompletionResult("retain"));
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::strong))
Results.AddResult(CodeCompletionResult("strong"));
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::copy))
Results.AddResult(CodeCompletionResult("copy"));
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::nonatomic))
Results.AddResult(CodeCompletionResult("nonatomic"));
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::atomic))
Results.AddResult(CodeCompletionResult("atomic"));
// Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::weak))
Results.AddResult(CodeCompletionResult("weak"));
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::setter)) {
CodeCompletionBuilder Setter(Results.getAllocator(),
Results.getCodeCompletionTUInfo());
Setter.AddTypedTextChunk("setter");
@@ -6577,7 +6591,8 @@
Setter.AddPlaceholderChunk("method");
Results.AddResult(CodeCompletionResult(Setter.TakeString()));
}
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
+ if (!ObjCPropertyFlagConflicts(Attributes,
+ ObjCPropertyAttribute::getter)) {
CodeCompletionBuilder Getter(Results.getAllocator(),
Results.getCodeCompletionTUInfo());
Getter.AddTypedTextChunk("getter");
@@ -6585,7 +6600,8 @@
Getter.AddPlaceholderChunk("method");
Results.AddResult(CodeCompletionResult(Getter.TakeString()));
}
- if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
+ if (!ObjCPropertyFlagConflicts(
+ Attributes, ObjCPropertyAttribute::nullability)) {
Results.AddResult(CodeCompletionResult("nonnull"));
Results.AddResult(CodeCompletionResult("nullable"));
Results.AddResult(CodeCompletionResult("null_unspecified"));
Index: clang/lib/Sema/SemaChecking.cpp
===================================================================
--- clang/lib/Sema/SemaChecking.cpp
+++ clang/lib/Sema/SemaChecking.cpp
@@ -13803,12 +13803,12 @@
return;
unsigned Attributes = PD->getPropertyAttributes();
- if (Attributes & ObjCPropertyDecl::OBJC_PR_assign) {
+ if (Attributes & ObjCPropertyAttribute::assign) {
// when 'assign' attribute was not explicitly specified
// by user, ignore it and rely on property type itself
// for lifetime info.
unsigned AsWrittenAttr = PD->getPropertyAttributesAsWritten();
- if (!(AsWrittenAttr & ObjCPropertyDecl::OBJC_PR_assign) &&
+ if (!(AsWrittenAttr & ObjCPropertyAttribute::assign) &&
LHSType->isObjCRetainableType())
return;
@@ -13820,8 +13820,7 @@
}
RHS = cast->getSubExpr();
}
- }
- else if (Attributes & ObjCPropertyDecl::OBJC_PR_weak) {
+ } else if (Attributes & ObjCPropertyAttribute::weak) {
if (checkUnsafeAssignObject(*this, Loc, Qualifiers::OCL_Weak, RHS, true))
return;
}
Index: clang/lib/Parse/ParseObjc.cpp
===================================================================
--- clang/lib/Parse/ParseObjc.cpp
+++ clang/lib/Parse/ParseObjc.cpp
@@ -740,7 +740,8 @@
// Map a nullability property attribute to a context-sensitive keyword
// attribute.
- if (OCDS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability)
+ if (OCDS.getPropertyAttributes() &
+ ObjCPropertyAttribute::nullability)
addContextSensitiveTypeNullability(*this, FD.D, OCDS.getNullability(),
OCDS.getNullabilityLoc(),
addedToDeclSpec);
@@ -860,25 +861,26 @@
SourceLocation AttrName = ConsumeToken(); // consume last attribute name
if (II->isStr("readonly"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readonly);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::readonly);
else if (II->isStr("assign"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_assign);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::assign);
else if (II->isStr("unsafe_unretained"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_unsafe_unretained);
+ DS.setPropertyAttributes(
+ ObjCPropertyAttribute::unsafe_unretained);
else if (II->isStr("readwrite"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readwrite);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::readwrite);
else if (II->isStr("retain"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_retain);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::retain);
else if (II->isStr("strong"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_strong);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::strong);
else if (II->isStr("copy"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_copy);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::copy);
else if (II->isStr("nonatomic"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nonatomic);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::nonatomic);
else if (II->isStr("atomic"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_atomic);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::atomic);
else if (II->isStr("weak"))
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_weak);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::weak);
else if (II->isStr("getter") || II->isStr("setter")) {
bool IsSetter = II->getNameStart()[0] == 's';
@@ -910,7 +912,7 @@
}
if (IsSetter) {
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_setter);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::setter);
DS.setSetterName(SelIdent, SelLoc);
if (ExpectAndConsume(tok::colon,
@@ -919,44 +921,49 @@
return;
}
} else {
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_getter);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::getter);
DS.setGetterName(SelIdent, SelLoc);
}
} else if (II->isStr("nonnull")) {
- if (DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability)
+ if (DS.getPropertyAttributes() &
+ ObjCPropertyAttribute::nullability)
diagnoseRedundantPropertyNullability(*this, DS,
NullabilityKind::NonNull,
Tok.getLocation());
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nullability);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::nullability);
DS.setNullability(Tok.getLocation(), NullabilityKind::NonNull);
} else if (II->isStr("nullable")) {
- if (DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability)
+ if (DS.getPropertyAttributes() &
+ ObjCPropertyAttribute::nullability)
diagnoseRedundantPropertyNullability(*this, DS,
NullabilityKind::Nullable,
Tok.getLocation());
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nullability);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::nullability);
DS.setNullability(Tok.getLocation(), NullabilityKind::Nullable);
} else if (II->isStr("null_unspecified")) {
- if (DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability)
+ if (DS.getPropertyAttributes() &
+ ObjCPropertyAttribute::nullability)
diagnoseRedundantPropertyNullability(*this, DS,
NullabilityKind::Unspecified,
Tok.getLocation());
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nullability);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::nullability);
DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified);
} else if (II->isStr("null_resettable")) {
- if (DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nullability)
+ if (DS.getPropertyAttributes() &
+ ObjCPropertyAttribute::nullability)
diagnoseRedundantPropertyNullability(*this, DS,
NullabilityKind::Unspecified,
Tok.getLocation());
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nullability);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::nullability);
DS.setNullability(Tok.getLocation(), NullabilityKind::Unspecified);
// Also set the null_resettable bit.
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_null_resettable);
+ DS.setPropertyAttributes(
+ ObjCPropertyAttribute::null_resettable);
} else if (II->isStr("class")) {
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_class);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::classattr);
} else if (II->isStr("direct")) {
- DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_direct);
+ DS.setPropertyAttributes(ObjCPropertyAttribute::direct);
} else {
Diag(AttrName, diag::err_objc_expected_property_attr) << II;
SkipUntil(tok::r_paren, StopAtSemi);
Index: clang/lib/Frontend/Rewrite/RewriteObjC.cpp
===================================================================
--- clang/lib/Frontend/Rewrite/RewriteObjC.cpp
+++ clang/lib/Frontend/Rewrite/RewriteObjC.cpp
@@ -789,9 +789,10 @@
unsigned Attributes = PD->getPropertyAttributes();
if (PID->getGetterMethodDecl() && !PID->getGetterMethodDecl()->isDefined()) {
- bool GenGetProperty = !(Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) &&
- (Attributes & (ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_copy));
+ bool GenGetProperty =
+ !(Attributes & ObjCPropertyAttribute::nonatomic) &&
+ (Attributes & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::copy));
std::string Getr;
if (GenGetProperty && !objcGetPropertyDefined) {
objcGetPropertyDefined = true;
@@ -850,8 +851,9 @@
// Generate the 'setter' function.
std::string Setr;
- bool GenSetProperty = Attributes & (ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_copy);
+ bool GenSetProperty =
+ Attributes & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::copy);
if (GenSetProperty && !objcSetPropertyDefined) {
objcSetPropertyDefined = true;
// FIXME. Is this attribute correct in all cases?
@@ -870,11 +872,11 @@
Setr += ", (id)";
Setr += PD->getName();
Setr += ", ";
- if (Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic)
+ if (Attributes & ObjCPropertyAttribute::nonatomic)
Setr += "0, ";
else
Setr += "1, ";
- if (Attributes & ObjCPropertyDecl::OBJC_PR_copy)
+ if (Attributes & ObjCPropertyAttribute::copy)
Setr += "1)";
else
Setr += "0)";
Index: clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp
===================================================================
--- clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp
+++ clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp
@@ -941,9 +941,10 @@
unsigned Attributes = PD->getPropertyAttributes();
if (mustSynthesizeSetterGetterMethod(IMD, PD, true /*getter*/)) {
- bool GenGetProperty = !(Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) &&
- (Attributes & (ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_copy));
+ bool GenGetProperty =
+ !(Attributes & ObjCPropertyAttribute::nonatomic) &&
+ (Attributes & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::copy));
std::string Getr;
if (GenGetProperty && !objcGetPropertyDefined) {
objcGetPropertyDefined = true;
@@ -1002,8 +1003,9 @@
// Generate the 'setter' function.
std::string Setr;
- bool GenSetProperty = Attributes & (ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_copy);
+ bool GenSetProperty =
+ Attributes & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::copy);
if (GenSetProperty && !objcSetPropertyDefined) {
objcSetPropertyDefined = true;
// FIXME. Is this attribute correct in all cases?
@@ -1022,11 +1024,11 @@
Setr += ", (id)";
Setr += PD->getName();
Setr += ", ";
- if (Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic)
+ if (Attributes & ObjCPropertyAttribute::nonatomic)
Setr += "0, ";
else
Setr += "1, ";
- if (Attributes & ObjCPropertyDecl::OBJC_PR_copy)
+ if (Attributes & ObjCPropertyAttribute::copy)
Setr += "1)";
else
Setr += "0)";
Index: clang/lib/CodeGen/CGObjCGNU.cpp
===================================================================
--- clang/lib/CodeGen/CGObjCGNU.cpp
+++ clang/lib/CodeGen/CGObjCGNU.cpp
@@ -255,11 +255,11 @@
isDynamic=true) {
int attrs = property->getPropertyAttributes();
// For read-only properties, clear the copy and retain flags
- if (attrs & ObjCPropertyDecl::OBJC_PR_readonly) {
- attrs &= ~ObjCPropertyDecl::OBJC_PR_copy;
- attrs &= ~ObjCPropertyDecl::OBJC_PR_retain;
- attrs &= ~ObjCPropertyDecl::OBJC_PR_weak;
- attrs &= ~ObjCPropertyDecl::OBJC_PR_strong;
+ if (attrs & ObjCPropertyAttribute::readonly) {
+ attrs &= ~ObjCPropertyAttribute::copy;
+ attrs &= ~ObjCPropertyAttribute::retain;
+ attrs &= ~ObjCPropertyAttribute::weak;
+ attrs &= ~ObjCPropertyAttribute::strong;
}
// The first flags field has the same attribute values as clang uses internally
Fields.addInt(Int8Ty, attrs & 0xff);
Index: clang/lib/CodeGen/CGObjC.cpp
===================================================================
--- clang/lib/CodeGen/CGObjC.cpp
+++ clang/lib/CodeGen/CGObjC.cpp
@@ -3505,7 +3505,8 @@
if (!Ty->isRecordType())
return nullptr;
const ObjCPropertyDecl *PD = PID->getPropertyDecl();
- if ((!(PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_atomic)))
+ if ((!(PD->getPropertyAttributes() &
+ ObjCPropertyAttribute::atomic)))
return nullptr;
llvm::Constant *HelperFn = nullptr;
if (hasTrivialSetExpr(PID))
@@ -3589,7 +3590,8 @@
QualType Ty = PD->getType();
if (!Ty->isRecordType())
return nullptr;
- if ((!(PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_atomic)))
+ if ((!(PD->getPropertyAttributes() &
+ ObjCPropertyAttribute::atomic)))
return nullptr;
llvm::Constant *HelperFn = nullptr;
if (hasTrivialGetExpr(PID))
Index: clang/lib/Analysis/BodyFarm.cpp
===================================================================
--- clang/lib/Analysis/BodyFarm.cpp
+++ clang/lib/Analysis/BodyFarm.cpp
@@ -762,7 +762,7 @@
return nullptr;
// Ignore weak variables, which have special behavior.
- if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak)
+ if (Prop->getPropertyAttributes() & ObjCPropertyAttribute::weak)
return nullptr;
// Look to see if Sema has synthesized a body for us. This happens in
Index: clang/lib/AST/TextNodeDumper.cpp
===================================================================
--- clang/lib/AST/TextNodeDumper.cpp
+++ clang/lib/AST/TextNodeDumper.cpp
@@ -1958,35 +1958,35 @@
else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
OS << " optional";
- ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
- if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
- if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly)
+ ObjCPropertyAttribute::Kind Attrs = D->getPropertyAttributes();
+ if (Attrs != ObjCPropertyAttribute::noattr) {
+ if (Attrs & ObjCPropertyAttribute::readonly)
OS << " readonly";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
+ if (Attrs & ObjCPropertyAttribute::assign)
OS << " assign";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite)
+ if (Attrs & ObjCPropertyAttribute::readwrite)
OS << " readwrite";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_retain)
+ if (Attrs & ObjCPropertyAttribute::retain)
OS << " retain";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_copy)
+ if (Attrs & ObjCPropertyAttribute::copy)
OS << " copy";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic)
+ if (Attrs & ObjCPropertyAttribute::nonatomic)
OS << " nonatomic";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic)
+ if (Attrs & ObjCPropertyAttribute::atomic)
OS << " atomic";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_weak)
+ if (Attrs & ObjCPropertyAttribute::weak)
OS << " weak";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_strong)
+ if (Attrs & ObjCPropertyAttribute::strong)
OS << " strong";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained)
+ if (Attrs & ObjCPropertyAttribute::unsafe_unretained)
OS << " unsafe_unretained";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_class)
+ if (Attrs & ObjCPropertyAttribute::classattr)
OS << " class";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_direct)
+ if (Attrs & ObjCPropertyAttribute::direct)
OS << " direct";
- if (Attrs & ObjCPropertyDecl::OBJC_PR_getter)
+ if (Attrs & ObjCPropertyAttribute::getter)
dumpDeclRef(D->getGetterMethodDecl(), "getter");
- if (Attrs & ObjCPropertyDecl::OBJC_PR_setter)
+ if (Attrs & ObjCPropertyAttribute::setter)
dumpDeclRef(D->getSetterMethodDecl(), "setter");
}
}
Index: clang/lib/AST/JSONNodeDumper.cpp
===================================================================
--- clang/lib/AST/JSONNodeDumper.cpp
+++ clang/lib/AST/JSONNodeDumper.cpp
@@ -999,31 +999,42 @@
case ObjCPropertyDecl::Optional: JOS.attribute("control", "optional"); break;
}
- ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
- if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
- if (Attrs & ObjCPropertyDecl::OBJC_PR_getter)
+ ObjCPropertyAttribute::Kind Attrs = D->getPropertyAttributes();
+ if (Attrs != ObjCPropertyAttribute::noattr) {
+ if (Attrs & ObjCPropertyAttribute::getter)
JOS.attribute("getter", createBareDeclRef(D->getGetterMethodDecl()));
- if (Attrs & ObjCPropertyDecl::OBJC_PR_setter)
+ if (Attrs & ObjCPropertyAttribute::setter)
JOS.attribute("setter", createBareDeclRef(D->getSetterMethodDecl()));
- attributeOnlyIfTrue("readonly", Attrs & ObjCPropertyDecl::OBJC_PR_readonly);
- attributeOnlyIfTrue("assign", Attrs & ObjCPropertyDecl::OBJC_PR_assign);
+ attributeOnlyIfTrue("readonly",
+ Attrs & ObjCPropertyAttribute::readonly);
+ attributeOnlyIfTrue("assign",
+ Attrs & ObjCPropertyAttribute::assign);
attributeOnlyIfTrue("readwrite",
- Attrs & ObjCPropertyDecl::OBJC_PR_readwrite);
- attributeOnlyIfTrue("retain", Attrs & ObjCPropertyDecl::OBJC_PR_retain);
- attributeOnlyIfTrue("copy", Attrs & ObjCPropertyDecl::OBJC_PR_copy);
+ Attrs & ObjCPropertyAttribute::readwrite);
+ attributeOnlyIfTrue("retain",
+ Attrs & ObjCPropertyAttribute::retain);
+ attributeOnlyIfTrue("copy",
+ Attrs & ObjCPropertyAttribute::copy);
attributeOnlyIfTrue("nonatomic",
- Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic);
- attributeOnlyIfTrue("atomic", Attrs & ObjCPropertyDecl::OBJC_PR_atomic);
- attributeOnlyIfTrue("weak", Attrs & ObjCPropertyDecl::OBJC_PR_weak);
- attributeOnlyIfTrue("strong", Attrs & ObjCPropertyDecl::OBJC_PR_strong);
- attributeOnlyIfTrue("unsafe_unretained",
- Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
- attributeOnlyIfTrue("class", Attrs & ObjCPropertyDecl::OBJC_PR_class);
- attributeOnlyIfTrue("direct", Attrs & ObjCPropertyDecl::OBJC_PR_direct);
+ Attrs & ObjCPropertyAttribute::nonatomic);
+ attributeOnlyIfTrue("atomic",
+ Attrs & ObjCPropertyAttribute::atomic);
+ attributeOnlyIfTrue("weak",
+ Attrs & ObjCPropertyAttribute::weak);
+ attributeOnlyIfTrue("strong",
+ Attrs & ObjCPropertyAttribute::strong);
+ attributeOnlyIfTrue(
+ "unsafe_unretained",
+ Attrs & ObjCPropertyAttribute::unsafe_unretained);
+ attributeOnlyIfTrue("class",
+ Attrs & ObjCPropertyAttribute::classattr);
+ attributeOnlyIfTrue("direct",
+ Attrs & ObjCPropertyAttribute::direct);
attributeOnlyIfTrue("nullability",
- Attrs & ObjCPropertyDecl::OBJC_PR_nullability);
+ Attrs & ObjCPropertyAttribute::nullability);
attributeOnlyIfTrue("null_resettable",
- Attrs & ObjCPropertyDecl::OBJC_PR_null_resettable);
+ Attrs &
+ ObjCPropertyAttribute::null_resettable);
}
}
Index: clang/lib/AST/DeclPrinter.cpp
===================================================================
--- clang/lib/AST/DeclPrinter.cpp
+++ clang/lib/AST/DeclPrinter.cpp
@@ -1428,85 +1428,95 @@
QualType T = PDecl->getType();
Out << "@property";
- if (PDecl->getPropertyAttributes() != ObjCPropertyDecl::OBJC_PR_noattr) {
+ if (PDecl->getPropertyAttributes() !=
+ ObjCPropertyAttribute::noattr) {
bool first = true;
Out << "(";
- if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_class) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::classattr) {
Out << (first ? "" : ", ") << "class";
first = false;
}
- if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_direct) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::direct) {
Out << (first ? "" : ", ") << "direct";
first = false;
}
if (PDecl->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_nonatomic) {
+ ObjCPropertyAttribute::nonatomic) {
Out << (first ? "" : ", ") << "nonatomic";
first = false;
}
if (PDecl->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_atomic) {
+ ObjCPropertyAttribute::atomic) {
Out << (first ? "" : ", ") << "atomic";
first = false;
}
- if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_assign) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::assign) {
Out << (first ? "" : ", ") << "assign";
first = false;
}
- if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_retain) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::retain) {
Out << (first ? "" : ", ") << "retain";
first = false;
}
- if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_strong) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::strong) {
Out << (first ? "" : ", ") << "strong";
first = false;
}
- if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_copy) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::copy) {
Out << (first ? "" : ", ") << "copy";
first = false;
}
- if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::weak) {
Out << (first ? "" : ", ") << "weak";
first = false;
}
- if (PDecl->getPropertyAttributes()
- & ObjCPropertyDecl::OBJC_PR_unsafe_unretained) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::unsafe_unretained) {
Out << (first ? "" : ", ") << "unsafe_unretained";
first = false;
}
if (PDecl->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_readwrite) {
+ ObjCPropertyAttribute::readwrite) {
Out << (first ? "" : ", ") << "readwrite";
first = false;
}
if (PDecl->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_readonly) {
+ ObjCPropertyAttribute::readonly) {
Out << (first ? "" : ", ") << "readonly";
first = false;
}
- if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::getter) {
Out << (first ? "" : ", ") << "getter = ";
PDecl->getGetterName().print(Out);
first = false;
}
- if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
+ if (PDecl->getPropertyAttributes() &
+ ObjCPropertyAttribute::setter) {
Out << (first ? "" : ", ") << "setter = ";
PDecl->getSetterName().print(Out);
first = false;
}
if (PDecl->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_nullability) {
+ ObjCPropertyAttribute::nullability) {
if (auto nullability = AttributedType::stripOuterNullability(T)) {
if (*nullability == NullabilityKind::Unspecified &&
(PDecl->getPropertyAttributes() &
- ObjCPropertyDecl::OBJC_PR_null_resettable)) {
+ ObjCPropertyAttribute::null_resettable)) {
Out << (first ? "" : ", ") << "null_resettable";
} else {
Out << (first ? "" : ", ")
Index: clang/lib/AST/DeclObjC.cpp
===================================================================
--- clang/lib/AST/DeclObjC.cpp
+++ clang/lib/AST/DeclObjC.cpp
@@ -146,7 +146,8 @@
// auto-synthesized).
for (const auto *P : Cat->properties())
if (P->getIdentifier() == Property->getIdentifier()) {
- if (P->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readwrite)
+ if (P->getPropertyAttributes() &
+ ObjCPropertyAttribute::readwrite)
return true;
break;
}
Index: clang/lib/AST/ASTContext.cpp
===================================================================
--- clang/lib/AST/ASTContext.cpp
+++ clang/lib/AST/ASTContext.cpp
@@ -6715,11 +6715,11 @@
if (PD->isReadOnly()) {
S += ",R";
- if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_copy)
+ if (PD->getPropertyAttributes() & ObjCPropertyAttribute::copy)
S += ",C";
- if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_retain)
+ if (PD->getPropertyAttributes() & ObjCPropertyAttribute::retain)
S += ",&";
- if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak)
+ if (PD->getPropertyAttributes() & ObjCPropertyAttribute::weak)
S += ",W";
} else {
switch (PD->getSetterKind()) {
@@ -6735,15 +6735,16 @@
if (Dynamic)
S += ",D";
- if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
+ if (PD->getPropertyAttributes() &
+ ObjCPropertyAttribute::nonatomic)
S += ",N";
- if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
+ if (PD->getPropertyAttributes() & ObjCPropertyAttribute::getter) {
S += ",G";
S += PD->getGetterName().getAsString();
}
- if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
+ if (PD->getPropertyAttributes() & ObjCPropertyAttribute::setter) {
S += ",S";
S += PD->getSetterName().getAsString();
}
Index: clang/lib/ARCMigrate/TransZeroOutPropsInDealloc.cpp
===================================================================
--- clang/lib/ARCMigrate/TransZeroOutPropsInDealloc.cpp
+++ clang/lib/ARCMigrate/TransZeroOutPropsInDealloc.cpp
@@ -118,13 +118,11 @@
ObjCPropertyDecl *PD = PID->getPropertyDecl();
ObjCMethodDecl *setterM = PD->getSetterMethodDecl();
if (!(setterM && setterM->isDefined())) {
- ObjCPropertyDecl::PropertyAttributeKind AttrKind =
- PD->getPropertyAttributes();
- if (AttrKind &
- (ObjCPropertyDecl::OBJC_PR_retain |
- ObjCPropertyDecl::OBJC_PR_copy |
- ObjCPropertyDecl::OBJC_PR_strong))
- SynthesizedProperties[PD] = PID;
+ ObjCPropertyAttribute::Kind AttrKind = PD->getPropertyAttributes();
+ if (AttrKind & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::copy |
+ ObjCPropertyAttribute::strong))
+ SynthesizedProperties[PD] = PID;
}
}
}
Index: clang/lib/ARCMigrate/TransProperties.cpp
===================================================================
--- clang/lib/ARCMigrate/TransProperties.cpp
+++ clang/lib/ARCMigrate/TransProperties.cpp
@@ -168,22 +168,22 @@
}
void rewriteProperty(PropsTy &props, SourceLocation atLoc) {
- ObjCPropertyDecl::PropertyAttributeKind propAttrs = getPropertyAttrs(props);
+ ObjCPropertyAttribute::Kind propAttrs = getPropertyAttrs(props);
- if (propAttrs & (ObjCPropertyDecl::OBJC_PR_copy |
- ObjCPropertyDecl::OBJC_PR_unsafe_unretained |
- ObjCPropertyDecl::OBJC_PR_strong |
- ObjCPropertyDecl::OBJC_PR_weak))
+ if (propAttrs & (ObjCPropertyAttribute::copy |
+ ObjCPropertyAttribute::unsafe_unretained |
+ ObjCPropertyAttribute::strong |
+ ObjCPropertyAttribute::weak))
return;
- if (propAttrs & ObjCPropertyDecl::OBJC_PR_retain) {
+ if (propAttrs & ObjCPropertyAttribute::retain) {
// strong is the default.
return doPropAction(PropAction_RetainReplacedWithStrong, props, atLoc);
}
bool HasIvarAssignedAPlusOneObject = hasIvarAssignedAPlusOneObject(props);
- if (propAttrs & ObjCPropertyDecl::OBJC_PR_assign) {
+ if (propAttrs & ObjCPropertyAttribute::assign) {
if (HasIvarAssignedAPlusOneObject)
return doPropAction(PropAction_AssignRemoved, props, atLoc);
return doPropAction(PropAction_AssignRewritten, props, atLoc);
@@ -354,11 +354,10 @@
return ty;
}
- ObjCPropertyDecl::PropertyAttributeKind
- getPropertyAttrs(PropsTy &props) const {
+ ObjCPropertyAttribute::Kind getPropertyAttrs(PropsTy &props) const {
assert(!props.empty());
- ObjCPropertyDecl::PropertyAttributeKind
- attrs = props[0].PropD->getPropertyAttributesAsWritten();
+ ObjCPropertyAttribute::Kind attrs =
+ props[0].PropD->getPropertyAttributesAsWritten();
#ifndef NDEBUG
for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
Index: clang/lib/ARCMigrate/TransGCAttrs.cpp
===================================================================
--- clang/lib/ARCMigrate/TransGCAttrs.cpp
+++ clang/lib/ARCMigrate/TransGCAttrs.cpp
@@ -231,8 +231,7 @@
SmallVector<std::pair<AttributedTypeLoc, ObjCPropertyDecl *>, 4> ATLs;
bool hasWeak = false, hasStrong = false;
- ObjCPropertyDecl::PropertyAttributeKind
- Attrs = ObjCPropertyDecl::OBJC_PR_noattr;
+ ObjCPropertyAttribute::Kind Attrs = ObjCPropertyAttribute::noattr;
for (IndivPropsTy::iterator
PI = IndProps.begin(), PE = IndProps.end(); PI != PE; ++PI) {
ObjCPropertyDecl *PD = *PI;
@@ -274,7 +273,7 @@
else
toAttr = "unsafe_unretained";
}
- if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
+ if (Attrs & ObjCPropertyAttribute::assign)
MigrateCtx.rewritePropertyAttribute("assign", toAttr, AtLoc);
else
MigrateCtx.addPropertyAttribute(toAttr, AtLoc);
@@ -302,8 +301,8 @@
for (unsigned i = 0, e = AllProps.size(); i != e; ++i) {
ObjCPropertyDecl *PD = AllProps[i];
if (PD->getPropertyAttributesAsWritten() &
- (ObjCPropertyDecl::OBJC_PR_assign |
- ObjCPropertyDecl::OBJC_PR_readonly)) {
+ (ObjCPropertyAttribute::assign |
+ ObjCPropertyAttribute::readonly)) {
SourceLocation AtLoc = PD->getAtLoc();
if (AtLoc.isInvalid())
continue;
Index: clang/include/clang/Sema/DeclSpec.h
===================================================================
--- clang/include/clang/Sema/DeclSpec.h
+++ clang/include/clang/Sema/DeclSpec.h
@@ -23,6 +23,7 @@
#define LLVM_CLANG_SEMA_DECLSPEC_H
#include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclObjCCommon.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/Basic/ExceptionSpecificationType.h"
#include "clang/Basic/Lambda.h"
@@ -837,31 +838,10 @@
DQ_CSNullability = 0x40
};
- /// PropertyAttributeKind - list of property attributes.
- /// Keep this list in sync with LLVM's Dwarf.h ApplePropertyAttributes.
- enum ObjCPropertyAttributeKind {
- DQ_PR_noattr = 0x0,
- DQ_PR_readonly = 0x01,
- DQ_PR_getter = 0x02,
- DQ_PR_assign = 0x04,
- DQ_PR_readwrite = 0x08,
- DQ_PR_retain = 0x10,
- DQ_PR_copy = 0x20,
- DQ_PR_nonatomic = 0x40,
- DQ_PR_setter = 0x80,
- DQ_PR_atomic = 0x100,
- DQ_PR_weak = 0x200,
- DQ_PR_strong = 0x400,
- DQ_PR_unsafe_unretained = 0x800,
- DQ_PR_nullability = 0x1000,
- DQ_PR_null_resettable = 0x2000,
- DQ_PR_class = 0x4000,
- DQ_PR_direct = 0x8000,
- };
-
ObjCDeclSpec()
- : objcDeclQualifier(DQ_None), PropertyAttributes(DQ_PR_noattr),
- Nullability(0), GetterName(nullptr), SetterName(nullptr) { }
+ : objcDeclQualifier(DQ_None),
+ PropertyAttributes(ObjCPropertyAttribute::noattr),
+ Nullability(0), GetterName(nullptr), SetterName(nullptr) {}
ObjCDeclQualifier getObjCDeclQualifier() const {
return (ObjCDeclQualifier)objcDeclQualifier;
@@ -873,31 +853,34 @@
objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier & ~DQVal);
}
- ObjCPropertyAttributeKind getPropertyAttributes() const {
- return ObjCPropertyAttributeKind(PropertyAttributes);
+ ObjCPropertyAttribute::Kind getPropertyAttributes() const {
+ return ObjCPropertyAttribute::Kind(PropertyAttributes);
}
- void setPropertyAttributes(ObjCPropertyAttributeKind PRVal) {
+ void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) {
PropertyAttributes =
- (ObjCPropertyAttributeKind)(PropertyAttributes | PRVal);
+ (ObjCPropertyAttribute::Kind)(PropertyAttributes | PRVal);
}
NullabilityKind getNullability() const {
assert(((getObjCDeclQualifier() & DQ_CSNullability) ||
- (getPropertyAttributes() & DQ_PR_nullability)) &&
+ (getPropertyAttributes() &
+ ObjCPropertyAttribute::nullability)) &&
"Objective-C declspec doesn't have nullability");
return static_cast<NullabilityKind>(Nullability);
}
SourceLocation getNullabilityLoc() const {
assert(((getObjCDeclQualifier() & DQ_CSNullability) ||
- (getPropertyAttributes() & DQ_PR_nullability)) &&
+ (getPropertyAttributes() &
+ ObjCPropertyAttribute::nullability)) &&
"Objective-C declspec doesn't have nullability");
return NullabilityLoc;
}
void setNullability(SourceLocation loc, NullabilityKind kind) {
assert(((getObjCDeclQualifier() & DQ_CSNullability) ||
- (getPropertyAttributes() & DQ_PR_nullability)) &&
+ (getPropertyAttributes() &
+ ObjCPropertyAttribute::nullability)) &&
"Set the nullability declspec or property attribute first");
Nullability = static_cast<unsigned>(kind);
NullabilityLoc = loc;
@@ -925,8 +908,8 @@
// (space saving is negligible).
unsigned objcDeclQualifier : 7;
- // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttributeKind
- unsigned PropertyAttributes : 16;
+ // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttribute::Kind
+ unsigned PropertyAttributes : NumObjCPropertyAttrsBits;
unsigned Nullability : 2;
Index: clang/include/clang/AST/DeclObjCCommon.h
===================================================================
--- /dev/null
+++ clang/include/clang/AST/DeclObjCCommon.h
@@ -0,0 +1,55 @@
+//===- DeclObjCCommon.h - Classes for representing declarations -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains common ObjC enums and classes used in AST and
+// Sema.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_DECLOBJC_COMMON_H
+#define LLVM_CLANG_AST_DECLOBJC_COMMON_H
+
+namespace clang {
+
+/// ObjCPropertyAttribute::Kind - list of property attributes.
+/// Keep this list in sync with LLVM's Dwarf.h ApplePropertyAttributes.s
+namespace ObjCPropertyAttribute {
+enum Kind {
+ noattr = 0x00,
+ readonly = 0x01,
+ getter = 0x02,
+ assign = 0x04,
+ readwrite = 0x08,
+ retain = 0x10,
+ copy = 0x20,
+ nonatomic = 0x40,
+ setter = 0x80,
+ atomic = 0x100,
+ weak = 0x200,
+ strong = 0x400,
+ unsafe_unretained = 0x800,
+ /// Indicates that the nullability of the type was spelled with a
+ /// property attribute rather than a type qualifier.
+ nullability = 0x1000,
+ null_resettable = 0x2000,
+ classattr = 0x4000,
+ direct = 0x8000,
+ // Adding a property should change NumObjCPropertyAttrsBits
+ // Also, don't forget to update the Clang C API at CXObjCPropertyAttrKind and
+ // clang_Cursor_getObjCPropertyAttributes.
+};
+} // namespace ObjCPropertyAttribute::Kind
+
+enum {
+ /// Number of bits fitting all the property attributes.
+ NumObjCPropertyAttrsBits = 16
+};
+
+} // namespace clang
+
+#endif // LLVM_CLANG_AST_DECLOBJC_COMMON_H
Index: clang/include/clang/AST/DeclObjC.h
===================================================================
--- clang/include/clang/AST/DeclObjC.h
+++ clang/include/clang/AST/DeclObjC.h
@@ -15,6 +15,7 @@
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
+#include "clang/AST/DeclObjCCommon.h"
#include "clang/AST/ExternalASTSource.h"
#include "clang/AST/Redeclarable.h"
#include "clang/AST/SelectorLocationsKind.h"
@@ -742,34 +743,6 @@
void anchor() override;
public:
- enum PropertyAttributeKind {
- OBJC_PR_noattr = 0x00,
- OBJC_PR_readonly = 0x01,
- OBJC_PR_getter = 0x02,
- OBJC_PR_assign = 0x04,
- OBJC_PR_readwrite = 0x08,
- OBJC_PR_retain = 0x10,
- OBJC_PR_copy = 0x20,
- OBJC_PR_nonatomic = 0x40,
- OBJC_PR_setter = 0x80,
- OBJC_PR_atomic = 0x100,
- OBJC_PR_weak = 0x200,
- OBJC_PR_strong = 0x400,
- OBJC_PR_unsafe_unretained = 0x800,
- /// Indicates that the nullability of the type was spelled with a
- /// property attribute rather than a type qualifier.
- OBJC_PR_nullability = 0x1000,
- OBJC_PR_null_resettable = 0x2000,
- OBJC_PR_class = 0x4000,
- OBJC_PR_direct = 0x8000
- // Adding a property should change NumPropertyAttrsBits
- };
-
- enum {
- /// Number of bits fitting all the property attributes.
- NumPropertyAttrsBits = 16
- };
-
enum SetterKind { Assign, Retain, Copy, Weak };
enum PropertyControl { None, Required, Optional };
@@ -782,8 +755,8 @@
QualType DeclType;
TypeSourceInfo *DeclTypeSourceInfo;
- unsigned PropertyAttributes : NumPropertyAttrsBits;
- unsigned PropertyAttributesAsWritten : NumPropertyAttrsBits;
+ unsigned PropertyAttributes : NumObjCPropertyAttrsBits;
+ unsigned PropertyAttributesAsWritten : NumObjCPropertyAttrsBits;
// \@required/\@optional
unsigned PropertyImplementation : 2;
@@ -815,8 +788,8 @@
PropertyControl propControl)
: NamedDecl(ObjCProperty, DC, L, Id), AtLoc(AtLocation),
LParenLoc(LParenLocation), DeclType(T), DeclTypeSourceInfo(TSI),
- PropertyAttributes(OBJC_PR_noattr),
- PropertyAttributesAsWritten(OBJC_PR_noattr),
+ PropertyAttributes(ObjCPropertyAttribute::noattr),
+ PropertyAttributesAsWritten(ObjCPropertyAttribute::noattr),
PropertyImplementation(propControl), GetterName(Selector()),
SetterName(Selector()) {}
@@ -850,11 +823,11 @@
/// type.
QualType getUsageType(QualType objectType) const;
- PropertyAttributeKind getPropertyAttributes() const {
- return PropertyAttributeKind(PropertyAttributes);
+ ObjCPropertyAttribute::Kind getPropertyAttributes() const {
+ return ObjCPropertyAttribute::Kind(PropertyAttributes);
}
- void setPropertyAttributes(PropertyAttributeKind PRVal) {
+ void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) {
PropertyAttributes |= PRVal;
}
@@ -862,11 +835,11 @@
PropertyAttributes = PRVal;
}
- PropertyAttributeKind getPropertyAttributesAsWritten() const {
- return PropertyAttributeKind(PropertyAttributesAsWritten);
+ ObjCPropertyAttribute::Kind getPropertyAttributesAsWritten() const {
+ return ObjCPropertyAttribute::Kind(PropertyAttributesAsWritten);
}
- void setPropertyAttributesAsWritten(PropertyAttributeKind PRVal) {
+ void setPropertyAttributesAsWritten(ObjCPropertyAttribute::Kind PRVal) {
PropertyAttributesAsWritten = PRVal;
}
@@ -874,23 +847,24 @@
/// isReadOnly - Return true iff the property has a setter.
bool isReadOnly() const {
- return (PropertyAttributes & OBJC_PR_readonly);
+ return (PropertyAttributes & ObjCPropertyAttribute::readonly);
}
/// isAtomic - Return true if the property is atomic.
bool isAtomic() const {
- return (PropertyAttributes & OBJC_PR_atomic);
+ return (PropertyAttributes & ObjCPropertyAttribute::atomic);
}
/// isRetaining - Return true if the property retains its value.
bool isRetaining() const {
- return (PropertyAttributes &
- (OBJC_PR_retain | OBJC_PR_strong | OBJC_PR_copy));
+ return (PropertyAttributes & (ObjCPropertyAttribute::retain |
+ ObjCPropertyAttribute::strong |
+ ObjCPropertyAttribute::copy));
}
bool isInstanceProperty() const { return !isClassProperty(); }
- bool isClassProperty() const { return PropertyAttributes & OBJC_PR_class; }
- bool isDirectProperty() const { return PropertyAttributes & OBJC_PR_direct; }
+ bool isClassProperty() const { return PropertyAttributes & ObjCPropertyAttribute::classattr; }
+ bool isDirectProperty() const { return PropertyAttributes & ObjCPropertyAttribute::direct; }
ObjCPropertyQueryKind getQueryKind() const {
return isClassProperty() ? ObjCPropertyQueryKind::OBJC_PR_query_class :
@@ -906,13 +880,13 @@
/// the property setter. This is only valid if the property has been
/// defined to have a setter.
SetterKind getSetterKind() const {
- if (PropertyAttributes & OBJC_PR_strong)
+ if (PropertyAttributes & ObjCPropertyAttribute::strong)
return getType()->isBlockPointerType() ? Copy : Retain;
- if (PropertyAttributes & OBJC_PR_retain)
+ if (PropertyAttributes & ObjCPropertyAttribute::retain)
return Retain;
- if (PropertyAttributes & OBJC_PR_copy)
+ if (PropertyAttributes & ObjCPropertyAttribute::copy)
return Copy;
- if (PropertyAttributes & OBJC_PR_weak)
+ if (PropertyAttributes & ObjCPropertyAttribute::weak)
return Weak;
return Assign;
}
Index: clang/include/clang-c/Index.h
===================================================================
--- clang/include/clang-c/Index.h
+++ clang/include/clang-c/Index.h
@@ -4500,7 +4500,7 @@
CXObjCPropertyAttr_weak = 0x200,
CXObjCPropertyAttr_strong = 0x400,
CXObjCPropertyAttr_unsafe_unretained = 0x800,
- CXObjCPropertyAttr_class = 0x1000
+ CXObjCPropertyAttr_classattr = 0x1000
} CXObjCPropertyAttrKind;
/**
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
