maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Sema/SemaObjCProperty.cpp

2694 lines
112 KiB
C++
Raw Normal View History

Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
//===--- SemaObjCProperty.cpp - Semantic Analysis for ObjC @property ------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements semantic analysis for Objective C @property and
// @synthesize declarations.
//
//===----------------------------------------------------------------------===//
Split out a header to hold APIs meant for the Sema implementation from Sema.h. Clients of Sema don't need to know (for example) the list of diagnostics we support. llvm-svn: 112093
2010-08-26 06:03:47 +08:00
#include "clang/Sema/SemaInternal.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/AST/ASTMutationListener.h"
Struggle mightily against header inclusion in Sema.h. llvm-svn: 111904
2010-08-24 15:21:54 +08:00
#include "clang/AST/DeclObjC.h"
objc++: For atomic properties of c++ class objec typet, appropriate operator= is called. Issue a warning for non-trivial case until runtime support is provided. // rdar://6137845 llvm-svn: 141302
2011-10-07 02:38:18 +08:00
#include "clang/AST/ExprCXX.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/AST/ExprObjC.h"
objective-c: When default synthesizing readonly IBOutlet properties provide a 'fixit' to change 'readonly' to 'readwrite'. // rdar://11448209 llvm-svn: 157193
2012-05-22 01:02:43 +08:00
#include "clang/Basic/SourceManager.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Lex/Lexer.h"
Suggest objc_method_family(none) for a property named -newFoo or similar. As mentioned in the previous commit, if a property (declared with @property) has a name that matches a special Objective-C method family, the getter picks up that family despite being declared by the property. The most correct way to solve this problem is to add the 'objc_method_family' attribute to the getter with an argument of 'none', which unfortunately requires an explicit declaration of the getter. This commit adds a note to the existing error (ARC) or warning (MRR) for such a poorly-named property that suggests the solution; if there's already a declaration of the getter, it even includes a fix-it. llvm-svn: 226339
2015-01-17 07:04:31 +08:00
#include "clang/Lex/Preprocessor.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Sema/Initialization.h"
Remove the DenseSet dependency from Sema.h. llvm-svn: 112030
2010-08-25 15:03:20 +08:00
#include "llvm/ADT/DenseSet.h"
Move a method from IdentifierTable.h out of line and remove the SmallString include. Fix all the transitive include users. llvm-svn: 149783
2012-02-04 21:45:25 +08:00
#include "llvm/ADT/SmallString.h"
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
using namespace clang;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
//===----------------------------------------------------------------------===//
// Grammar actions.
//===----------------------------------------------------------------------===//
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
/// getImpliedARCOwnership - Given a set of property attributes and a
/// type, infer an expected lifetime. The type's ownership qualification
/// is not considered.
///
/// 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) {
// 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)) {
Fix a pair of bugs relating to properties in ARC. First, when synthesizing an explicitly strong/retain/copy property of Class type, don't pretend during compatibility checking that the property is actually assign. Instead, resolve incompatibilities by secretly changing the type of *implicitly* __unsafe_unretained Class ivars to be strong. This is moderately evil but better than what we were doing. Second, when synthesizing the setter for a strong property of non-retainable type, be sure to use objc_setProperty. This is possible when the property is decorated with the NSObject attribute. This is an ugly, ugly corner of the language, and we probably ought to deprecate it. The first is rdar://problem/12039404; the second was noticed by inspection while fixing the first. llvm-svn: 162244
2012-08-21 07:36:59 +08:00
return Qualifiers::OCL_Strong;
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
} else if (attrs & ObjCPropertyDecl::OBJC_PR_weak) {
return Qualifiers::OCL_Weak;
} else if (attrs & ObjCPropertyDecl::OBJC_PR_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 &&
type->isObjCRetainableType()) {
return Qualifiers::OCL_ExplicitNone;
}
return Qualifiers::OCL_None;
}
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
/// Check the internal consistency of a property declaration with
/// an explicit ownership qualifier.
static void checkPropertyDeclWithOwnership(Sema &S,
ObjCPropertyDecl *property) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
if (property->isInvalidDecl()) return;
ObjCPropertyDecl::PropertyAttributeKind propertyKind
= property->getPropertyAttributes();
Qualifiers::ObjCLifetime propertyLifetime
= property->getType().getObjCLifetime();
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
assert(propertyLifetime != Qualifiers::OCL_None);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
Qualifiers::ObjCLifetime expectedLifetime
= getImpliedARCOwnership(propertyKind, property->getType());
if (!expectedLifetime) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
// We have a lifetime qualifier but no dominating property
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
// attribute. That's okay, but restore reasonable invariants by
// setting the property attribute according to the lifetime
// qualifier.
ObjCPropertyDecl::PropertyAttributeKind attr;
if (propertyLifetime == Qualifiers::OCL_Strong) {
attr = ObjCPropertyDecl::OBJC_PR_strong;
} else if (propertyLifetime == Qualifiers::OCL_Weak) {
attr = ObjCPropertyDecl::OBJC_PR_weak;
} else {
assert(propertyLifetime == Qualifiers::OCL_ExplicitNone);
attr = ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
}
property->setPropertyAttributes(attr);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
return;
}
if (propertyLifetime == expectedLifetime) return;
property->setInvalidDecl();
S.Diag(property->getLocation(),
Rename objc_lifetime -> objc_ownership, and modify diagnostics to talk about 'ownership', not 'lifetime'. rdar://9477613. llvm-svn: 133779
2011-06-24 08:08:59 +08:00
diag::err_arc_inconsistent_property_ownership)
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
<< property->getDeclName()
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
<< expectedLifetime
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
<< propertyLifetime;
}
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
/// \brief Check this Objective-C property against a property declared in the
/// given protocol.
static void
CheckPropertyAgainstProtocol(Sema &S, ObjCPropertyDecl *Prop,
ObjCProtocolDecl *Proto,
Repace SmallPtrSet with SmallPtrSetImpl in function arguments to avoid needing to mention the size. llvm-svn: 215869
2014-08-18 07:49:53 +08:00
llvm::SmallPtrSetImpl<ObjCProtocolDecl *> &Known) {
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
// Have we seen this protocol before?
Update for LLVM API change to make Small(Ptr)Set::insert return pair<iterator, bool> as per the C++ standard's associative container concept. llvm-svn: 222335
2014-11-19 15:49:47 +08:00
if (!Known.insert(Proto).second)
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
return;
// Look for a property with the same name.
DeclContext::lookup_result R = Proto->lookup(Prop->getDeclName());
for (unsigned I = 0, N = R.size(); I != N; ++I) {
if (ObjCPropertyDecl *ProtoProp = dyn_cast<ObjCPropertyDecl>(R[I])) {
ObjectiveC. Allow readonly properties without an explicit ownership (assign/unsafe_unretained/weak/retain/strong/copy) in super class to be overridden by a property with any explicit ownership in the subclass. // rdar://15014468 llvm-svn: 191971
2013-10-05 02:06:08 +08:00
S.DiagnosePropertyMismatch(Prop, ProtoProp, Proto->getIdentifier(), true);
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
return;
}
}
// Check this property against any protocols we inherit.
[C++11] Replacing ObjCProtocolDecl iterators protocol_begin() and protocol_end() with iterator_range protocols(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203863
2014-03-14 06:58:06 +08:00
for (auto *P : Proto->protocols())
CheckPropertyAgainstProtocol(S, Prop, P, Known);
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
}
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
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;
// 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;
case Qualifiers::OCL_Strong:
return ObjCDeclSpec::DQ_PR_strong;
case Qualifiers::OCL_ExplicitNone:
return ObjCDeclSpec::DQ_PR_unsafe_unretained;
case Qualifiers::OCL_Autoreleasing:
case Qualifiers::OCL_None:
return 0;
}
llvm_unreachable("bad qualifier");
}
return 0;
}
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
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);
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
static unsigned getOwnershipRule(unsigned attr) {
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
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;
}
return result;
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc,
objective-c: provide fixit hint when atomic property does not have matching user defined setter/getter and a warning is issued. In this case, a fixit note is displayed. // rdar://10267155 llvm-svn: 151766
2012-03-01 06:18:55 +08:00
SourceLocation LParenLoc,
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
FieldDeclarator &FD,
ObjCDeclSpec &ODS,
Selector GetterSel,
Selector SetterSel,
For properties declared in a @protocol and redeclared in a class extension, use the class extension as the lexical DeclContext for the @property declaration that gets auto-created for the @interface. Fixes: <rdar://problem/8467189> llvm-svn: 114693
2010-09-24 05:18:05 +08:00
tok::ObjCKeywordKind MethodImplKind,
DeclContext *lexicalDC) {
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
unsigned Attributes = ODS.getPropertyAttributes();
Introduced pragmas for audited nullability regions. Introduce the clang pragmas "assume_nonnull begin" and "assume_nonnull end" in which we make default assumptions about the nullability of many unannotated pointers: - Single-level pointers are inferred to __nonnull - NSError** in a (function or method) parameter list is inferred to NSError * __nullable * __nullable. - CFErrorRef * in a (function or method) parameter list is inferred to CFErrorRef __nullable * __nullable. - Other multi-level pointers are never inferred to anything. Implements rdar://problem/19191042. llvm-svn: 240156
2015-06-20 02:25:57 +08:00
FD.D.setObjCWeakProperty((Attributes & ObjCDeclSpec::DQ_PR_weak) != 0);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
TypeSourceInfo *TSI = GetTypeForDeclarator(FD.D, S);
QualType T = TSI->getType();
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
if (!getOwnershipRule(Attributes)) {
Attributes |= deducePropertyOwnershipFromType(*this, T);
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
bool isReadWrite = ((Attributes & ObjCDeclSpec::DQ_PR_readwrite) ||
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// default is readwrite!
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
!(Attributes & ObjCDeclSpec::DQ_PR_readonly));
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
// Proceed with constructing the ObjCPropertyDecls.
Restore patch I reversed in r138040. Known buildbot failures are resolved. llvm-svn: 138234
2011-08-22 23:54:49 +08:00
ObjCContainerDecl *ClassDecl = cast<ObjCContainerDecl>(CurContext);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
ObjCPropertyDecl *Res = nullptr;
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
if (ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
Check on property attributes which are declared in class extensions (radar 8171968). llvm-svn: 108283
2010-07-14 06:04:56 +08:00
if (CDecl->IsClassExtension()) {
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
Res = HandlePropertyInClassExtension(S, AtLoc, LParenLoc,
[index/AST] Add references for ObjC getter=/setter= property attributes and related property getter/setter role fixes This enhances the AST to keep track of locations of the names in those ObjC property attributes, and reports them for indexing. Patch by Nathan Hawes! https://reviews.llvm.org/D30907 llvm-svn: 297972
2017-03-17 02:25:40 +08:00
FD,
GetterSel, ODS.getGetterNameLoc(),
SetterSel, ODS.getSetterNameLoc(),
isReadWrite, Attributes,
Make sure when setting AttributesAsWritten of a property that they do not include ownership qualifiers from the type. llvm-svn: 143885
2011-11-07 02:58:12 +08:00
ODS.getPropertyAttributes(),
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
T, TSI, MethodImplKind);
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
if (!Res)
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Check on property attributes which are declared in class extensions (radar 8171968). llvm-svn: 108283
2010-07-14 06:04:56 +08:00
}
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
}
if (!Res) {
Res = CreatePropertyDecl(S, ClassDecl, AtLoc, LParenLoc, FD,
[index/AST] Add references for ObjC getter=/setter= property attributes and related property getter/setter role fixes This enhances the AST to keep track of locations of the names in those ObjC property attributes, and reports them for indexing. Patch by Nathan Hawes! https://reviews.llvm.org/D30907 llvm-svn: 297972
2017-03-17 02:25:40 +08:00
GetterSel, ODS.getGetterNameLoc(), SetterSel,
ODS.getSetterNameLoc(), isReadWrite, Attributes,
ODS.getPropertyAttributes(), T, TSI,
MethodImplKind);
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
if (lexicalDC)
Res->setLexicalDeclContext(lexicalDC);
}
For properties declared in a @protocol and redeclared in a class extension, use the class extension as the lexical DeclContext for the @property declaration that gets auto-created for the @interface. Fixes: <rdar://problem/8467189> llvm-svn: 114693
2010-09-24 05:18:05 +08:00
Recognize __attribute__((NSObject)) directly applied on retain properties. (radar 7809468). llvm-svn: 99951
2010-03-31 06:40:11 +08:00
// Validate the attributes on the @property.
Fix inference of _Nullable for weak Objective-C properties. The inference of _Nullable for weak Objective-C properties was broken in several ways: * It was back-patching the type information very late in the process of checking the attributes for an Objective-C property, which is just wrong. * It was using ad hoc checks to try to suppress the warning about missing nullability specifiers (-Wnullability-completeness), which didn't actual work in all cases (rdar://problem/22985457) * It was inferring _Nullable even outside of assumes-nonnull regions, which is wrong. Putting the inference of _Nullable for weak Objective-C properties in the same place as all of the other inference logic fixes all of these ills. llvm-svn: 249896
2015-10-10 04:36:17 +08:00
CheckObjCPropertyAttributes(Res, AtLoc, Attributes,
objective-c: Normally, a property cannot be both 'readonly' and having a "write" attribute (copy/retain/etc.). But, property declaration in primary class and protcols are tentative as they may be overridden into a 'readwrite' property in class extensions. Postpone diagnosing such warnings until the class implementation is seen. // rdar://11656982 llvm-svn: 158869
2012-06-21 06:57:42 +08:00
(isa<ObjCInterfaceDecl>(ClassDecl) ||
isa<ObjCProtocolDecl>(ClassDecl)));
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
// Check consistency if the type has explicit ownership qualification.
if (Res->getType().getObjCLifetime())
checkPropertyDeclWithOwnership(*this, Res);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
llvm::SmallPtrSet<ObjCProtocolDecl *, 16> KnownProtos;
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
// For a class, compare the property against a property in our superclass.
bool FoundInSuper = false;
[Objective-C Sema]. Warn when an indirectly overridden property mismatches the one declared in current class; in addition to those that are directly overridden. // rdar://15967517 llvm-svn: 201446
2014-02-15 08:04:36 +08:00
ObjCInterfaceDecl *CurrentInterfaceDecl = IFace;
while (ObjCInterfaceDecl *Super = CurrentInterfaceDecl->getSuperClass()) {
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
DeclContext::lookup_result R = Super->lookup(Res->getDeclName());
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
for (unsigned I = 0, N = R.size(); I != N; ++I) {
if (ObjCPropertyDecl *SuperProp = dyn_cast<ObjCPropertyDecl>(R[I])) {
ObjectiveC. Allow readonly properties without an explicit ownership (assign/unsafe_unretained/weak/retain/strong/copy) in super class to be overridden by a property with any explicit ownership in the subclass. // rdar://15014468 llvm-svn: 191971
2013-10-05 02:06:08 +08:00
DiagnosePropertyMismatch(Res, SuperProp, Super->getIdentifier(), false);
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
FoundInSuper = true;
break;
}
}
[Objective-C Sema]. Warn when an indirectly overridden property mismatches the one declared in current class; in addition to those that are directly overridden. // rdar://15967517 llvm-svn: 201446
2014-02-15 08:04:36 +08:00
if (FoundInSuper)
break;
else
CurrentInterfaceDecl = Super;
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
}
if (FoundInSuper) {
// Also compare the property against a property in our protocols.
[C++11] Replacing ObjCInterfaceDecl iterators protocol_begin() and protocol_end() with iterator_range protocols(). Updating all of the usages of the iterators with range-based for loops. Drive-by fixing some incorrect types where a for loop would be improperly using ObjCInterfaceDecl::protocol_iterator. No functional changes in these cases. llvm-svn: 203842
2014-03-14 04:29:09 +08:00
for (auto *P : CurrentInterfaceDecl->protocols()) {
CheckPropertyAgainstProtocol(*this, Res, P, KnownProtos);
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
}
} else {
// Slower path: look in all protocols we referenced.
[C++11] Replacing ObjCInterfaceDecl iterators all_referenced_protocol_begin() and all_referenced_protocol_end() with iterator_range all_referenced_protocols(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203848
2014-03-14 04:55:22 +08:00
for (auto *P : IFace->all_referenced_protocols()) {
CheckPropertyAgainstProtocol(*this, Res, P, KnownProtos);
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
}
}
} else if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
// We don't check if class extension. Because properties in class extension
// are meant to override some of the attributes and checking has already done
// when property in class extension is constructed.
if (!Cat->IsClassExtension())
for (auto *P : Cat->protocols())
CheckPropertyAgainstProtocol(*this, Res, P, KnownProtos);
Eliminate Sema::CompareProperties(), which was walking over a pile of lexical declarations looking for properties when we could more efficiently check for property mismatches at property declaration time. Good for ~1% of -fsyntax-only time when most of the properties we're checking against come from an AST file. llvm-svn: 173079
2013-01-22 03:42:21 +08:00
} else {
ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(ClassDecl);
[C++11] Replacing ObjCProtocolDecl iterators protocol_begin() and protocol_end() with iterator_range protocols(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203863
2014-03-14 06:58:06 +08:00
for (auto *P : Proto->protocols())
CheckPropertyAgainstProtocol(*this, Res, P, KnownProtos);
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
}
Attaching comments to declarations during parsing: handle more Objective-C declarations. llvm-svn: 160156
2012-07-13 09:06:46 +08:00
ActOnDocumentableDecl(Res);
Recognize __attribute__((NSObject)) directly applied on retain properties. (radar 7809468). llvm-svn: 99951
2010-03-31 06:40:11 +08:00
return Res;
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
}
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
static ObjCPropertyDecl::PropertyAttributeKind
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
makePropertyAttributesAsWritten(unsigned Attributes) {
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
unsigned attributesAsWritten = 0;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readonly;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_readwrite)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readwrite;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_getter)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_getter;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_setter)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_setter;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_assign)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_assign;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_retain)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_retain;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_strong)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_strong;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_weak)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_weak;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_copy)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_copy;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_nonatomic;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_atomic)
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_atomic;
Class Property: parse property attribute (class). This is the third patch in a series of patches to support class properties in addition to instance properties in objective-c. rdar://23891898 llvm-svn: 258834
2016-01-27 02:52:43 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_class)
attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_class;
Set the objc "property attributes as written" for extension properties as well. llvm-svn: 142406
2011-10-19 03:49:16 +08:00
return (ObjCPropertyDecl::PropertyAttributeKind)attributesAsWritten;
}
Remove unused argument in my last patch. llvm-svn: 157194
2012-05-22 01:10:28 +08:00
static bool LocPropertyAttribute( ASTContext &Context, const char *attrName,
objective-c: When default synthesizing readonly IBOutlet properties provide a 'fixit' to change 'readonly' to 'readwrite'. // rdar://11448209 llvm-svn: 157193
2012-05-22 01:02:43 +08:00
SourceLocation LParenLoc, SourceLocation &Loc) {
if (LParenLoc.isMacroID())
return false;
SourceManager &SM = Context.getSourceManager();
std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(LParenLoc);
// Try to load the file buffer.
bool invalidTemp = false;
StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
if (invalidTemp)
return false;
const char *tokenBegin = file.data() + locInfo.second;
// Lex from the start of the given location.
Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
Context.getLangOpts(),
file.begin(), tokenBegin, file.end());
Token Tok;
do {
lexer.LexFromRawLexer(Tok);
Provide and use a safe Token::getRawIdentifier() accessor llvm-svn: 209061
2014-05-17 12:53:25 +08:00
if (Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == attrName) {
objective-c: When default synthesizing readonly IBOutlet properties provide a 'fixit' to change 'readonly' to 'readwrite'. // rdar://11448209 llvm-svn: 157193
2012-05-22 01:02:43 +08:00
Loc = Tok.getLocation();
return true;
}
} while (Tok.isNot(tok::r_paren));
return false;
objective-c: Warn if default synthesizing readonly IBOutlet properties and provide a 'fixit' to change 'readonly' to 'readwrite'. 'fixit' part needs little more work. // rdar://11448209 llvm-svn: 157121
2012-05-20 02:17:17 +08:00
}
Objective-C properties: loosen 'atomic' checking for readonly properties. r251874 reworked the way we handle properties declared within Objective-C class extensions, which had the effective of tightening up property checking in a number of places. In this particular class of cases, we end up complaining about "atomic" mismatches between an implicitly-atomic, readonly property and a nonatomic, readwrite property, which doesn't make sense because "atomic" is essentially irrelevant to readonly properties. Therefore, suppress this diagnostic when the readonly property is implicitly atomic. Fixes rdar://problem/23803109. llvm-svn: 255174
2015-12-10 06:57:32 +08:00
/// Check for a mismatch in the atomicity of the given properties.
static void checkAtomicPropertyMismatch(Sema &S,
ObjCPropertyDecl *OldProperty,
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
ObjCPropertyDecl *NewProperty,
bool PropagateAtomicity) {
Objective-C properties: loosen 'atomic' checking for readonly properties. r251874 reworked the way we handle properties declared within Objective-C class extensions, which had the effective of tightening up property checking in a number of places. In this particular class of cases, we end up complaining about "atomic" mismatches between an implicitly-atomic, readonly property and a nonatomic, readwrite property, which doesn't make sense because "atomic" is essentially irrelevant to readonly properties. Therefore, suppress this diagnostic when the readonly property is implicitly atomic. Fixes rdar://problem/23803109. llvm-svn: 255174
2015-12-10 06:57:32 +08:00
// If the atomicity of both matches, we're done.
bool OldIsAtomic =
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
(OldProperty->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
== 0;
Objective-C properties: loosen 'atomic' checking for readonly properties. r251874 reworked the way we handle properties declared within Objective-C class extensions, which had the effective of tightening up property checking in a number of places. In this particular class of cases, we end up complaining about "atomic" mismatches between an implicitly-atomic, readonly property and a nonatomic, readwrite property, which doesn't make sense because "atomic" is essentially irrelevant to readonly properties. Therefore, suppress this diagnostic when the readonly property is implicitly atomic. Fixes rdar://problem/23803109. llvm-svn: 255174
2015-12-10 06:57:32 +08:00
bool NewIsAtomic =
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
(NewProperty->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
== 0;
Objective-C properties: loosen 'atomic' checking for readonly properties. r251874 reworked the way we handle properties declared within Objective-C class extensions, which had the effective of tightening up property checking in a number of places. In this particular class of cases, we end up complaining about "atomic" mismatches between an implicitly-atomic, readonly property and a nonatomic, readwrite property, which doesn't make sense because "atomic" is essentially irrelevant to readonly properties. Therefore, suppress this diagnostic when the readonly property is implicitly atomic. Fixes rdar://problem/23803109. llvm-svn: 255174
2015-12-10 06:57:32 +08:00
if (OldIsAtomic == NewIsAtomic) return;
// Determine whether the given property is readonly and implicitly
// atomic.
auto isImplicitlyReadonlyAtomic = [](ObjCPropertyDecl *Property) -> bool {
// Is it readonly?
auto Attrs = Property->getPropertyAttributes();
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
if ((Attrs & ObjCPropertyDecl::OBJC_PR_readonly) == 0) return false;
Objective-C properties: loosen 'atomic' checking for readonly properties. r251874 reworked the way we handle properties declared within Objective-C class extensions, which had the effective of tightening up property checking in a number of places. In this particular class of cases, we end up complaining about "atomic" mismatches between an implicitly-atomic, readonly property and a nonatomic, readwrite property, which doesn't make sense because "atomic" is essentially irrelevant to readonly properties. Therefore, suppress this diagnostic when the readonly property is implicitly atomic. Fixes rdar://problem/23803109. llvm-svn: 255174
2015-12-10 06:57:32 +08:00
// Is it nonatomic?
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic) return false;
Objective-C properties: loosen 'atomic' checking for readonly properties. r251874 reworked the way we handle properties declared within Objective-C class extensions, which had the effective of tightening up property checking in a number of places. In this particular class of cases, we end up complaining about "atomic" mismatches between an implicitly-atomic, readonly property and a nonatomic, readwrite property, which doesn't make sense because "atomic" is essentially irrelevant to readonly properties. Therefore, suppress this diagnostic when the readonly property is implicitly atomic. Fixes rdar://problem/23803109. llvm-svn: 255174
2015-12-10 06:57:32 +08:00
// Was 'atomic' specified directly?
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
if (Property->getPropertyAttributesAsWritten() &
ObjCPropertyDecl::OBJC_PR_atomic)
Objective-C properties: loosen 'atomic' checking for readonly properties. r251874 reworked the way we handle properties declared within Objective-C class extensions, which had the effective of tightening up property checking in a number of places. In this particular class of cases, we end up complaining about "atomic" mismatches between an implicitly-atomic, readonly property and a nonatomic, readwrite property, which doesn't make sense because "atomic" is essentially irrelevant to readonly properties. Therefore, suppress this diagnostic when the readonly property is implicitly atomic. Fixes rdar://problem/23803109. llvm-svn: 255174
2015-12-10 06:57:32 +08:00
return false;
return true;
};
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
// 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);
if (PropagateAtomicity &&
((NewProperty->getPropertyAttributesAsWritten() & AtomicityMask) == 0)) {
unsigned Attrs = NewProperty->getPropertyAttributes();
Attrs = Attrs & ~AtomicityMask;
if (OldIsAtomic)
Attrs |= ObjCPropertyDecl::OBJC_PR_atomic;
else
Attrs |= ObjCPropertyDecl::OBJC_PR_nonatomic;
NewProperty->overwritePropertyAttributes(Attrs);
return;
}
Objective-C properties: loosen 'atomic' checking for readonly properties. r251874 reworked the way we handle properties declared within Objective-C class extensions, which had the effective of tightening up property checking in a number of places. In this particular class of cases, we end up complaining about "atomic" mismatches between an implicitly-atomic, readonly property and a nonatomic, readwrite property, which doesn't make sense because "atomic" is essentially irrelevant to readonly properties. Therefore, suppress this diagnostic when the readonly property is implicitly atomic. Fixes rdar://problem/23803109. llvm-svn: 255174
2015-12-10 06:57:32 +08:00
// One of the properties is atomic; if it's a readonly property, and
// 'atomic' wasn't explicitly specified, we're okay.
if ((OldIsAtomic && isImplicitlyReadonlyAtomic(OldProperty)) ||
(NewIsAtomic && isImplicitlyReadonlyAtomic(NewProperty)))
return;
// Diagnose the conflict.
const IdentifierInfo *OldContextName;
auto *OldDC = OldProperty->getDeclContext();
if (auto Category = dyn_cast<ObjCCategoryDecl>(OldDC))
OldContextName = Category->getClassInterface()->getIdentifier();
else
OldContextName = cast<ObjCContainerDecl>(OldDC)->getIdentifier();
S.Diag(NewProperty->getLocation(), diag::warn_property_attribute)
<< NewProperty->getDeclName() << "atomic"
<< OldContextName;
S.Diag(OldProperty->getLocation(), diag::note_property_declare);
}
Eliminate the oddly-named Sema::ComparePropertiesInBaseAndSuper, which did a redundant traversal of the lexical declarations in the superclass. Instead, when we declare a new property, look into the superclass to see whether we're redeclaring the property. Goot for 1% of -fsyntax-only time on Cocoa.h and a little less than 3% on my modules test case. llvm-svn: 173073
2013-01-22 03:05:22 +08:00
ObjCPropertyDecl *
Restore patch I reversed in r138040. Known buildbot failures are resolved. llvm-svn: 138234
2011-08-22 23:54:49 +08:00
Sema::HandlePropertyInClassExtension(Scope *S,
objective-c: provide fixit hint when atomic property does not have matching user defined setter/getter and a warning is issued. In this case, a fixit note is displayed. // rdar://10267155 llvm-svn: 151766
2012-03-01 06:18:55 +08:00
SourceLocation AtLoc,
SourceLocation LParenLoc,
FieldDeclarator &FD,
[index/AST] Add references for ObjC getter=/setter= property attributes and related property getter/setter role fixes This enhances the AST to keep track of locations of the names in those ObjC property attributes, and reports them for indexing. Patch by Nathan Hawes! https://reviews.llvm.org/D30907 llvm-svn: 297972
2017-03-17 02:25:40 +08:00
Selector GetterSel,
SourceLocation GetterNameLoc,
Selector SetterSel,
SourceLocation SetterNameLoc,
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
const bool isReadWrite,
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
unsigned &Attributes,
Make sure when setting AttributesAsWritten of a property that they do not include ownership qualifiers from the type. llvm-svn: 143885
2011-11-07 02:58:12 +08:00
const unsigned AttributesAsWritten,
Extend type nullability qualifiers for Objective-C. Introduce context-sensitive, non-underscored nullability specifiers (nonnull, nullable, null_unspecified) for Objective-C method return types, method parameter types, and properties. Introduce Objective-C-specific semantics, including computation of the nullability of the result of a message send, merging of nullability information from the @interface of a class into its @implementation, etc . This is the Objective-C part of rdar://problem/18868820. llvm-svn: 240154
2015-06-20 02:14:38 +08:00
QualType T,
TypeSourceInfo *TSI,
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
tok::ObjCKeywordKind MethodImplKind) {
objc - minor comment fix up and cleanup. llvm-svn: 138253
2011-08-23 02:34:22 +08:00
ObjCCategoryDecl *CDecl = cast<ObjCCategoryDecl>(CurContext);
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
// Diagnose if this property is already in continuation class.
Restore patch I reversed in r138040. Known buildbot failures are resolved. llvm-svn: 138234
2011-08-22 23:54:49 +08:00
DeclContext *DC = CurContext;
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
IdentifierInfo *PropertyId = FD.D.getIdentifier();
Check for duplicate declaration of a property in current and other class extensions. // rdar://7629420 llvm-svn: 118689
2010-11-11 02:01:36 +08:00
ObjCInterfaceDecl *CCPrimary = CDecl->getClassInterface();
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
// We need to look in the @interface to see if the @property was
// already declared.
if (!CCPrimary) {
Diag(CDecl->getLocation(), diag::err_continuation_class);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
}
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
bool isClassProperty = (AttributesAsWritten & ObjCDeclSpec::DQ_PR_class) ||
(Attributes & ObjCDeclSpec::DQ_PR_class);
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
// Find the property in the extended class's primary class or
// extensions.
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
ObjCPropertyDecl *PIDecl = CCPrimary->FindPropertyVisibleInPrimaryClass(
PropertyId, ObjCPropertyDecl::getQueryKind(isClassProperty));
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
// If we found a property in an extension, complain.
if (PIDecl && isa<ObjCCategoryDecl>(PIDecl->getDeclContext())) {
Diag(AtLoc, diag::err_duplicate_property);
Diag(PIDecl->getLocation(), diag::note_property_declare);
return nullptr;
}
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
// Check for consistency with the previous declaration, if there is one.
if (PIDecl) {
// A readonly property declared in the primary class can be refined
// by adding a readwrite property within an extension.
// Anything else is an error.
if (!(PIDecl->isReadOnly() && isReadWrite)) {
// Tailor the diagnostics for the common case where a readwrite
// property is declared both in the @interface and the continuation.
// 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;
Diag(AtLoc, diag)
<< CCPrimary->getDeclName();
Diag(PIDecl->getLocation(), diag::note_property_declare);
return nullptr;
}
// 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);
}
// Always adopt the getter from the original declaration.
GetterSel = PIDecl->getGetterName();
Attributes |= ObjCDeclSpec::DQ_PR_getter;
}
// Check consistency of ownership.
unsigned ExistingOwnership
= getOwnershipRule(PIDecl->getPropertyAttributes());
unsigned NewOwnership = getOwnershipRule(Attributes);
if (ExistingOwnership && NewOwnership != ExistingOwnership) {
// If the ownership was written explicitly, complain.
if (getOwnershipRule(AttributesAsWritten)) {
Diag(AtLoc, diag::warn_property_attr_mismatch);
Diag(PIDecl->getLocation(), diag::note_property_declare);
}
// Take the ownership from the original property.
Attributes = (Attributes & ~OwnershipMask) | ExistingOwnership;
}
// If the redeclaration is 'weak' but the original property is not,
if ((Attributes & ObjCPropertyDecl::OBJC_PR_weak) &&
!(PIDecl->getPropertyAttributesAsWritten()
& ObjCPropertyDecl::OBJC_PR_weak) &&
PIDecl->getType()->getAs<ObjCObjectPointerType>() &&
PIDecl->getType().getObjCLifetime() == Qualifiers::OCL_None) {
Diag(AtLoc, diag::warn_property_implicitly_mismatched);
Diag(PIDecl->getLocation(), diag::note_property_declare);
}
}
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
// Create a new ObjCPropertyDecl with the DeclContext being
// the class extension.
ObjCPropertyDecl *PDecl = CreatePropertyDecl(S, CDecl, AtLoc, LParenLoc,
[index/AST] Add references for ObjC getter=/setter= property attributes and related property getter/setter role fixes This enhances the AST to keep track of locations of the names in those ObjC property attributes, and reports them for indexing. Patch by Nathan Hawes! https://reviews.llvm.org/D30907 llvm-svn: 297972
2017-03-17 02:25:40 +08:00
FD, GetterSel, GetterNameLoc,
SetterSel, SetterNameLoc,
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
isReadWrite,
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
Attributes, AttributesAsWritten,
T, TSI, MethodImplKind, DC);
// If there was no declaration of a property with the same name in
// the primary class, we're done.
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
if (!PIDecl) {
Simplify Sema::ProcessPropertyDecl. NFC Now that the properties created within Objective-C class extensions go into the extension themselves, we don't need any of the extra complexity here. llvm-svn: 251949
2015-11-04 01:02:34 +08:00
ProcessPropertyDecl(PDecl);
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
return PDecl;
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
}
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
objective-c: When redeclaraing in continuation class a 'readonly' property to 'readwrite', also allow redeclaration of property type to a narrowring object type. // rdar://10790488 llvm-svn: 149614
2012-02-03 02:54:58 +08:00
if (!Context.hasSameType(PIDecl->getType(), PDecl->getType())) {
bool IncompatibleObjC = false;
QualType ConvertedType;
objc: comment the code which allows narroing of property object type in continuation class. llvm-svn: 149625
2012-02-03 03:34:05 +08:00
// Relax the strict type matching for property type in continuation class.
// Allow property object type of continuation class to be different as long
Further enhance comment for property in continuation class. llvm-svn: 149639
2012-02-03 06:37:48 +08:00
// as it narrows the object type in its primary class property. Note that
// this conversion is safe only because the wider type is for a 'readonly'
// property in primary class and 'narrowed' type for a 'readwrite' property
// in continuation class.
[Objective-C Sema] Use canonical type of properties when comparing redeclaration of property in class extension and to avoid bogus error. rdar://20469452 llvm-svn: 234440
2015-04-09 05:34:04 +08:00
QualType PrimaryClassPropertyT = Context.getCanonicalType(PIDecl->getType());
QualType ClassExtPropertyT = Context.getCanonicalType(PDecl->getType());
if (!isa<ObjCObjectPointerType>(PrimaryClassPropertyT) ||
!isa<ObjCObjectPointerType>(ClassExtPropertyT) ||
(!isObjCPointerConversion(ClassExtPropertyT, PrimaryClassPropertyT,
objective-c: When redeclaraing in continuation class a 'readonly' property to 'readwrite', also allow redeclaration of property type to a narrowring object type. // rdar://10790488 llvm-svn: 149614
2012-02-03 02:54:58 +08:00
ConvertedType, IncompatibleObjC))
|| IncompatibleObjC) {
Diag(AtLoc,
diag::err_type_mismatch_continuation_class) << PDecl->getType();
Diag(PIDecl->getLocation(), diag::note_property_declare);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
objective-c: When redeclaraing in continuation class a 'readonly' property to 'readwrite', also allow redeclaration of property type to a narrowring object type. // rdar://10790488 llvm-svn: 149614
2012-02-03 02:54:58 +08:00
}
objc - redeclaration of property in extension class must match property type declaration in its primary class. // rdar://10142679 llvm-svn: 140438
2011-09-24 08:56:59 +08:00
}
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
// Check that atomicity of property in class extension matches the previous
// declaration.
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
checkAtomicPropertyMismatch(*this, PIDecl, PDecl, true);
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
Simplify Sema::ProcessPropertyDecl. NFC Now that the properties created within Objective-C class extensions go into the extension themselves, we don't need any of the extra complexity here. llvm-svn: 251949
2015-11-04 01:02:34 +08:00
// Make sure getter/setter are appropriately synthesized.
ProcessPropertyDecl(PDecl);
objective-C: peroform property attribute consistency checking on property declared in class extension. // rdar://12214070 llvm-svn: 164053
2012-09-18 04:57:19 +08:00
return PDecl;
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
}
ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S,
ObjCContainerDecl *CDecl,
SourceLocation AtLoc,
objective-c: provide fixit hint when atomic property does not have matching user defined setter/getter and a warning is issued. In this case, a fixit note is displayed. // rdar://10267155 llvm-svn: 151766
2012-03-01 06:18:55 +08:00
SourceLocation LParenLoc,
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
FieldDeclarator &FD,
Selector GetterSel,
[index/AST] Add references for ObjC getter=/setter= property attributes and related property getter/setter role fixes This enhances the AST to keep track of locations of the names in those ObjC property attributes, and reports them for indexing. Patch by Nathan Hawes! https://reviews.llvm.org/D30907 llvm-svn: 297972
2017-03-17 02:25:40 +08:00
SourceLocation GetterNameLoc,
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
Selector SetterSel,
[index/AST] Add references for ObjC getter=/setter= property attributes and related property getter/setter role fixes This enhances the AST to keep track of locations of the names in those ObjC property attributes, and reports them for indexing. Patch by Nathan Hawes! https://reviews.llvm.org/D30907 llvm-svn: 297972
2017-03-17 02:25:40 +08:00
SourceLocation SetterNameLoc,
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
const bool isReadWrite,
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
const unsigned Attributes,
Make sure when setting AttributesAsWritten of a property that they do not include ownership qualifiers from the type. llvm-svn: 143885
2011-11-07 02:58:12 +08:00
const unsigned AttributesAsWritten,
Extend type nullability qualifiers for Objective-C. Introduce context-sensitive, non-underscored nullability specifiers (nonnull, nullable, null_unspecified) for Objective-C method return types, method parameter types, and properties. Introduce Objective-C-specific semantics, including computation of the nullability of the result of a message send, merging of nullability information from the @interface of a class into its @implementation, etc . This is the Objective-C part of rdar://problem/18868820. llvm-svn: 240154
2015-06-20 02:14:38 +08:00
QualType T,
Remember type source information for Objective C property declarations. llvm-svn: 105484
2010-06-05 04:50:08 +08:00
TypeSourceInfo *TInfo,
Teach CursorVisitor about duplicate ObjCPropertyDecls that can arise because of a current design limitation in how we handle Objective-C class extensions. This was causing the CursorVisitor to essentially visit an @property twice (once in the @interface, the other in the class extension). Fixes <rdar://problem/7410145>. llvm-svn: 104055
2010-05-19 05:09:07 +08:00
tok::ObjCKeywordKind MethodImplKind,
DeclContext *lexicalDC){
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
IdentifierInfo *PropertyId = FD.D.getIdentifier();
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
// 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)) {
isAssign = true;
} else if (getOwnershipRule(Attributes) || !isReadWrite) {
isAssign = false;
} else {
isAssign = (!getLangOpts().ObjCAutoRefCount ||
!T->isObjCRetainableType());
}
// Issue a warning if property is 'assign' as default and its
// object, which is gc'able conforms to NSCopying protocol
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().getGC() != LangOptions::NonGC &&
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
isAssign && !(Attributes & ObjCDeclSpec::DQ_PR_assign)) {
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
if (const ObjCObjectPointerType *ObjPtrTy =
T->getAs<ObjCObjectPointerType>()) {
ObjCInterfaceDecl *IDecl = ObjPtrTy->getObjectType()->getInterface();
if (IDecl)
if (ObjCProtocolDecl* PNSCopying =
LookupProtocol(&Context.Idents.get("NSCopying"), AtLoc))
if (IDecl->ClassImplementsProtocol(PNSCopying, true))
Diag(AtLoc, diag::warn_implements_nscopying) << PropertyId;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
}
Fix recovery for missing * in objc property. <rdar://problem/14354144> llvm-svn: 185897
2013-07-09 09:38:07 +08:00
if (T->isObjCObjectType()) {
SourceLocation StarLoc = TInfo->getTypeLoc().getLocEnd();
Fix a bunch of mislayered clang/Lex includes from Sema llvm-svn: 207896
2014-05-03 11:45:55 +08:00
StarLoc = getLocForEndOfToken(StarLoc);
Fix recovery for missing * in objc property. <rdar://problem/14354144> llvm-svn: 185897
2013-07-09 09:38:07 +08:00
Diag(FD.D.getIdentifierLoc(), diag::err_statically_allocated_object)
<< FixItHint::CreateInsertion(StarLoc, "*");
T = Context.getObjCObjectPointerType(T);
SourceLocation TLoc = TInfo->getTypeLoc().getLocStart();
TInfo = Context.getTrivialTypeSourceInfo(T, TLoc);
}
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
DeclContext *DC = cast<DeclContext>(CDecl);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
ObjCPropertyDecl *PDecl = ObjCPropertyDecl::Create(Context, DC,
FD.D.getIdentifierLoc(),
Extend type nullability qualifiers for Objective-C. Introduce context-sensitive, non-underscored nullability specifiers (nonnull, nullable, null_unspecified) for Objective-C method return types, method parameter types, and properties. Introduce Objective-C-specific semantics, including computation of the nullability of the result of a message send, merging of nullability information from the @interface of a class into its @implementation, etc . This is the Objective-C part of rdar://problem/18868820. llvm-svn: 240154
2015-06-20 02:14:38 +08:00
PropertyId, AtLoc,
LParenLoc, T, TInfo);
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
bool isClassProperty = (AttributesAsWritten & ObjCDeclSpec::DQ_PR_class) ||
(Attributes & ObjCDeclSpec::DQ_PR_class);
// Class property and instance property can have the same name.
if (ObjCPropertyDecl *prevDecl = ObjCPropertyDecl::findPropertyDecl(
DC, PropertyId, ObjCPropertyDecl::getQueryKind(isClassProperty))) {
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Diag(PDecl->getLocation(), diag::err_duplicate_property);
Correctly determine if the @property has been previously declared. If a property has the same name as the ivar it wraps then the old logic wouldn't find the previous property declaration. llvm-svn: 98559
2010-03-16 02:47:25 +08:00
Diag(prevDecl->getLocation(), diag::note_property_declare);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
PDecl->setInvalidDecl();
}
Teach CursorVisitor about duplicate ObjCPropertyDecls that can arise because of a current design limitation in how we handle Objective-C class extensions. This was causing the CursorVisitor to essentially visit an @property twice (once in the @interface, the other in the class extension). Fixes <rdar://problem/7410145>. llvm-svn: 104055
2010-05-19 05:09:07 +08:00
else {
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
DC->addDecl(PDecl);
Teach CursorVisitor about duplicate ObjCPropertyDecls that can arise because of a current design limitation in how we handle Objective-C class extensions. This was causing the CursorVisitor to essentially visit an @property twice (once in the @interface, the other in the class extension). Fixes <rdar://problem/7410145>. llvm-svn: 104055
2010-05-19 05:09:07 +08:00
if (lexicalDC)
PDecl->setLexicalDeclContext(lexicalDC);
}
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
if (T->isArrayType() || T->isFunctionType()) {
Diag(AtLoc, diag::err_property_type) << T;
PDecl->setInvalidDecl();
}
ProcessDeclAttributes(S, PDecl, FD.D);
// Regardless of setter/getter attribute, we save the default getter/setter
// selector names in anticipation of declaration of setter/getter methods.
[index/AST] Add references for ObjC getter=/setter= property attributes and related property getter/setter role fixes This enhances the AST to keep track of locations of the names in those ObjC property attributes, and reports them for indexing. Patch by Nathan Hawes! https://reviews.llvm.org/D30907 llvm-svn: 297972
2017-03-17 02:25:40 +08:00
PDecl->setGetterName(GetterSel, GetterNameLoc);
PDecl->setSetterName(SetterSel, SetterNameLoc);
[ARC] Complain about property without storage attribute when @synthesizing it, not at its declaration. For this sample: @interface Foo @property id x; @end we get: t.m:2:1: error: ARC forbids properties of Objective-C objects with unspecified storage attribute @property id x; ^ 1 error generated. The error should be imposed on the implementor of the interface, not the user. If the user uses a header of a non-ARC library whose source code he does not have, we are basically asking him to go change the header of the library (bad in general), possible overriding how the property is implemented if he gets confused and says "Oh I'll just add 'copy' then" (even worse). Second issue is that we don't emit any error for 'readonly' properties, e.g: @interface Foo @property (readonly) id x; // no error here @end @implementation Foo @synthesize x; // no error here too @end We should give an error when the implementor is @synthesizing a property which doesn't have any storage specifier; this is when the explicit specifier is important, because we are going to create an ivar and we want its ownership to be explicit. Related improvements: -OBJC_PR_unsafe_unretained turned out to not fit in ObjCPropertyDecl's bitfields, fix it. -For properties of extension classes don't drop PropertyAttributesAsWritten values. -Have PropertyAttributesAsWritten actually only reflect what the user wrote rdar://9756610. llvm-svn: 134960
2011-07-12 12:30:16 +08:00
PDecl->setPropertyAttributesAsWritten(
Make sure when setting AttributesAsWritten of a property that they do not include ownership qualifiers from the type. llvm-svn: 143885
2011-11-07 02:58:12 +08:00
makePropertyAttributesAsWritten(AttributesAsWritten));
[ARC] Complain about property without storage attribute when @synthesizing it, not at its declaration. For this sample: @interface Foo @property id x; @end we get: t.m:2:1: error: ARC forbids properties of Objective-C objects with unspecified storage attribute @property id x; ^ 1 error generated. The error should be imposed on the implementor of the interface, not the user. If the user uses a header of a non-ARC library whose source code he does not have, we are basically asking him to go change the header of the library (bad in general), possible overriding how the property is implemented if he gets confused and says "Oh I'll just add 'copy' then" (even worse). Second issue is that we don't emit any error for 'readonly' properties, e.g: @interface Foo @property (readonly) id x; // no error here @end @implementation Foo @synthesize x; // no error here too @end We should give an error when the implementor is @synthesizing a property which doesn't have any storage specifier; this is when the explicit specifier is important, because we are going to create an ivar and we want its ownership to be explicit. Related improvements: -OBJC_PR_unsafe_unretained turned out to not fit in ObjCPropertyDecl's bitfields, fix it. -For properties of extension classes don't drop PropertyAttributesAsWritten values. -Have PropertyAttributesAsWritten actually only reflect what the user wrote rdar://9756610. llvm-svn: 134960
2011-07-12 12:30:16 +08:00
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_getter)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter);
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_setter)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter);
if (isReadWrite)
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_retain)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_strong)
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_weak)
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_weak);
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_copy)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
if (isAssign)
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
// In the semantic attributes, one of nonatomic or atomic is always set.
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic);
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
else
Restore 'atomic' as an attribute of objc properties. llvm-svn: 132866
2011-06-11 08:45:12 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_atomic);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
// 'unsafe_unretained' is alias for 'assign'.
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
if (isAssign)
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
if (MethodImplKind == tok::objc_required)
PDecl->setPropertyImplementation(ObjCPropertyDecl::Required);
else if (MethodImplKind == tok::objc_optional)
PDecl->setPropertyImplementation(ObjCPropertyDecl::Optional);
Extend type nullability qualifiers for Objective-C. Introduce context-sensitive, non-underscored nullability specifiers (nonnull, nullable, null_unspecified) for Objective-C method return types, method parameter types, and properties. Introduce Objective-C-specific semantics, including computation of the nullability of the result of a message send, merging of nullability information from the @interface of a class into its @implementation, etc . This is the Objective-C part of rdar://problem/18868820. llvm-svn: 240154
2015-06-20 02:14:38 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_nullability)
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nullability);
Implement the 'null_resettable' attribute for Objective-C properties. 'null_resettable' properties are those whose getters return nonnull but whose setters take nil, to "reset" the property to some default. Implements rdar://problem/19051334. llvm-svn: 240155
2015-06-20 02:14:46 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_null_resettable)
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_null_resettable);
Class Property: parse property attribute (class). This is the third patch in a series of patches to support class properties in addition to instance properties in objective-c. rdar://23891898 llvm-svn: 258834
2016-01-27 02:52:43 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_class)
PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_class);
Split Sema::ActOnProperty() into two recursive functions to clearly separate the handling of class extensions from other cases. llvm-svn: 98326
2010-03-12 10:31:10 +08:00
return PDecl;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc,
ObjCPropertyDecl *property,
ObjCIvarDecl *ivar) {
if (property->isInvalidDecl() || ivar->isInvalidDecl()) return;
QualType ivarType = ivar->getType();
Qualifiers::ObjCLifetime ivarLifetime = ivarType.getObjCLifetime();
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
// The lifetime implied by the property's attributes.
Qualifiers::ObjCLifetime propertyLifetime =
getImpliedARCOwnership(property->getPropertyAttributes(),
property->getType());
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
// We're fine if they match.
if (propertyLifetime == ivarLifetime) return;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Define weak and __weak to mean ARC-style weak references, even in MRC. Previously, __weak was silently accepted and ignored in MRC mode. That makes this a potentially source-breaking change that we have to roll out cautiously. Accordingly, for the time being, actual support for __weak references in MRC is experimental, and the compiler will reject attempts to actually form such references. The intent is to eventually enable the feature by default in all non-GC modes. (It is, of course, incompatible with ObjC GC's interpretation of __weak.) If you like, you can enable this feature with -Xclang -fobjc-weak but like any -Xclang option, this option may be removed at any point, e.g. if/when it is eventually enabled by default. This patch also enables the use of the ARC __unsafe_unretained qualifier in MRC. Unlike __weak, this is being enabled immediately. Since variables are essentially __unsafe_unretained by default in MRC, the only practical uses are (1) communication and (2) changing the default behavior of by-value block capture. As an implementation matter, this means that the ObjC ownership qualifiers may appear in any ObjC language mode, and so this patch removes a number of checks for getLangOpts().ObjCAutoRefCount that were guarding the processing of these qualifiers. I don't expect this to be a significant drain on performance; it may even be faster to just check for these qualifiers directly on a type (since it's probably in a register anyway) than to do N dependent loads to grab the LangOptions. rdar://9674298 llvm-svn: 251041
2015-10-23 02:38:17 +08:00
// None isn't a valid lifetime for an object ivar in ARC, and
// __autoreleasing is never valid; don't diagnose twice.
if ((ivarLifetime == Qualifiers::OCL_None &&
S.getLangOpts().ObjCAutoRefCount) ||
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
ivarLifetime == Qualifiers::OCL_Autoreleasing)
return;
Fix a pair of bugs relating to properties in ARC. First, when synthesizing an explicitly strong/retain/copy property of Class type, don't pretend during compatibility checking that the property is actually assign. Instead, resolve incompatibilities by secretly changing the type of *implicitly* __unsafe_unretained Class ivars to be strong. This is moderately evil but better than what we were doing. Second, when synthesizing the setter for a strong property of non-retainable type, be sure to use objc_setProperty. This is possible when the property is decorated with the NSObject attribute. This is an ugly, ugly corner of the language, and we probably ought to deprecate it. The first is rdar://problem/12039404; the second was noticed by inspection while fixing the first. llvm-svn: 162244
2012-08-21 07:36:59 +08:00
// If the ivar is private, and it's implicitly __unsafe_unretained
// becaues of its type, then pretend it was actually implicitly
// __strong. This is only sound because we're processing the
// property implementation before parsing any method bodies.
if (ivarLifetime == Qualifiers::OCL_ExplicitNone &&
propertyLifetime == Qualifiers::OCL_Strong &&
ivar->getAccessControl() == ObjCIvarDecl::Private) {
SplitQualType split = ivarType.split();
if (split.Quals.hasObjCLifetime()) {
assert(ivarType->isObjCARCImplicitlyUnretainedType());
split.Quals.setObjCLifetime(Qualifiers::OCL_Strong);
ivarType = S.Context.getQualifiedType(split);
ivar->setType(ivarType);
return;
}
}
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
switch (propertyLifetime) {
case Qualifiers::OCL_Strong:
[objc] For the ARC error that is emitted when a synthesized property implementation has inconsistent ownership with the backing ivar, point the error location to the ivar. Pointing to the ivar (instead of the @synthesize) is better since this is where a fix is needed. Also provide the location of @synthesize via a note. This also fixes the problem where an auto-synthesized property would emit an error without any location. llvm-svn: 170039
2012-12-13 06:48:25 +08:00
S.Diag(ivar->getLocation(), diag::err_arc_strong_property_ownership)
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
<< property->getDeclName()
<< ivar->getDeclName()
<< ivarLifetime;
break;
case Qualifiers::OCL_Weak:
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
S.Diag(ivar->getLocation(), diag::err_weak_property)
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
<< property->getDeclName()
<< ivar->getDeclName();
break;
case Qualifiers::OCL_ExplicitNone:
[objc] For the ARC error that is emitted when a synthesized property implementation has inconsistent ownership with the backing ivar, point the error location to the ivar. Pointing to the ivar (instead of the @synthesize) is better since this is where a fix is needed. Also provide the location of @synthesize via a note. This also fixes the problem where an auto-synthesized property would emit an error without any location. llvm-svn: 170039
2012-12-13 06:48:25 +08:00
S.Diag(ivar->getLocation(), diag::err_arc_assign_property_ownership)
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
<< property->getDeclName()
<< ivar->getDeclName()
<< ((property->getPropertyAttributesAsWritten()
& ObjCPropertyDecl::OBJC_PR_assign) != 0);
break;
case Qualifiers::OCL_Autoreleasing:
llvm_unreachable("properties cannot be autoreleasing");
case Qualifiers::OCL_None:
// Any other property should be ignored.
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
return;
}
S.Diag(property->getLocation(), diag::note_property_declare);
[objc] For the ARC error that is emitted when a synthesized property implementation has inconsistent ownership with the backing ivar, point the error location to the ivar. Pointing to the ivar (instead of the @synthesize) is better since this is where a fix is needed. Also provide the location of @synthesize via a note. This also fixes the problem where an auto-synthesized property would emit an error without any location. llvm-svn: 170039
2012-12-13 06:48:25 +08:00
if (propertyImplLoc.isValid())
S.Diag(propertyImplLoc, diag::note_property_synthesize);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
objc-arc: evaluate 'readonly' property with no known life-time to that of its backing 'ivar's lifetime. // rdar://10558871 llvm-svn: 147956
2012-01-12 02:26:06 +08:00
/// setImpliedPropertyAttributeForReadOnlyProperty -
/// This routine evaludates life-time attributes for a 'readonly'
/// property with no known lifetime of its own, using backing
/// 'ivar's attribute, if any. If no backing 'ivar', property's
/// life-time is assumed 'strong'.
static void setImpliedPropertyAttributeForReadOnlyProperty(
ObjCPropertyDecl *property, ObjCIvarDecl *ivar) {
Qualifiers::ObjCLifetime propertyLifetime =
getImpliedARCOwnership(property->getPropertyAttributes(),
property->getType());
if (propertyLifetime != Qualifiers::OCL_None)
return;
if (!ivar) {
// if no backing ivar, make property 'strong'.
property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_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);
else if (ivarLifetime == Qualifiers::OCL_Weak)
property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_weak);
}
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
static bool
isIncompatiblePropertyAttribute(unsigned Attr1, unsigned Attr2,
ObjCPropertyDecl::PropertyAttributeKind Kind) {
return (Attr1 & Kind) != (Attr2 & Kind);
}
static bool areIncompatiblePropertyAttributes(unsigned Attr1, unsigned Attr2,
unsigned Kinds) {
return ((Attr1 & Kinds) != 0) != ((Attr2 & Kinds) != 0);
}
/// SelectPropertyForSynthesisFromProtocols - Finds the most appropriate
/// property declaration that should be synthesised in all of the inherited
/// protocols. It also diagnoses properties declared in inherited protocols with
/// mismatched types or attributes, since any of them can be candidate for
/// synthesis.
static ObjCPropertyDecl *
SelectPropertyForSynthesisFromProtocols(Sema &S, SourceLocation AtLoc,
Make helper functions static. llvm-svn: 182589
2013-05-23 23:53:44 +08:00
ObjCInterfaceDecl *ClassDecl,
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
ObjCPropertyDecl *Property) {
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
assert(isa<ObjCProtocolDecl>(Property->getDeclContext()) &&
"Expected a property from a protocol");
ObjCInterfaceDecl::ProtocolPropertySet ProtocolSet;
ObjCInterfaceDecl::PropertyDeclOrder Properties;
[C++11] Replacing ObjCInterfaceDecl iterators all_referenced_protocol_begin() and all_referenced_protocol_end() with iterator_range all_referenced_protocols(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203848
2014-03-14 04:55:22 +08:00
for (const auto *PI : ClassDecl->all_referenced_protocols()) {
if (const ObjCProtocolDecl *PDecl = PI->getDefinition())
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
PDecl->collectInheritedProtocolProperties(Property, ProtocolSet,
Properties);
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
}
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
if (ObjCInterfaceDecl *SDecl = ClassDecl->getSuperClass()) {
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
while (SDecl) {
[C++11] Replacing ObjCInterfaceDecl iterators all_referenced_protocol_begin() and all_referenced_protocol_end() with iterator_range all_referenced_protocols(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203848
2014-03-14 04:55:22 +08:00
for (const auto *PI : SDecl->all_referenced_protocols()) {
if (const ObjCProtocolDecl *PDecl = PI->getDefinition())
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
PDecl->collectInheritedProtocolProperties(Property, ProtocolSet,
Properties);
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
}
SDecl = SDecl->getSuperClass();
}
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
}
if (Properties.empty())
return Property;
ObjCPropertyDecl *OriginalProperty = Property;
size_t SelectedIndex = 0;
for (const auto &Prop : llvm::enumerate(Properties)) {
// Select the 'readwrite' property if such property exists.
if (Property->isReadOnly() && !Prop.value()->isReadOnly()) {
Property = Prop.value();
SelectedIndex = Prop.index();
}
}
if (Property != OriginalProperty) {
// Check that the old property is compatible with the new one.
Properties[SelectedIndex] = OriginalProperty;
}
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
QualType RHSType = S.Context.getCanonicalType(Property->getType());
[ObjC] Check written attributes only when synthesizing ambiguous property This commit fixes a bug introduced in r307903. The attribute ambiguity checker that was introduced in r307903 checked all property attributes, which caused errors for source-compatible properties, like: @property (nonatomic, readonly) NSObject *prop; @property (nonatomic, readwrite) NSObject *prop; because the readwrite property would get implicit 'strong' attribute. The ambiguity checker should be concerned about explicitly specified attributes only. rdar://33748089 llvm-svn: 311443
2017-08-22 18:38:07 +08:00
unsigned OriginalAttributes = Property->getPropertyAttributesAsWritten();
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
enum MismatchKind {
IncompatibleType = 0,
HasNoExpectedAttribute,
HasUnexpectedAttribute,
DifferentGetter,
DifferentSetter
};
// Represents a property from another protocol that conflicts with the
// selected declaration.
struct MismatchingProperty {
const ObjCPropertyDecl *Prop;
MismatchKind Kind;
StringRef AttributeName;
};
SmallVector<MismatchingProperty, 4> Mismatches;
for (ObjCPropertyDecl *Prop : Properties) {
// Verify the property attributes.
[ObjC] Check written attributes only when synthesizing ambiguous property This commit fixes a bug introduced in r307903. The attribute ambiguity checker that was introduced in r307903 checked all property attributes, which caused errors for source-compatible properties, like: @property (nonatomic, readonly) NSObject *prop; @property (nonatomic, readwrite) NSObject *prop; because the readwrite property would get implicit 'strong' attribute. The ambiguity checker should be concerned about explicitly specified attributes only. rdar://33748089 llvm-svn: 311443
2017-08-22 18:38:07 +08:00
unsigned Attr = Prop->getPropertyAttributesAsWritten();
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
if (Attr != OriginalAttributes) {
auto Diag = [&](bool OriginalHasAttribute, StringRef AttributeName) {
MismatchKind Kind = OriginalHasAttribute ? HasNoExpectedAttribute
: HasUnexpectedAttribute;
Mismatches.push_back({Prop, Kind, AttributeName});
};
if (isIncompatiblePropertyAttribute(OriginalAttributes, Attr,
ObjCPropertyDecl::OBJC_PR_copy)) {
Diag(OriginalAttributes & ObjCPropertyDecl::OBJC_PR_copy, "copy");
continue;
}
if (areIncompatiblePropertyAttributes(
OriginalAttributes, Attr, ObjCPropertyDecl::OBJC_PR_retain |
ObjCPropertyDecl::OBJC_PR_strong)) {
Diag(OriginalAttributes & (ObjCPropertyDecl::OBJC_PR_retain |
ObjCPropertyDecl::OBJC_PR_strong),
"retain (or strong)");
continue;
}
if (isIncompatiblePropertyAttribute(OriginalAttributes, Attr,
ObjCPropertyDecl::OBJC_PR_atomic)) {
Diag(OriginalAttributes & ObjCPropertyDecl::OBJC_PR_atomic, "atomic");
continue;
}
}
if (Property->getGetterName() != Prop->getGetterName()) {
Mismatches.push_back({Prop, DifferentGetter, ""});
continue;
}
if (!Property->isReadOnly() && !Prop->isReadOnly() &&
Property->getSetterName() != Prop->getSetterName()) {
Mismatches.push_back({Prop, DifferentSetter, ""});
continue;
}
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
QualType LHSType = S.Context.getCanonicalType(Prop->getType());
if (!S.Context.propertyTypesAreCompatible(LHSType, RHSType)) {
bool IncompatibleObjC = false;
QualType ConvertedType;
if (!S.isObjCPointerConversion(RHSType, LHSType, ConvertedType, IncompatibleObjC)
|| IncompatibleObjC) {
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
Mismatches.push_back({Prop, IncompatibleType, ""});
continue;
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
}
}
}
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
if (Mismatches.empty())
return Property;
// Diagnose incompability.
{
bool HasIncompatibleAttributes = false;
for (const auto &Note : Mismatches)
HasIncompatibleAttributes =
Note.Kind != IncompatibleType ? true : HasIncompatibleAttributes;
// Promote the warning to an error if there are incompatible attributes or
// incompatible types together with readwrite/readonly incompatibility.
auto Diag = S.Diag(Property->getLocation(),
Property != OriginalProperty || HasIncompatibleAttributes
? diag::err_protocol_property_mismatch
: diag::warn_protocol_property_mismatch);
Diag << Mismatches[0].Kind;
switch (Mismatches[0].Kind) {
case IncompatibleType:
Diag << Property->getType();
break;
case HasNoExpectedAttribute:
case HasUnexpectedAttribute:
Diag << Mismatches[0].AttributeName;
break;
case DifferentGetter:
Diag << Property->getGetterName();
break;
case DifferentSetter:
Diag << Property->getSetterName();
break;
}
}
for (const auto &Note : Mismatches) {
auto Diag =
S.Diag(Note.Prop->getLocation(), diag::note_protocol_property_declare)
<< Note.Kind;
switch (Note.Kind) {
case IncompatibleType:
Diag << Note.Prop->getType();
break;
case HasNoExpectedAttribute:
case HasUnexpectedAttribute:
Diag << Note.AttributeName;
break;
case DifferentGetter:
Diag << Note.Prop->getGetterName();
break;
case DifferentSetter:
Diag << Note.Prop->getSetterName();
break;
}
}
if (AtLoc.isValid())
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
S.Diag(AtLoc, diag::note_property_synthesize);
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
return Property;
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
}
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
/// Determine whether any storage attributes were written on the property.
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
static bool hasWrittenStorageAttribute(ObjCPropertyDecl *Prop,
ObjCPropertyQueryKind QueryKind) {
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
if (Prop->getPropertyAttributesAsWritten() & OwnershipMask) return true;
// If this is a readwrite property in a class extension that refines
// a readonly property in the original class definition, check it as
// well.
// If it's a readonly property, we're not interested.
if (Prop->isReadOnly()) return false;
// Is it declared in an extension?
auto Category = dyn_cast<ObjCCategoryDecl>(Prop->getDeclContext());
if (!Category || !Category->IsClassExtension()) return false;
// Find the corresponding property in the primary class definition.
auto OrigClass = Category->getClassInterface();
for (auto Found : OrigClass->lookup(Prop->getDeclName())) {
if (ObjCPropertyDecl *OrigProp = dyn_cast<ObjCPropertyDecl>(Found))
return OrigProp->getPropertyAttributesAsWritten() & OwnershipMask;
}
ObjC properties: consider ownership of properties from protocols when synthesizing. When determining whether ownership was explicitly written for a property when it is being synthesized, also consider that the original property might have come from a protocol. Fixes rdar://problem/23931441. llvm-svn: 255943
2015-12-18 08:52:31 +08:00
// Look through all of the protocols.
for (const auto *Proto : OrigClass->all_referenced_protocols()) {
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
if (ObjCPropertyDecl *OrigProp = Proto->FindPropertyDeclaration(
Prop->getIdentifier(), QueryKind))
ObjC properties: consider ownership of properties from protocols when synthesizing. When determining whether ownership was explicitly written for a property when it is being synthesized, also consider that the original property might have come from a protocol. Fixes rdar://problem/23931441. llvm-svn: 255943
2015-12-18 08:52:31 +08:00
return OrigProp->getPropertyAttributesAsWritten() & OwnershipMask;
}
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
return false;
}
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
/// ActOnPropertyImplDecl - This routine performs semantic checks and
/// builds the AST node for a property implementation declaration; declared
Documentation cleanup: * Removed \param comments for parameters that no longer exist; * Fixed a "\para" typo to "\param"; * Escaped @, # and \ symbols as needed in Doxygen comments; * Added use of \brief to output short summaries. llvm-svn: 158498
2012-06-15 15:13:21 +08:00
/// as \@synthesize or \@dynamic.
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
///
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *Sema::ActOnPropertyImplDecl(Scope *S,
SourceLocation AtLoc,
SourceLocation PropertyLoc,
bool Synthesize,
IdentifierInfo *PropertyId,
For an Objective-C @synthesize statement, e.g., @synthesize foo = _foo; keep track of the location of the ivar ("_foo"). Teach libclang to visit the ivar as a member reference. llvm-svn: 119447
2010-11-17 09:03:52 +08:00
IdentifierInfo *PropertyIvar,
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
SourceLocation PropertyIvarLoc,
ObjCPropertyQueryKind QueryKind) {
Use cast<> + OpaquePtr.getAs<Decl> to add extra checking of our assumptions. llvm-svn: 100496
2010-04-06 07:45:09 +08:00
ObjCContainerDecl *ClassImpDecl =
CurContext cannot be null ever. llvm-svn: 140022
2011-09-20 00:32:32 +08:00
dyn_cast<ObjCContainerDecl>(CurContext);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Make sure we have a context for the property implementation declaration.
if (!ClassImpDecl) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(AtLoc, diag::err_missing_property_context);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
[AST] When we @synthesize a property with a user-defined ivar name, make sure to record the source location of the ivar name. [libclang] When indexing @synthesized objc methods, report the @implementation as the lexical container. Fixes rdar://10905472 llvm-svn: 151635
2012-02-29 01:50:39 +08:00
if (PropertyIvarLoc.isInvalid())
PropertyIvarLoc = PropertyLoc;
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
SourceLocation PropertyDiagLoc = PropertyLoc;
if (PropertyDiagLoc.isInvalid())
PropertyDiagLoc = ClassImpDecl->getLocStart();
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
ObjCPropertyDecl *property = nullptr;
ObjCInterfaceDecl *IDecl = nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Find the class or category class where this property must have
// a declaration.
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
ObjCImplementationDecl *IC = nullptr;
ObjCCategoryImplDecl *CatImplClass = nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {
IDecl = IC->getClassInterface();
// We always synthesize an interface for an implementation
// without an interface decl. So, IDecl is always non-zero.
assert(IDecl &&
"ActOnPropertyImplDecl - @implementation without @interface");
// Look for this property declaration in the @implementation's @interface
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
property = IDecl->FindPropertyDeclaration(PropertyId, QueryKind);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
if (!property) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyLoc, diag::err_bad_property_decl) << IDecl->getDeclName();
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
Class Property: warn for synthesize on a class property. rdar://23891898 llvm-svn: 259226
2016-01-30 03:16:39 +08:00
if (property->isClassProperty() && Synthesize) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyLoc, diag::err_synthesize_on_class_property) << PropertyId;
Class Property: warn for synthesize on a class property. rdar://23891898 llvm-svn: 259226
2016-01-30 03:16:39 +08:00
return nullptr;
}
Warn when synthesizing a property which is implicitly atomic under -Wimplicit-atomic-properties flag. // rdar://8774580 llvm-svn: 122095
2010-12-18 06:28:16 +08:00
unsigned PIkind = property->getPropertyAttributesAsWritten();
Restore 'atomic' as an attribute of objc properties. llvm-svn: 132866
2011-06-11 08:45:12 +08:00
if ((PIkind & (ObjCPropertyDecl::OBJC_PR_atomic |
ObjCPropertyDecl::OBJC_PR_nonatomic) ) == 0) {
Warn when synthesizing a property which is implicitly atomic under -Wimplicit-atomic-properties flag. // rdar://8774580 llvm-svn: 122095
2010-12-18 06:28:16 +08:00
if (AtLoc.isValid())
Diag(AtLoc, diag::warn_implicit_atomic_property);
else
Diag(IC->getLocation(), diag::warn_auto_implicit_atomic_property);
Diag(property->getLocation(), diag::note_property_declare);
}
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
if (const ObjCCategoryDecl *CD =
dyn_cast<ObjCCategoryDecl>(property->getDeclContext())) {
if (!CD->IsClassExtension()) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyLoc, diag::err_category_property) << CD->getDeclName();
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Diag(property->getLocation(), diag::note_property_declare);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
}
objective-c: Warn if default synthesizing readonly IBOutlet properties and provide a 'fixit' to change 'readonly' to 'readwrite'. 'fixit' part needs little more work. // rdar://11448209 llvm-svn: 157121
2012-05-20 02:17:17 +08:00
if (Synthesize&&
(PIkind & ObjCPropertyDecl::OBJC_PR_readonly) &&
property->hasAttr<IBOutletAttr>() &&
!AtLoc.isValid()) {
objective-C: don't issue bogus warning about "auto-synthesized may not work correctly with 'nib' loader" when 'readonly' property is redeclared 'readwrite' in class extension. // rdar://13123861 llvm-svn: 174775
2013-02-09 07:32:30 +08:00
bool ReadWriteProperty = false;
// Search into the class extensions and see if 'readonly property is
// redeclared 'readwrite', then no warning is to be issued.
[C++11] Replacing ObjCInterfaceDecl iterators known_extensions_begin() and known_extensions_end() with iterator_range known_extensions(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203857
2014-03-14 05:57:01 +08:00
for (auto *Ext : IDecl->known_extensions()) {
objective-C: don't issue bogus warning about "auto-synthesized may not work correctly with 'nib' loader" when 'readonly' property is redeclared 'readwrite' in class extension. // rdar://13123861 llvm-svn: 174775
2013-02-09 07:32:30 +08:00
DeclContext::lookup_result R = Ext->lookup(property->getDeclName());
if (!R.empty())
if (ObjCPropertyDecl *ExtProp = dyn_cast<ObjCPropertyDecl>(R[0])) {
PIkind = ExtProp->getPropertyAttributesAsWritten();
if (PIkind & ObjCPropertyDecl::OBJC_PR_readwrite) {
ReadWriteProperty = true;
break;
}
}
}
if (!ReadWriteProperty) {
QoI: -Wreadonly-iboutlet-property should have the warning's location on the property. There's no need to refer to the @implementation at all. Fixes <rdar://problem/13186515> llvm-svn: 174802
2013-02-09 15:13:16 +08:00
Diag(property->getLocation(), diag::warn_auto_readonly_iboutlet_property)
Removing some more unnecessary manual quotes from diagnostics. llvm-svn: 198418
2014-01-03 22:23:03 +08:00
<< property;
objective-C: don't issue bogus warning about "auto-synthesized may not work correctly with 'nib' loader" when 'readonly' property is redeclared 'readwrite' in class extension. // rdar://13123861 llvm-svn: 174775
2013-02-09 07:32:30 +08:00
SourceLocation readonlyLoc;
if (LocPropertyAttribute(Context, "readonly",
property->getLParenLoc(), readonlyLoc)) {
SourceLocation endLoc =
readonlyLoc.getLocWithOffset(strlen("readonly")-1);
SourceRange ReadonlySourceRange(readonlyLoc, endLoc);
Diag(property->getLocation(),
diag::note_auto_readonly_iboutlet_fixup_suggest) <<
FixItHint::CreateReplacement(ReadonlySourceRange, "readwrite");
}
objective-c: When default synthesizing readonly IBOutlet properties provide a 'fixit' to change 'readonly' to 'readwrite'. // rdar://11448209 llvm-svn: 157193
2012-05-22 01:02:43 +08:00
}
objective-c: Warn if default synthesizing readonly IBOutlet properties and provide a 'fixit' to change 'readonly' to 'readwrite'. 'fixit' part needs little more work. // rdar://11448209 llvm-svn: 157121
2012-05-20 02:17:17 +08:00
}
Objective-C [qoi]: When an class conforms to multiple protocols that declare the same property of incompatible types, issue a warning when class implementation synthesizes the property. // rdar://13075400 llvm-svn: 182316
2013-05-21 05:20:24 +08:00
if (Synthesize && isa<ObjCProtocolDecl>(property->getDeclContext()))
[ObjC] Pick a 'readwrite' property when synthesizing ambiguous property and check for incompatible attributes This commit changes the way ambiguous property synthesis (i.e. when synthesizing a property that's declared in multiple protocols) is performed. Previously, Clang synthesized the first property that was found. This lead to problems when the property was synthesized in a class that conformed to two protocols that declared that property and a second protocols had a 'readwrite' declaration - the setter was not synthesized so the class didn't really conform to the second protocol and user's code would crash at runtime when they would try to set the property. This commit ensures that a first readwrite property is selected. This is a semantic change that changes users code in this manner: ``` @protocol P @property(readonly) int p; @end @protocol P2 @property(readwrite) id p; @end @interface I <P2> @end @implementation I @syntesize p; // Users previously got a warning here, and Clang synthesized // readonly 'int p' here. Now Clang synthesizes readwrite 'id' p.. @end ``` To ensure that this change is safe, the warning about incompatible types is promoted to an error when this kind of readonly/readwrite ambiguity is detected in the @implementation. This will ensure that previous code that had this subtle bug and ignored the warning now will fail to compile with an error, and users should not get suprises at runtime once they resolve the error. The commit also extends the ambiguity checker, and now it can detect conflicts among the different property attributes. An error diagnostic is used for conflicting attributes, to ensure that the user won't get "suprises" at runtime. ProtocolPropertyMap is removed in favour of a a set + vector because the map's order of iteration is non-deterministic, so it couldn't be used to select the readwrite property. rdar://31579994 Differential Revision: https://reviews.llvm.org/D35268 llvm-svn: 307903
2017-07-13 19:06:22 +08:00
property = SelectPropertyForSynthesisFromProtocols(*this, AtLoc, IDecl,
property);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
} else if ((CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassImpDecl))) {
if (Synthesize) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(AtLoc, diag::err_synthesize_category_decl);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
IDecl = CatImplClass->getClassInterface();
if (!IDecl) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(AtLoc, diag::err_missing_property_interface);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
ObjCCategoryDecl *Category =
IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier());
// If category for this implementation not found, it is an error which
// has already been reported eralier.
if (!Category)
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Look for this property declaration in @implementation's category
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
property = Category->FindPropertyDeclaration(PropertyId, QueryKind);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
if (!property) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyLoc, diag::err_bad_category_property_decl)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
<< Category->getDeclName();
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
} else {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(AtLoc, diag::err_bad_property_context);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
ObjCIvarDecl *Ivar = nullptr;
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
bool CompleteTypeErr = false;
objc: avoid duplicate diagnostics on certain type mismatches between property and its backing ivar. llvm-svn: 156832
2012-05-16 02:12:51 +08:00
bool compat = true;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Check that we have a valid, previously declared ivar for @synthesize
if (Synthesize) {
// @synthesize
if (!PropertyIvar)
PropertyIvar = PropertyId;
objc-arc: evaluate 'readonly' property with no known life-time to that of its backing 'ivar's lifetime. // rdar://10558871 llvm-svn: 147956
2012-01-12 02:26:06 +08:00
// Check that this is a previously declared 'ivar' in 'IDecl' interface
ObjCInterfaceDecl *ClassDeclared;
Ivar = IDecl->lookupInstanceVariable(PropertyIvar, ClassDeclared);
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
QualType PropType = property->getType();
QualType PropertyIvarType = PropType.getNonReferenceType();
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
if (RequireCompleteType(PropertyDiagLoc, PropertyIvarType,
Move Sema::RequireCompleteType() and Sema::RequireCompleteExprType() off PartialDiagnostic. PartialDiagnostic is rather heavyweight for something that is in the critical path and is rarely used. So, switch over to an abstract-class-based callback mechanism that delays most of the work until a diagnostic is actually produced. Good for ~11k code size reduction in the compiler and 1% speedup in -fsyntax-only on the code in <rdar://problem/11004361>. llvm-svn: 156176
2012-05-05 00:32:21 +08:00
diag::err_incomplete_synthesized_property,
property->getDeclName())) {
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
Diag(property->getLocation(), diag::note_property_declare);
CompleteTypeErr = true;
}
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().ObjCAutoRefCount &&
objc-arc: evaluate 'readonly' property with no known life-time to that of its backing 'ivar's lifetime. // rdar://10558871 llvm-svn: 147956
2012-01-12 02:26:06 +08:00
(property->getPropertyAttributesAsWritten() &
minor refactoring to improve compile-time performance. llvm-svn: 147963
2012-01-12 03:48:08 +08:00
ObjCPropertyDecl::OBJC_PR_readonly) &&
PropertyIvarType->isObjCRetainableType()) {
objc-arc: evaluate 'readonly' property with no known life-time to that of its backing 'ivar's lifetime. // rdar://10558871 llvm-svn: 147956
2012-01-12 02:26:06 +08:00
setImpliedPropertyAttributeForReadOnlyProperty(property, Ivar);
}
ObjCPropertyDecl::PropertyAttributeKind kind
= property->getPropertyAttributes();
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
Define weak and __weak to mean ARC-style weak references, even in MRC. Previously, __weak was silently accepted and ignored in MRC mode. That makes this a potentially source-breaking change that we have to roll out cautiously. Accordingly, for the time being, actual support for __weak references in MRC is experimental, and the compiler will reject attempts to actually form such references. The intent is to eventually enable the feature by default in all non-GC modes. (It is, of course, incompatible with ObjC GC's interpretation of __weak.) If you like, you can enable this feature with -Xclang -fobjc-weak but like any -Xclang option, this option may be removed at any point, e.g. if/when it is eventually enabled by default. This patch also enables the use of the ARC __unsafe_unretained qualifier in MRC. Unlike __weak, this is being enabled immediately. Since variables are essentially __unsafe_unretained by default in MRC, the only practical uses are (1) communication and (2) changing the default behavior of by-value block capture. As an implementation matter, this means that the ObjC ownership qualifiers may appear in any ObjC language mode, and so this patch removes a number of checks for getLangOpts().ObjCAutoRefCount that were guarding the processing of these qualifiers. I don't expect this to be a significant drain on performance; it may even be faster to just check for these qualifiers directly on a type (since it's probably in a register anyway) than to do N dependent loads to grab the LangOptions. rdar://9674298 llvm-svn: 251041
2015-10-23 02:38:17 +08:00
bool isARCWeak = false;
if (kind & ObjCPropertyDecl::OBJC_PR_weak) {
// Add GC __weak to the ivar type if the property is weak.
if (getLangOpts().getGC() != LangOptions::NonGC) {
assert(!getLangOpts().ObjCAutoRefCount);
if (PropertyIvarType.isObjCGCStrong()) {
Diag(PropertyDiagLoc, diag::err_gc_weak_property_strong_type);
Diag(property->getLocation(), diag::note_property_declare);
} else {
PropertyIvarType =
Context.getObjCGCQualType(PropertyIvarType, Qualifiers::Weak);
}
// Otherwise, check whether ARC __weak is enabled and works with
// the property type.
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
} else {
Define weak and __weak to mean ARC-style weak references, even in MRC. Previously, __weak was silently accepted and ignored in MRC mode. That makes this a potentially source-breaking change that we have to roll out cautiously. Accordingly, for the time being, actual support for __weak references in MRC is experimental, and the compiler will reject attempts to actually form such references. The intent is to eventually enable the feature by default in all non-GC modes. (It is, of course, incompatible with ObjC GC's interpretation of __weak.) If you like, you can enable this feature with -Xclang -fobjc-weak but like any -Xclang option, this option may be removed at any point, e.g. if/when it is eventually enabled by default. This patch also enables the use of the ARC __unsafe_unretained qualifier in MRC. Unlike __weak, this is being enabled immediately. Since variables are essentially __unsafe_unretained by default in MRC, the only practical uses are (1) communication and (2) changing the default behavior of by-value block capture. As an implementation matter, this means that the ObjC ownership qualifiers may appear in any ObjC language mode, and so this patch removes a number of checks for getLangOpts().ObjCAutoRefCount that were guarding the processing of these qualifiers. I don't expect this to be a significant drain on performance; it may even be faster to just check for these qualifiers directly on a type (since it's probably in a register anyway) than to do N dependent loads to grab the LangOptions. rdar://9674298 llvm-svn: 251041
2015-10-23 02:38:17 +08:00
if (!getLangOpts().ObjCWeak) {
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
// Only complain here when synthesizing an ivar.
if (!Ivar) {
Diag(PropertyDiagLoc,
getLangOpts().ObjCWeakRuntime
? diag::err_synthesizing_arc_weak_property_disabled
: diag::err_synthesizing_arc_weak_property_no_runtime);
Diag(property->getLocation(), diag::note_property_declare);
Define weak and __weak to mean ARC-style weak references, even in MRC. Previously, __weak was silently accepted and ignored in MRC mode. That makes this a potentially source-breaking change that we have to roll out cautiously. Accordingly, for the time being, actual support for __weak references in MRC is experimental, and the compiler will reject attempts to actually form such references. The intent is to eventually enable the feature by default in all non-GC modes. (It is, of course, incompatible with ObjC GC's interpretation of __weak.) If you like, you can enable this feature with -Xclang -fobjc-weak but like any -Xclang option, this option may be removed at any point, e.g. if/when it is eventually enabled by default. This patch also enables the use of the ARC __unsafe_unretained qualifier in MRC. Unlike __weak, this is being enabled immediately. Since variables are essentially __unsafe_unretained by default in MRC, the only practical uses are (1) communication and (2) changing the default behavior of by-value block capture. As an implementation matter, this means that the ObjC ownership qualifiers may appear in any ObjC language mode, and so this patch removes a number of checks for getLangOpts().ObjCAutoRefCount that were guarding the processing of these qualifiers. I don't expect this to be a significant drain on performance; it may even be faster to just check for these qualifiers directly on a type (since it's probably in a register anyway) than to do N dependent loads to grab the LangOptions. rdar://9674298 llvm-svn: 251041
2015-10-23 02:38:17 +08:00
}
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
CompleteTypeErr = true; // suppress later diagnostics about the ivar
Define weak and __weak to mean ARC-style weak references, even in MRC. Previously, __weak was silently accepted and ignored in MRC mode. That makes this a potentially source-breaking change that we have to roll out cautiously. Accordingly, for the time being, actual support for __weak references in MRC is experimental, and the compiler will reject attempts to actually form such references. The intent is to eventually enable the feature by default in all non-GC modes. (It is, of course, incompatible with ObjC GC's interpretation of __weak.) If you like, you can enable this feature with -Xclang -fobjc-weak but like any -Xclang option, this option may be removed at any point, e.g. if/when it is eventually enabled by default. This patch also enables the use of the ARC __unsafe_unretained qualifier in MRC. Unlike __weak, this is being enabled immediately. Since variables are essentially __unsafe_unretained by default in MRC, the only practical uses are (1) communication and (2) changing the default behavior of by-value block capture. As an implementation matter, this means that the ObjC ownership qualifiers may appear in any ObjC language mode, and so this patch removes a number of checks for getLangOpts().ObjCAutoRefCount that were guarding the processing of these qualifiers. I don't expect this to be a significant drain on performance; it may even be faster to just check for these qualifiers directly on a type (since it's probably in a register anyway) than to do N dependent loads to grab the LangOptions. rdar://9674298 llvm-svn: 251041
2015-10-23 02:38:17 +08:00
} else {
isARCWeak = true;
if (const ObjCObjectPointerType *ObjT =
PropertyIvarType->getAs<ObjCObjectPointerType>()) {
const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl();
if (ObjI && ObjI->isArcWeakrefUnavailable()) {
Diag(property->getLocation(),
diag::err_arc_weak_unavailable_property)
<< PropertyIvarType;
Diag(ClassImpDecl->getLocation(), diag::note_implemented_by_class)
<< ClassImpDecl->getName();
}
}
}
objc-gc: More sema work for properties declared 'weak' in GC mode. // rdar://10073896 llvm-svn: 139235
2011-09-08 00:24:21 +08:00
}
}
Define weak and __weak to mean ARC-style weak references, even in MRC. Previously, __weak was silently accepted and ignored in MRC mode. That makes this a potentially source-breaking change that we have to roll out cautiously. Accordingly, for the time being, actual support for __weak references in MRC is experimental, and the compiler will reject attempts to actually form such references. The intent is to eventually enable the feature by default in all non-GC modes. (It is, of course, incompatible with ObjC GC's interpretation of __weak.) If you like, you can enable this feature with -Xclang -fobjc-weak but like any -Xclang option, this option may be removed at any point, e.g. if/when it is eventually enabled by default. This patch also enables the use of the ARC __unsafe_unretained qualifier in MRC. Unlike __weak, this is being enabled immediately. Since variables are essentially __unsafe_unretained by default in MRC, the only practical uses are (1) communication and (2) changing the default behavior of by-value block capture. As an implementation matter, this means that the ObjC ownership qualifiers may appear in any ObjC language mode, and so this patch removes a number of checks for getLangOpts().ObjCAutoRefCount that were guarding the processing of these qualifiers. I don't expect this to be a significant drain on performance; it may even be faster to just check for these qualifiers directly on a type (since it's probably in a register anyway) than to do N dependent loads to grab the LangOptions. rdar://9674298 llvm-svn: 251041
2015-10-23 02:38:17 +08:00
objc: improved diagnostic when property autosynthesis may cause change in behavior. // rdar://11671080 llvm-svn: 158828
2012-06-21 01:18:31 +08:00
if (AtLoc.isInvalid()) {
// Check when default synthesizing a property that there is
// an ivar matching property name and issue warning; since this
// is the most common case of not using an ivar used for backing
// property in non-default synthesis case.
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
ObjCInterfaceDecl *ClassDeclared=nullptr;
objc: improved diagnostic when property autosynthesis may cause change in behavior. // rdar://11671080 llvm-svn: 158828
2012-06-21 01:18:31 +08:00
ObjCIvarDecl *originalIvar =
IDecl->lookupInstanceVariable(property->getIdentifier(),
ClassDeclared);
if (originalIvar) {
Diag(PropertyDiagLoc,
diag::warn_autosynthesis_property_ivar_match)
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
<< PropertyId << (Ivar == nullptr) << PropertyIvar
objc diagnostic: pass IdentifierInfo* to the diagnostic system to produce quotes instead of adding qoute to the test. llvm-svn: 159450
2012-06-30 02:43:30 +08:00
<< originalIvar->getIdentifier();
objc: improved diagnostic when property autosynthesis may cause change in behavior. // rdar://11671080 llvm-svn: 158828
2012-06-21 01:18:31 +08:00
Diag(property->getLocation(), diag::note_property_declare);
Diag(originalIvar->getLocation(), diag::note_ivar_decl);
objective-c: warn when autosynthesizing a property which has same name as an existing ivar since this is common source of error when people remove @synthesize to take advantage of autosynthesis. // rdar://11671080 llvm-svn: 158756
2012-06-20 06:51:22 +08:00
}
objc: improved diagnostic when property autosynthesis may cause change in behavior. // rdar://11671080 llvm-svn: 158828
2012-06-21 01:18:31 +08:00
}
if (!Ivar) {
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
// In ARC, give the ivar a lifetime qualifier based on the
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
// property attributes.
Define weak and __weak to mean ARC-style weak references, even in MRC. Previously, __weak was silently accepted and ignored in MRC mode. That makes this a potentially source-breaking change that we have to roll out cautiously. Accordingly, for the time being, actual support for __weak references in MRC is experimental, and the compiler will reject attempts to actually form such references. The intent is to eventually enable the feature by default in all non-GC modes. (It is, of course, incompatible with ObjC GC's interpretation of __weak.) If you like, you can enable this feature with -Xclang -fobjc-weak but like any -Xclang option, this option may be removed at any point, e.g. if/when it is eventually enabled by default. This patch also enables the use of the ARC __unsafe_unretained qualifier in MRC. Unlike __weak, this is being enabled immediately. Since variables are essentially __unsafe_unretained by default in MRC, the only practical uses are (1) communication and (2) changing the default behavior of by-value block capture. As an implementation matter, this means that the ObjC ownership qualifiers may appear in any ObjC language mode, and so this patch removes a number of checks for getLangOpts().ObjCAutoRefCount that were guarding the processing of these qualifiers. I don't expect this to be a significant drain on performance; it may even be faster to just check for these qualifiers directly on a type (since it's probably in a register anyway) than to do N dependent loads to grab the LangOptions. rdar://9674298 llvm-svn: 251041
2015-10-23 02:38:17 +08:00
if ((getLangOpts().ObjCAutoRefCount || isARCWeak) &&
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
!PropertyIvarType.getObjCLifetime() &&
PropertyIvarType->isObjCRetainableType()) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
// It's an error if we have to do this and the user didn't
// explicitly write an ownership attribute on the property.
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
if (!hasWrittenStorageAttribute(property, QueryKind) &&
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
!(kind & ObjCPropertyDecl::OBJC_PR_strong)) {
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
Diag(PropertyDiagLoc,
In ARC we emit an error when compiling: @interface Foo : NSObject @property (readonly) id myProp; @end @implementation Foo @synthesize myProp; @end t.m:9:13: error: ARC forbids synthesizing a property of an Objective-C object with unspecified storage attribute @synthesize myProp; ^ which is fine, we want the ownership of the synthesized ivar to be explicit. But we should _not_ emit an error for the following cases, because we can get the ownership either from the declared ivar or from the property type: @interface Foo : NSObject { __weak id _myProp1; id myProp2; } @property (readonly) id myProp1; @property (readonly) id myProp2; @property (readonly) __strong id myProp3; @end @implementation Foo @synthesize myProp1 = _myProp1; @synthesize myProp2; @synthesize myProp3; @end  rdar://9844006. llvm-svn: 136155
2011-07-27 05:48:26 +08:00
diag::err_arc_objc_property_default_assign_on_object);
Diag(property->getLocation(), diag::note_property_declare);
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
} else {
Qualifiers::ObjCLifetime lifetime =
getImpliedARCOwnership(kind, PropertyIvarType);
assert(lifetime && "no lifetime for property?");
objc-arc: diagnose synthesis of a 'weak unavailable' property. // rdar://10535245 llvm-svn: 146272
2011-12-10 03:55:11 +08:00
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Qualifiers qs;
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
qs.addObjCLifetime(lifetime);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
PropertyIvarType = Context.getQualifiedType(PropertyIvarType, qs);
}
}
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
Ivar = ObjCIvarDecl::Create(Context, ClassImpDecl,
[AST] When we @synthesize a property with a user-defined ivar name, make sure to record the source location of the ivar name. [libclang] When indexing @synthesized objc methods, report the @implementation as the lexical container. Fixes rdar://10905472 llvm-svn: 151635
2012-02-29 01:50:39 +08:00
PropertyIvarLoc,PropertyIvarLoc, PropertyIvar,
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
PropertyIvarType, /*Dinfo=*/nullptr,
ivars craeted for explicit @synthesize and those created for auto-synthesis are @private. Fixes: // rdar://8769582 llvm-svn: 121913
2010-12-16 07:29:04 +08:00
ObjCIvarDecl::Private,
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
(Expr *)nullptr, true);
Objective-C: diagnose when synthesizing an ivar of abstract class type. // rdar://14261999 llvm-svn: 185710
2013-07-06 01:18:11 +08:00
if (RequireNonAbstractType(PropertyIvarLoc,
PropertyIvarType,
diag::err_abstract_type_in_decl,
AbstractSynthesizedIvarType)) {
Diag(property->getLocation(), diag::note_property_declare);
Move checks for creation of objects of abstract class type from the various constructs that can do so into the initialization code. This fixes a number of different cases in which we used to fail to check for abstract types. Thanks to Tim Shen for inspiring the weird code that uncovered this! llvm-svn: 289753
2016-12-15 10:28:18 +08:00
// An abstract type is as bad as an incomplete type.
CompleteTypeErr = true;
}
[Sema] Add support for flexible array members in Obj-C. Allow Obj-C ivars with incomplete array type but only as the last ivar. Also add a requirement for ivars that contain a flexible array member to be at the end of class too. It is possible to add in a subclass another ivar at the end but we'll emit a warning in this case. Also we'll emit a warning if a variable sized ivar is declared in class extension or in implementation because subclasses won't know they should avoid adding new ivars. In ARC incomplete array objects are treated as __unsafe_unretained so require them to be marked as such. Prohibit synthesizing ivars with flexible array members because order of synthesized ivars is not obvious and tricky to control. Spelling out ivar explicitly gives control to developers and helps to avoid surprises with unexpected ivar ordering. For C and C++ changed diagnostic to tell explicitly a field is not the last one and point to the next field. It is not as useful as in Obj-C but it is an improvement and it is consistent with Obj-C. For C for unions emit more specific err_flexible_array_union instead of generic err_field_incomplete. rdar://problem/21054495 Reviewers: rjmccall, theraven Reviewed By: rjmccall Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D38773 llvm-svn: 316381
2017-10-24 06:01:41 +08:00
if (!CompleteTypeErr) {
const RecordType *RecordTy = PropertyIvarType->getAs<RecordType>();
if (RecordTy && RecordTy->getDecl()->hasFlexibleArrayMember()) {
Diag(PropertyIvarLoc, diag::err_synthesize_variable_sized_ivar)
<< PropertyIvarType;
CompleteTypeErr = true; // suppress later diagnostics about the ivar
}
}
Move checks for creation of objects of abstract class type from the various constructs that can do so into the initialization code. This fixes a number of different cases in which we used to fail to check for abstract types. Thanks to Tim Shen for inspiring the weird code that uncovered this! llvm-svn: 289753
2016-12-15 10:28:18 +08:00
if (CompleteTypeErr)
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
Ivar->setInvalidDecl();
Sema/Obj-C: Narrow type, and simplify. llvm-svn: 100210
2010-04-03 03:44:54 +08:00
ClassImpDecl->addDecl(Ivar);
Fix PR10447: lazily building name lookup tables for DeclContexts was broken. The deferred lookup table building step couldn't accurately tell which Decls should be included in the lookup table, and consequently built different tables in some cases. Fix this by removing lazy building of DeclContext name lookup tables. In practice, the laziness was frequently not worthwhile in C++, because we performed lookup into most DeclContexts. In C, it had a bit more value, since there is no qualified lookup. In the place of lazy lookup table building, we simply don't build lookup tables for function DeclContexts at all. Such name lookup tables are not useful, since they don't capture the scoping information required to correctly perform name lookup in a function scope. The resulting performance delta is within the noise on my testing, but appears to be a very slight win for C++ and a very slight loss for C. The C performance can probably be recovered (if it is a measurable problem) by avoiding building the lookup table for the translation unit. llvm-svn: 152608
2012-03-13 11:12:56 +08:00
IDecl->makeDeclVisibleInContext(Ivar);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Restructure how the driver communicates information about the target Objective-C runtime down to the frontend: break this down into a single target runtime kind and version, and compute all the relevant information from that. This makes it relatively painless to add support for new runtimes to the compiler. Make the new -cc1 flag, -fobjc-runtime=blah-x.y.z, available at the driver level as a better and more general alternative to -fgnu-runtime and -fnext-runtime. This new concept of an Objective-C runtime also encompasses what we were previously separating out as the "Objective-C ABI", so fragile vs. non-fragile runtimes are now really modelled as different kinds of runtime, paving the way for better overall differentiation. As a sort of special case, continue to accept the -cc1 flag -fobjc-runtime-has-weak, as a sop to PLCompatibilityWeak. I won't go so far as to say "no functionality change", even ignoring the new driver flag, but subtle changes in driver semantics are almost certainly not intended. llvm-svn: 158793
2012-06-20 14:18:46 +08:00
if (getLangOpts().ObjCRuntime.isFragile())
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyDiagLoc, diag::err_missing_property_ivar_decl)
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
<< PropertyId;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Note! I deliberately want it to fall thru so, we have a
// a property implementation and to avoid future warnings.
Restructure how the driver communicates information about the target Objective-C runtime down to the frontend: break this down into a single target runtime kind and version, and compute all the relevant information from that. This makes it relatively painless to add support for new runtimes to the compiler. Make the new -cc1 flag, -fobjc-runtime=blah-x.y.z, available at the driver level as a better and more general alternative to -fgnu-runtime and -fnext-runtime. This new concept of an Objective-C runtime also encompasses what we were previously separating out as the "Objective-C ABI", so fragile vs. non-fragile runtimes are now really modelled as different kinds of runtime, paving the way for better overall differentiation. As a sort of special case, continue to accept the -cc1 flag -fobjc-runtime-has-weak, as a sop to PLCompatibilityWeak. I won't go so far as to say "no functionality change", even ignoring the new driver flag, but subtle changes in driver semantics are almost certainly not intended. llvm-svn: 158793
2012-06-20 14:18:46 +08:00
} else if (getLangOpts().ObjCRuntime.isNonFragile() &&
Replace all comparisons between ObjCInterfaceDecl pointers with calls to declaresSameEntity(), as a baby step toward tracking forward declarations of Objective-C classes precisely. Part of <rdar://problem/10583531>. llvm-svn: 146618
2011-12-15 08:29:59 +08:00
!declaresSameEntity(ClassDeclared, IDecl)) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyDiagLoc, diag::err_ivar_in_superclass_use)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
<< property->getDeclName() << Ivar->getDeclName()
<< ClassDeclared->getDeclName();
Diag(Ivar->getLocation(), diag::note_previous_access_declaration)
StringRef'ication of lots stuff, patch by Peter Davies! llvm-svn: 111314
2010-08-18 06:39:59 +08:00
<< Ivar << Ivar->getName();
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Note! I deliberately want it to fall thru so more errors are caught.
}
[analyzer] Add experimental ObjC invalidation method checker. This checker is annotation driven. It checks that the annotated invalidation method accesses all ivars of the enclosing objects that are objects of type, which in turn contains an invalidation method. This is driven by __attribute((annotation("objc_instance_variable_invalidator")). llvm-svn: 164716
2012-09-27 02:55:16 +08:00
property->setPropertyIvarDecl(Ivar);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
QualType IvarType = Context.getCanonicalType(Ivar->getType());
// Check that type of property and its ivar are type compatible.
objc: avoid duplicate diagnostics on certain type mismatches between property and its backing ivar. llvm-svn: 156832
2012-05-16 02:12:51 +08:00
if (!Context.hasSameType(PropertyIvarType, IvarType)) {
Implements property of reference types. Adding an executable test to llvm test suite. // rdar://9070460. llvm-svn: 128435
2011-03-29 07:47:18 +08:00
if (isa<ObjCObjectPointerType>(PropertyIvarType)
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
&& isa<ObjCObjectPointerType>(IvarType))
Fix some dead stores which the static analyzer warned about. No functionality change (the problematic cases in ParseDecl.cpp are currently impossible). llvm-svn: 163920
2012-09-15 02:27:01 +08:00
compat =
Misc. fixes to bring Objetive-C++'s handling of gc attributes to be inline with Objective-C (for radar 7925141). llvm-svn: 104084
2010-05-19 07:04:17 +08:00
Context.canAssignObjCInterfaces(
Implements property of reference types. Adding an executable test to llvm test suite. // rdar://9070460. llvm-svn: 128435
2011-03-29 07:47:18 +08:00
PropertyIvarType->getAs<ObjCObjectPointerType>(),
Misc. fixes to bring Objetive-C++'s handling of gc attributes to be inline with Objective-C (for radar 7925141). llvm-svn: 104084
2010-05-19 07:04:17 +08:00
IvarType->getAs<ObjCObjectPointerType>());
Give OpaqueValueExpr a source location, because its source location might be queried in places where we absolutely require a valid location (e.g., for template instantiation). Fixes some major brokenness in the use of __is_convertible_to. llvm-svn: 124465
2011-01-28 10:26:04 +08:00
else {
[AST] When we @synthesize a property with a user-defined ivar name, make sure to record the source location of the ivar name. [libclang] When indexing @synthesized objc methods, report the @implementation as the lexical container. Fixes rdar://10905472 llvm-svn: 151635
2012-02-29 01:50:39 +08:00
compat = (CheckAssignmentConstraints(PropertyIvarLoc, PropertyIvarType,
IvarType)
Assorted work leading towards the elimination of CK_Unknown. llvm-svn: 119138
2010-11-15 17:13:47 +08:00
== Compatible);
Give OpaqueValueExpr a source location, because its source location might be queried in places where we absolutely require a valid location (e.g., for template instantiation). Fixes some major brokenness in the use of __is_convertible_to. llvm-svn: 124465
2011-01-28 10:26:04 +08:00
}
Misc. fixes to bring Objetive-C++'s handling of gc attributes to be inline with Objective-C (for radar 7925141). llvm-svn: 104084
2010-05-19 07:04:17 +08:00
if (!compat) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyDiagLoc, diag::err_property_ivar_type)
Improve diagnostic for @property/ivar type mismatch by including the types of the ivar and @property respectively. llvm-svn: 99312
2010-03-24 03:02:22 +08:00
<< property->getDeclName() << PropType
<< Ivar->getDeclName() << IvarType;
Diag(Ivar->getLocation(), diag::note_ivar_decl);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Note! I deliberately want it to fall thru so, we have a
// a property implementation and to avoid future warnings.
}
objc: avoid duplicate diagnostics on certain type mismatches between property and its backing ivar. llvm-svn: 156832
2012-05-16 02:12:51 +08:00
else {
// FIXME! Rules for properties are somewhat different that those
// for assignments. Use a new routine to consolidate all cases;
// specifically for property redeclarations as well as for ivars.
QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType();
QualType rhsType =Context.getCanonicalType(IvarType).getUnqualifiedType();
if (lhsType != rhsType &&
lhsType->isArithmeticType()) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyDiagLoc, diag::err_property_ivar_type)
objc: avoid duplicate diagnostics on certain type mismatches between property and its backing ivar. llvm-svn: 156832
2012-05-16 02:12:51 +08:00
<< property->getDeclName() << PropType
<< Ivar->getDeclName() << IvarType;
Diag(Ivar->getLocation(), diag::note_ivar_decl);
// Fall thru - see previous comment
}
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
// __weak is explicit. So it works on Canonical type.
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
if ((PropType.isObjCGCWeak() && !IvarType.isObjCGCWeak() &&
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
getLangOpts().getGC() != LangOptions::NonGC)) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyDiagLoc, diag::err_weak_property)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
<< property->getDeclName() << Ivar->getDeclName();
objc-gc: More sema work for properties declared 'weak' in GC mode. // rdar://10073896 llvm-svn: 139235
2011-09-08 00:24:21 +08:00
Diag(Ivar->getLocation(), diag::note_ivar_decl);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Fall thru - see previous comment
}
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
// Fall thru - see previous comment
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
if ((property->getType()->isObjCObjectPointerType() ||
PropType.isObjCGCStrong()) && IvarType.isObjCGCWeak() &&
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
getLangOpts().getGC() != LangOptions::NonGC) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyDiagLoc, diag::err_strong_property)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
<< property->getDeclName() << Ivar->getDeclName();
// Fall thru - see previous comment
}
}
Define weak and __weak to mean ARC-style weak references, even in MRC. Previously, __weak was silently accepted and ignored in MRC mode. That makes this a potentially source-breaking change that we have to roll out cautiously. Accordingly, for the time being, actual support for __weak references in MRC is experimental, and the compiler will reject attempts to actually form such references. The intent is to eventually enable the feature by default in all non-GC modes. (It is, of course, incompatible with ObjC GC's interpretation of __weak.) If you like, you can enable this feature with -Xclang -fobjc-weak but like any -Xclang option, this option may be removed at any point, e.g. if/when it is eventually enabled by default. This patch also enables the use of the ARC __unsafe_unretained qualifier in MRC. Unlike __weak, this is being enabled immediately. Since variables are essentially __unsafe_unretained by default in MRC, the only practical uses are (1) communication and (2) changing the default behavior of by-value block capture. As an implementation matter, this means that the ObjC ownership qualifiers may appear in any ObjC language mode, and so this patch removes a number of checks for getLangOpts().ObjCAutoRefCount that were guarding the processing of these qualifiers. I don't expect this to be a significant drain on performance; it may even be faster to just check for these qualifiers directly on a type (since it's probably in a register anyway) than to do N dependent loads to grab the LangOptions. rdar://9674298 llvm-svn: 251041
2015-10-23 02:38:17 +08:00
if (getLangOpts().ObjCAutoRefCount || isARCWeak ||
Ivar->getType().getObjCLifetime())
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
checkARCPropertyImpl(*this, PropertyLoc, property, Ivar);
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
} else if (PropertyIvar)
// @dynamic
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyDiagLoc, diag::err_dynamic_property_ivar_decl);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
assert (property && "ActOnPropertyImplDecl - property declaration missing");
ObjCPropertyImplDecl *PIDecl =
ObjCPropertyImplDecl::Create(Context, CurContext, AtLoc, PropertyLoc,
property,
(Synthesize ?
ObjCPropertyImplDecl::Synthesize
: ObjCPropertyImplDecl::Dynamic),
For an Objective-C @synthesize statement, e.g., @synthesize foo = _foo; keep track of the location of the ivar ("_foo"). Teach libclang to visit the ivar as a member reference. llvm-svn: 119447
2010-11-17 09:03:52 +08:00
Ivar, PropertyIvarLoc);
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
objc: avoid duplicate diagnostics on certain type mismatches between property and its backing ivar. llvm-svn: 156832
2012-05-16 02:12:51 +08:00
if (CompleteTypeErr || !compat)
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
PIDecl->setInvalidDecl();
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
if (ObjCMethodDecl *getterMethod = property->getGetterMethodDecl()) {
getterMethod->createImplicitParams(Context, IDecl);
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr &&
Check for ivar being a C++ object before attempting to find a copy constructor/assignment operator used in getter/setter synthesis. This removes an unintended diagnostics and makes objc++ consistant with objective-c. // rdar: //8550657. llvm-svn: 116631
2010-10-16 06:42:59 +08:00
Ivar->getType()->isRecordType()) {
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
// For Objective-C++, need to synthesize the AST for the IVAR object to be
// returned by the getter as it must conform to C++'s copy-return rules.
// FIXME. Eventually we want to do this for Objective-C as well.
Fix Objective-C implicit property synthesis for C++ classes so we use valid source locations in places where it is necessary for diagnostics. By itself, this causes assertions, so while I'm here, also fix property synthesis for properties of C++ class type so we use so we properly set up a scope and mark variable declarations. <rdar://problem/12514189>. llvm-svn: 166219
2012-10-19 04:14:08 +08:00
SynthesizedFunctionScope Scope(*this, getterMethod);
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
ImplicitParamDecl *SelfDecl = getterMethod->getSelfDecl();
DeclRefExpr *SelfExpr =
Remove BlockDeclRefExpr and introduce a bit on DeclRefExpr to track whether the referenced declaration comes from an enclosing local context. I'm amenable to suggestions about the exact meaning of this bit. llvm-svn: 152491
2012-03-10 17:33:50 +08:00
new (Context) DeclRefExpr(SelfDecl, false, SelfDecl->getType(),
Use a proper lvalue-to-rvalue conversion in Objective-C++ property accessors. Previously, the synthesized AST contained an rvalue DeclRefExpr for 'self'. Now, it has an lvalue DeclRefExpr wrapped in an lvalue-to-rvalue ImplicitCastExpr, which is what's generated when an ivar access is written in the source. No (intended) functionality change. llvm-svn: 199225
2014-01-15 01:29:00 +08:00
VK_LValue, PropertyDiagLoc);
Fix Objective-C implicit property synthesis for C++ classes so we use valid source locations in places where it is necessary for diagnostics. By itself, this causes assertions, so while I'm here, also fix property synthesis for properties of C++ class type so we use so we properly set up a scope and mark variable declarations. <rdar://problem/12514189>. llvm-svn: 166219
2012-10-19 04:14:08 +08:00
MarkDeclRefReferenced(SelfExpr);
Use a proper lvalue-to-rvalue conversion in Objective-C++ property accessors. Previously, the synthesized AST contained an rvalue DeclRefExpr for 'self'. Now, it has an lvalue DeclRefExpr wrapped in an lvalue-to-rvalue ImplicitCastExpr, which is what's generated when an ivar access is written in the source. No (intended) functionality change. llvm-svn: 199225
2014-01-15 01:29:00 +08:00
Expr *LoadSelfExpr =
ImplicitCastExpr::Create(Context, SelfDecl->getType(),
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
CK_LValueToRValue, SelfExpr, nullptr,
VK_RValue);
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
Expr *IvarRefExpr =
Substitute type arguments into uses of Objective-C interface members. When messaging a method that was defined in an Objective-C class (or category or extension thereof) that has type parameters, substitute the type arguments for those type parameters. Similarly, substitute into property accesses, instance variables, and other references. This includes general infrastructure for substituting the type arguments associated with an ObjCObject(Pointer)Type into a type referenced within a particular context, handling all of the substitutions required to deal with (e.g.) inheritance involving parameterized classes. In cases where no type arguments are available (e.g., because we're messaging via some unspecialized type, id, etc.), we substitute in the type bounds for the type parameters instead. Example: @interface NSSet<T : id<NSCopying>> : NSObject <NSCopying> - (T)firstObject; @end void f(NSSet<NSString *> *stringSet, NSSet *anySet) { [stringSet firstObject]; // produces NSString* [anySet firstObject]; // produces id<NSCopying> (the bound) } When substituting for the type parameters given an unspecialized context (i.e., no specific type arguments were given), substituting the type bounds unconditionally produces type signatures that are too strong compared to the pre-generics signatures. Instead, use the following rule: - In covariant positions, such as method return types, replace type parameters with “id” or “Class” (the latter only when the type parameter bound is “Class” or qualified class, e.g, “Class<NSCopying>”) - In other positions (e.g., parameter types), replace type parameters with their type bounds. - When a specialized Objective-C object or object pointer type contains a type parameter in its type arguments (e.g., NSArray<T>*, but not NSArray<NSString *> *), replace the entire object/object pointer type with its unspecialized version (e.g., NSArray *). llvm-svn: 241543
2015-07-07 11:57:53 +08:00
new (Context) ObjCIvarRefExpr(Ivar,
Ivar->getUsageType(SelfDecl->getType()),
PropertyDiagLoc,
Objective-C: Provide fixit hints when warning about 'isa' ivar being explicitely accessed when base is a user class object reference. // rdar://13503456 llvm-svn: 178562
2013-04-03 02:57:54 +08:00
Ivar->getLocation(),
Use a proper lvalue-to-rvalue conversion in Objective-C++ property accessors. Previously, the synthesized AST contained an rvalue DeclRefExpr for 'self'. Now, it has an lvalue DeclRefExpr wrapped in an lvalue-to-rvalue ImplicitCastExpr, which is what's generated when an ivar access is written in the source. No (intended) functionality change. llvm-svn: 199225
2014-01-15 01:29:00 +08:00
LoadSelfExpr, true, true);
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
ExprResult Res = PerformCopyInitialization(
InitializedEntity::InitializeResult(PropertyDiagLoc,
getterMethod->getReturnType(),
/*NRVO=*/false),
Refactoring. Remove Owned method from Sema. llvm-svn: 209812
2014-05-29 22:05:12 +08:00
PropertyDiagLoc, IvarRefExpr);
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
if (!Res.isInvalid()) {
Refactoring. Remove release and take methods from ActionResult. Rename takeAs to getAs. llvm-svn: 209800
2014-05-29 18:55:11 +08:00
Expr *ResExpr = Res.getAs<Expr>();
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
if (ResExpr)
Rename CXXExprWithTemporaries -> ExprWithCleanups; there's no theoretical reason this is limited to C++, and it's certainly not limited to temporaries. llvm-svn: 120996
2010-12-06 16:20:24 +08:00
ResExpr = MaybeCreateExprWithCleanups(ResExpr);
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
PIDecl->setGetterCXXConstructor(ResExpr);
}
}
objc-arc/mrc: Allow ns_returns_not_retained attribute on properties to turn off warning on those properties which follow Cocoa naming convention for retaining objects and yet they were not meant for such purposes. Also, perform consistancy checking for declared getters of such methods. // rdar://9636091 llvm-svn: 133849
2011-06-25 08:17:46 +08:00
if (property->hasAttr<NSReturnsNotRetainedAttr>() &&
!getterMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
Diag(getterMethod->getLocation(),
diag::warn_property_getter_owning_mismatch);
Diag(property->getLocation(), diag::note_property_declare);
}
Objective-C arc: Diagnose when user attempts to synthesize a property getter method that overrides a method definition named 'retain' and the like. Fixes // rdar://13885083 llvm-svn: 182039
2013-05-17 03:08:44 +08:00
if (getLangOpts().ObjCAutoRefCount && Synthesize)
switch (getterMethod->getMethodFamily()) {
case OMF_retain:
case OMF_retainCount:
case OMF_release:
case OMF_autorelease:
Diag(getterMethod->getLocation(), diag::err_arc_illegal_method_def)
<< 1 << getterMethod->getSelector();
break;
default:
break;
}
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
}
if (ObjCMethodDecl *setterMethod = property->getSetterMethodDecl()) {
setterMethod->createImplicitParams(Context, IDecl);
Add a missing RequireCompleteType call when synthesizing properties. <rdar://problem/11333367>. While I'm here, fix source locations for other diagnostics related to property synthesis. llvm-svn: 155953
2012-05-02 06:26:06 +08:00
if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr &&
Ivar->getType()->isRecordType()) {
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
// FIXME. Eventually we want to do this for Objective-C as well.
Fix Objective-C implicit property synthesis for C++ classes so we use valid source locations in places where it is necessary for diagnostics. By itself, this causes assertions, so while I'm here, also fix property synthesis for properties of C++ class type so we use so we properly set up a scope and mark variable declarations. <rdar://problem/12514189>. llvm-svn: 166219
2012-10-19 04:14:08 +08:00
SynthesizedFunctionScope Scope(*this, setterMethod);
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
ImplicitParamDecl *SelfDecl = setterMethod->getSelfDecl();
DeclRefExpr *SelfExpr =
Remove BlockDeclRefExpr and introduce a bit on DeclRefExpr to track whether the referenced declaration comes from an enclosing local context. I'm amenable to suggestions about the exact meaning of this bit. llvm-svn: 152491
2012-03-10 17:33:50 +08:00
new (Context) DeclRefExpr(SelfDecl, false, SelfDecl->getType(),
Use a proper lvalue-to-rvalue conversion in Objective-C++ property accessors. Previously, the synthesized AST contained an rvalue DeclRefExpr for 'self'. Now, it has an lvalue DeclRefExpr wrapped in an lvalue-to-rvalue ImplicitCastExpr, which is what's generated when an ivar access is written in the source. No (intended) functionality change. llvm-svn: 199225
2014-01-15 01:29:00 +08:00
VK_LValue, PropertyDiagLoc);
Fix Objective-C implicit property synthesis for C++ classes so we use valid source locations in places where it is necessary for diagnostics. By itself, this causes assertions, so while I'm here, also fix property synthesis for properties of C++ class type so we use so we properly set up a scope and mark variable declarations. <rdar://problem/12514189>. llvm-svn: 166219
2012-10-19 04:14:08 +08:00
MarkDeclRefReferenced(SelfExpr);
Use a proper lvalue-to-rvalue conversion in Objective-C++ property accessors. Previously, the synthesized AST contained an rvalue DeclRefExpr for 'self'. Now, it has an lvalue DeclRefExpr wrapped in an lvalue-to-rvalue ImplicitCastExpr, which is what's generated when an ivar access is written in the source. No (intended) functionality change. llvm-svn: 199225
2014-01-15 01:29:00 +08:00
Expr *LoadSelfExpr =
ImplicitCastExpr::Create(Context, SelfDecl->getType(),
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
CK_LValueToRValue, SelfExpr, nullptr,
VK_RValue);
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
Expr *lhs =
Substitute type arguments into uses of Objective-C interface members. When messaging a method that was defined in an Objective-C class (or category or extension thereof) that has type parameters, substitute the type arguments for those type parameters. Similarly, substitute into property accesses, instance variables, and other references. This includes general infrastructure for substituting the type arguments associated with an ObjCObject(Pointer)Type into a type referenced within a particular context, handling all of the substitutions required to deal with (e.g.) inheritance involving parameterized classes. In cases where no type arguments are available (e.g., because we're messaging via some unspecialized type, id, etc.), we substitute in the type bounds for the type parameters instead. Example: @interface NSSet<T : id<NSCopying>> : NSObject <NSCopying> - (T)firstObject; @end void f(NSSet<NSString *> *stringSet, NSSet *anySet) { [stringSet firstObject]; // produces NSString* [anySet firstObject]; // produces id<NSCopying> (the bound) } When substituting for the type parameters given an unspecialized context (i.e., no specific type arguments were given), substituting the type bounds unconditionally produces type signatures that are too strong compared to the pre-generics signatures. Instead, use the following rule: - In covariant positions, such as method return types, replace type parameters with “id” or “Class” (the latter only when the type parameter bound is “Class” or qualified class, e.g, “Class<NSCopying>”) - In other positions (e.g., parameter types), replace type parameters with their type bounds. - When a specialized Objective-C object or object pointer type contains a type parameter in its type arguments (e.g., NSArray<T>*, but not NSArray<NSString *> *), replace the entire object/object pointer type with its unspecialized version (e.g., NSArray *). llvm-svn: 241543
2015-07-07 11:57:53 +08:00
new (Context) ObjCIvarRefExpr(Ivar,
Ivar->getUsageType(SelfDecl->getType()),
PropertyDiagLoc,
Objective-C: Provide fixit hints when warning about 'isa' ivar being explicitely accessed when base is a user class object reference. // rdar://13503456 llvm-svn: 178562
2013-04-03 02:57:54 +08:00
Ivar->getLocation(),
Use a proper lvalue-to-rvalue conversion in Objective-C++ property accessors. Previously, the synthesized AST contained an rvalue DeclRefExpr for 'self'. Now, it has an lvalue DeclRefExpr wrapped in an lvalue-to-rvalue ImplicitCastExpr, which is what's generated when an ivar access is written in the source. No (intended) functionality change. llvm-svn: 199225
2014-01-15 01:29:00 +08:00
LoadSelfExpr, true, true);
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
ObjCMethodDecl::param_iterator P = setterMethod->param_begin();
ParmVarDecl *Param = (*P);
Restore r142914 and r142915, now with missing file and apparent GCC compiler workaround. llvm-svn: 142931
2011-10-26 01:37:35 +08:00
QualType T = Param->getType().getNonReferenceType();
Fix Objective-C implicit property synthesis for C++ classes so we use valid source locations in places where it is necessary for diagnostics. By itself, this causes assertions, so while I'm here, also fix property synthesis for properties of C++ class type so we use so we properly set up a scope and mark variable declarations. <rdar://problem/12514189>. llvm-svn: 166219
2012-10-19 04:14:08 +08:00
DeclRefExpr *rhs = new (Context) DeclRefExpr(Param, false, T,
VK_LValue, PropertyDiagLoc);
MarkDeclRefReferenced(rhs);
ExprResult Res = BuildBinOp(S, PropertyDiagLoc,
GCC didn't care for my attempt at API compatibility, so brute-force everything to the new constants. llvm-svn: 112047
2010-08-25 19:45:40 +08:00
BO_Assign, lhs, rhs);
objc++: For atomic properties of c++ class objec typet, appropriate operator= is called. Issue a warning for non-trivial case until runtime support is provided. // rdar://6137845 llvm-svn: 141302
2011-10-07 02:38:18 +08:00
if (property->getPropertyAttributes() &
ObjCPropertyDecl::OBJC_PR_atomic) {
Refactoring. Remove release and take methods from ActionResult. Rename takeAs to getAs. llvm-svn: 209800
2014-05-29 18:55:11 +08:00
Expr *callExpr = Res.getAs<Expr>();
objc++: For atomic properties of c++ class objec typet, appropriate operator= is called. Issue a warning for non-trivial case until runtime support is provided. // rdar://6137845 llvm-svn: 141302
2011-10-07 02:38:18 +08:00
if (const CXXOperatorCallExpr *CXXCE =
objc++: some minor cleanup and a test case for atomic setters which requires assignment operator. llvm-svn: 141415
2011-10-08 05:08:14 +08:00
dyn_cast_or_null<CXXOperatorCallExpr>(callExpr))
if (const FunctionDecl *FuncDecl = CXXCE->getDirectCallee())
objc++: For atomic properties of c++ class objec typet, appropriate operator= is called. Issue a warning for non-trivial case until runtime support is provided. // rdar://6137845 llvm-svn: 141302
2011-10-07 02:38:18 +08:00
if (!FuncDecl->isTrivial())
objc++: patch for IRgen for atomic properties of c++ objects with non-trivial assignment/copy functions. Also, one additional sema check. // rdar://6137845 llvm-svn: 147817
2012-01-10 08:37:01 +08:00
if (property->getType()->isReferenceType()) {
Fix Objective-C implicit property synthesis for C++ classes so we use valid source locations in places where it is necessary for diagnostics. By itself, this causes assertions, so while I'm here, also fix property synthesis for properties of C++ class type so we use so we properly set up a scope and mark variable declarations. <rdar://problem/12514189>. llvm-svn: 166219
2012-10-19 04:14:08 +08:00
Diag(PropertyDiagLoc,
objc++: patch for IRgen for atomic properties of c++ objects with non-trivial assignment/copy functions. Also, one additional sema check. // rdar://6137845 llvm-svn: 147817
2012-01-10 08:37:01 +08:00
diag::err_atomic_property_nontrivial_assign_op)
objc++: For atomic properties of c++ class objec typet, appropriate operator= is called. Issue a warning for non-trivial case until runtime support is provided. // rdar://6137845 llvm-svn: 141302
2011-10-07 02:38:18 +08:00
<< property->getType();
objc++: patch for IRgen for atomic properties of c++ objects with non-trivial assignment/copy functions. Also, one additional sema check. // rdar://6137845 llvm-svn: 147817
2012-01-10 08:37:01 +08:00
Diag(FuncDecl->getLocStart(),
diag::note_callee_decl) << FuncDecl;
}
objc++: For atomic properties of c++ class objec typet, appropriate operator= is called. Issue a warning for non-trivial case until runtime support is provided. // rdar://6137845 llvm-svn: 141302
2011-10-07 02:38:18 +08:00
}
Refactoring. Remove release and take methods from ActionResult. Rename takeAs to getAs. llvm-svn: 209800
2014-05-29 18:55:11 +08:00
PIDecl->setSetterCXXAssignment(Res.getAs<Expr>());
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
}
}
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
if (IC) {
if (Synthesize)
if (ObjCPropertyImplDecl *PPIDecl =
IC->FindPropertyImplIvarDecl(PropertyIvar)) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyLoc, diag::err_duplicate_ivar_use)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
<< PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
<< PropertyIvar;
Diag(PPIDecl->getLocation(), diag::note_previous_use);
}
if (ObjCPropertyImplDecl *PPIDecl
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
= IC->FindPropertyImplDecl(PropertyId, QueryKind)) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyLoc, diag::err_property_implemented) << PropertyId;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
IC->addPropertyImplementation(PIDecl);
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().ObjCDefaultSynthProperties &&
Restructure how the driver communicates information about the target Objective-C runtime down to the frontend: break this down into a single target runtime kind and version, and compute all the relevant information from that. This makes it relatively painless to add support for new runtimes to the compiler. Make the new -cc1 flag, -fobjc-runtime=blah-x.y.z, available at the driver level as a better and more general alternative to -fgnu-runtime and -fnext-runtime. This new concept of an Objective-C runtime also encompasses what we were previously separating out as the "Objective-C ABI", so fragile vs. non-fragile runtimes are now really modelled as different kinds of runtime, paving the way for better overall differentiation. As a sort of special case, continue to accept the -cc1 flag -fobjc-runtime-has-weak, as a sop to PLCompatibilityWeak. I won't go so far as to say "no functionality change", even ignoring the new driver flag, but subtle changes in driver semantics are almost certainly not intended. llvm-svn: 158793
2012-06-20 14:18:46 +08:00
getLangOpts().ObjCRuntime.isNonFragile() &&
After further discussion, rename attribute 'objc_disable_automatic_synthesis' to 'objc_requires_property_definitions'. llvm-svn: 147622
2012-01-06 06:47:47 +08:00
!IDecl->isObjCRequiresPropertyDefs()) {
Patch to synthesize property ivars on demand as part of the new property synthesis by default. wip. llvm-svn: 108599
2010-07-17 08:59:30 +08:00
// Diagnose if an ivar was lazily synthesdized due to a previous
// use and if 1) property is @dynamic or 2) property is synthesized
Fix a bug in nonfragile-abi2 when attempting to diagnose previous use of a synthesized 'ivar' with property of same name declared as @dynamic. In this case, 'ivar' is in the inherited class and no diagnostics should be issued. llvm-svn: 111940
2010-08-25 02:48:05 +08:00
// but it requires an ivar of different name.
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
ObjCInterfaceDecl *ClassDeclared=nullptr;
ObjCIvarDecl *Ivar = nullptr;
Patch to synthesize property ivars on demand as part of the new property synthesis by default. wip. llvm-svn: 108599
2010-07-17 08:59:30 +08:00
if (!Synthesize)
Ivar = IDecl->lookupInstanceVariable(PropertyId, ClassDeclared);
else {
if (PropertyIvar && PropertyIvar != PropertyId)
Ivar = IDecl->lookupInstanceVariable(PropertyId, ClassDeclared);
}
Fix a bug in nonfragile-abi2 when attempting to diagnose previous use of a synthesized 'ivar' with property of same name declared as @dynamic. In this case, 'ivar' is in the inherited class and no diagnostics should be issued. llvm-svn: 111940
2010-08-25 02:48:05 +08:00
// Issue diagnostics only if Ivar belongs to current class.
if (Ivar && Ivar->getSynthesize() &&
Replace all comparisons between ObjCInterfaceDecl pointers with calls to declaresSameEntity(), as a baby step toward tracking forward declarations of Objective-C classes precisely. Part of <rdar://problem/10583531>. llvm-svn: 146618
2011-12-15 08:29:59 +08:00
declaresSameEntity(IC->getClassInterface(), ClassDeclared)) {
Patch to synthesize property ivars on demand as part of the new property synthesis by default. wip. llvm-svn: 108599
2010-07-17 08:59:30 +08:00
Diag(Ivar->getLocation(), diag::err_undeclared_var_use)
<< PropertyId;
Ivar->setInvalidDecl();
}
}
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
} else {
if (Synthesize)
if (ObjCPropertyImplDecl *PPIDecl =
CatImplClass->FindPropertyImplIvarDecl(PropertyIvar)) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyDiagLoc, diag::err_duplicate_ivar_use)
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
<< PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
<< PropertyIvar;
Diag(PPIDecl->getLocation(), diag::note_previous_use);
}
if (ObjCPropertyImplDecl *PPIDecl =
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
CatImplClass->FindPropertyImplDecl(PropertyId, QueryKind)) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(PropertyDiagLoc, diag::err_property_implemented) << PropertyId;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
return nullptr;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
CatImplClass->addPropertyImplementation(PIDecl);
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return PIDecl;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
//===----------------------------------------------------------------------===//
// Helper methods.
//===----------------------------------------------------------------------===//
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
/// DiagnosePropertyMismatch - Compares two properties for their
/// attributes and types and warns on a variety of inconsistencies.
///
void
Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
ObjCPropertyDecl *SuperProperty,
ObjectiveC. Allow readonly properties without an explicit ownership (assign/unsafe_unretained/weak/retain/strong/copy) in super class to be overridden by a property with any explicit ownership in the subclass. // rdar://15014468 llvm-svn: 191971
2013-10-05 02:06:08 +08:00
const IdentifierInfo *inheritedName,
bool OverridingProtocolProperty) {
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
ObjCPropertyDecl::PropertyAttributeKind CAttr =
ObjectiveC. Allow readonly properties without an explicit ownership (assign/unsafe_unretained/weak/retain/strong/copy) in super class to be overridden by a property with any explicit ownership in the subclass. // rdar://15014468 llvm-svn: 191971
2013-10-05 02:06:08 +08:00
Property->getPropertyAttributes();
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
ObjCPropertyDecl::PropertyAttributeKind SAttr =
ObjectiveC. Allow readonly properties without an explicit ownership (assign/unsafe_unretained/weak/retain/strong/copy) in super class to be overridden by a property with any explicit ownership in the subclass. // rdar://15014468 llvm-svn: 191971
2013-10-05 02:06:08 +08:00
SuperProperty->getPropertyAttributes();
// We allow readonly properties without an explicit ownership
// (assign/unsafe_unretained/weak/retain/strong/copy) in super class
// to be overridden by a property with any explicit ownership in the subclass.
if (!OverridingProtocolProperty &&
!getOwnershipRule(SAttr) && getOwnershipRule(CAttr))
;
else {
if ((CAttr & ObjCPropertyDecl::OBJC_PR_readonly)
&& (SAttr & ObjCPropertyDecl::OBJC_PR_readwrite))
Diag(Property->getLocation(), diag::warn_readonly_property)
<< Property->getDeclName() << inheritedName;
if ((CAttr & ObjCPropertyDecl::OBJC_PR_copy)
!= (SAttr & ObjCPropertyDecl::OBJC_PR_copy))
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Property->getLocation(), diag::warn_property_attribute)
ObjectiveC. Allow readonly properties without an explicit ownership (assign/unsafe_unretained/weak/retain/strong/copy) in super class to be overridden by a property with any explicit ownership in the subclass. // rdar://15014468 llvm-svn: 191971
2013-10-05 02:06:08 +08:00
<< Property->getDeclName() << "copy" << inheritedName;
else if (!(SAttr & ObjCPropertyDecl::OBJC_PR_readonly)){
unsigned CAttrRetain =
(CAttr &
(ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
unsigned SAttrRetain =
(SAttr &
(ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
bool CStrong = (CAttrRetain != 0);
bool SStrong = (SAttrRetain != 0);
if (CStrong != SStrong)
Diag(Property->getLocation(), diag::warn_property_attribute)
<< Property->getDeclName() << "retain (or strong)" << inheritedName;
}
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Objective-C properties: loosen 'atomic' checking for readonly properties. r251874 reworked the way we handle properties declared within Objective-C class extensions, which had the effective of tightening up property checking in a number of places. In this particular class of cases, we end up complaining about "atomic" mismatches between an implicitly-atomic, readonly property and a nonatomic, readwrite property, which doesn't make sense because "atomic" is essentially irrelevant to readonly properties. Therefore, suppress this diagnostic when the readonly property is implicitly atomic. Fixes rdar://problem/23803109. llvm-svn: 255174
2015-12-10 06:57:32 +08:00
// Check for nonatomic; note that nonatomic is effectively
// meaningless for readonly properties, so don't diagnose if the
// atomic property is 'readonly'.
Objective-C properties: merge attributes when redeclaring 'readonly' as 'readwrite' in an extension. r251874 stopped back-patching the AST when an Objective-C 'readonly' property is redeclared in a class extension as 'readwrite'. However, it did not properly handle merging of Objective-C property attributes (e.g., getter name, ownership, atomicity) to the redeclaration, leading to bad metadata. Merge (and check!) those property attributes so we get the right metadata and reasonable ASTs. Fixes rdar://problem/23823989. llvm-svn: 255309
2015-12-11 07:02:09 +08:00
checkAtomicPropertyMismatch(*this, SuperProperty, Property, false);
[ObjC] Don't warn on readwrite properties with custom setters that override readonly properties from protocols rdar://34192541 llvm-svn: 315093
2017-10-07 03:24:26 +08:00
// Readonly properties from protocols can be implemented as "readwrite"
// with a custom setter name.
if (Property->getSetterName() != SuperProperty->getSetterName() &&
!(SuperProperty->isReadOnly() &&
isa<ObjCProtocolDecl>(SuperProperty->getDeclContext()))) {
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Diag(Property->getLocation(), diag::warn_property_attribute)
<< Property->getDeclName() << "setter" << inheritedName;
objective-C: Fixes a bogus warning due to not setting the "nonatomic" attribute in property redeclaration in class extension. Also, improved on diagnostics in this area while at it. // rdar://13156292 llvm-svn: 174821
2013-02-10 08:16:04 +08:00
Diag(SuperProperty->getLocation(), diag::note_property_declare);
}
if (Property->getGetterName() != SuperProperty->getGetterName()) {
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Diag(Property->getLocation(), diag::warn_property_attribute)
<< Property->getDeclName() << "getter" << inheritedName;
objective-C: Fixes a bogus warning due to not setting the "nonatomic" attribute in property redeclaration in class extension. Also, improved on diagnostics in this area while at it. // rdar://13156292 llvm-svn: 174821
2013-02-10 08:16:04 +08:00
Diag(SuperProperty->getLocation(), diag::note_property_declare);
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
QualType LHSType =
Context.getCanonicalType(SuperProperty->getType());
QualType RHSType =
Context.getCanonicalType(Property->getType());
objc++: Some level of covariance is allowed in ObjC properties. Make it also available in ObjC++ propeties. // rdar://9740328 llvm-svn: 135001
2011-07-13 06:05:16 +08:00
if (!Context.propertyTypesAreCompatible(LHSType, RHSType)) {
objc++: Some level of covariance is allowed in ObjC properties. Make it also available in ObjC++ propeties. Use common code for objc and objc++ so they don't diverge. // rdar://9740328 llvm-svn: 135050
2011-07-14 01:55:01 +08:00
// Do cases not handled in above.
// FIXME. For future support of covariant property types, revisit this.
bool IncompatibleObjC = false;
QualType ConvertedType;
if (!isObjCPointerConversion(RHSType, LHSType,
ConvertedType, IncompatibleObjC) ||
objc: note location of the previously declared property in the diagnostic. llvm-svn: 141745
2011-10-12 08:00:57 +08:00
IncompatibleObjC) {
objc++: Some level of covariance is allowed in ObjC properties. Make it also available in ObjC++ propeties. Use common code for objc and objc++ so they don't diverge. // rdar://9740328 llvm-svn: 135050
2011-07-14 01:55:01 +08:00
Diag(Property->getLocation(), diag::warn_property_types_are_incompatible)
<< Property->getType() << SuperProperty->getType() << inheritedName;
objc: note location of the previously declared property in the diagnostic. llvm-svn: 141745
2011-10-12 08:00:57 +08:00
Diag(SuperProperty->getLocation(), diag::note_property_declare);
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
}
}
bool Sema::DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *property,
ObjCMethodDecl *GetterMethod,
SourceLocation Loc) {
objective-c: perform strict type checking on property type and its accessor type and issue error if types are incompatible, instead of crashing in IRgen. // rdar://1105153 llvm-svn: 156871
2012-05-16 06:37:04 +08:00
if (!GetterMethod)
return false;
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
QualType GetterType = GetterMethod->getReturnType().getNonReferenceType();
[ObjC] Remove _Atomic from return type and parameter type of objective-c properties. This fixes an assert in CodeGen that fires when the getter and setter functions for an objective-c property of type _Atomic(_Bool) are synthesized. rdar://problem/26322972 Differential Revision: http://reviews.llvm.org/D20407 llvm-svn: 270808
2016-05-26 08:37:30 +08:00
QualType PropertyRValueType =
property->getType().getNonReferenceType().getAtomicUnqualifiedType();
bool compat = Context.hasSameType(PropertyRValueType, GetterType);
objective-c: perform strict type checking on property type and its accessor type and issue error if types are incompatible, instead of crashing in IRgen. // rdar://1105153 llvm-svn: 156871
2012-05-16 06:37:04 +08:00
if (!compat) {
Objective-C properties: fix bogus use of "isa<>" on a QualType. The code used "isa" to check the type and then "getAs" to look through sugar; we need to look through the sugar when checking, too, otherwise any kind of sugar (nullability qualifiers in the example; or a typedef) will thwart this semantic check. Fixes rdar://problem/23804250. llvm-svn: 255066
2015-12-09 06:45:17 +08:00
const ObjCObjectPointerType *propertyObjCPtr = nullptr;
const ObjCObjectPointerType *getterObjCPtr = nullptr;
[ObjC] Remove _Atomic from return type and parameter type of objective-c properties. This fixes an assert in CodeGen that fires when the getter and setter functions for an objective-c property of type _Atomic(_Bool) are synthesized. rdar://problem/26322972 Differential Revision: http://reviews.llvm.org/D20407 llvm-svn: 270808
2016-05-26 08:37:30 +08:00
if ((propertyObjCPtr =
PropertyRValueType->getAs<ObjCObjectPointerType>()) &&
Objective-C properties: fix bogus use of "isa<>" on a QualType. The code used "isa" to check the type and then "getAs" to look through sugar; we need to look through the sugar when checking, too, otherwise any kind of sugar (nullability qualifiers in the example; or a typedef) will thwart this semantic check. Fixes rdar://problem/23804250. llvm-svn: 255066
2015-12-09 06:45:17 +08:00
(getterObjCPtr = GetterType->getAs<ObjCObjectPointerType>()))
compat = Context.canAssignObjCInterfaces(getterObjCPtr, propertyObjCPtr);
[ObjC] Remove _Atomic from return type and parameter type of objective-c properties. This fixes an assert in CodeGen that fires when the getter and setter functions for an objective-c property of type _Atomic(_Bool) are synthesized. rdar://problem/26322972 Differential Revision: http://reviews.llvm.org/D20407 llvm-svn: 270808
2016-05-26 08:37:30 +08:00
else if (CheckAssignmentConstraints(Loc, GetterType, PropertyRValueType)
objective-c: perform strict type checking on property type and its accessor type and issue error if types are incompatible, instead of crashing in IRgen. // rdar://1105153 llvm-svn: 156871
2012-05-16 06:37:04 +08:00
!= Compatible) {
Mass-rename the handful of error_* diagnostics to err_*. llvm-svn: 288545
2016-12-03 06:38:31 +08:00
Diag(Loc, diag::err_property_accessor_type)
[ObjC] Remove _Atomic from return type and parameter type of objective-c properties. This fixes an assert in CodeGen that fires when the getter and setter functions for an objective-c property of type _Atomic(_Bool) are synthesized. rdar://problem/26322972 Differential Revision: http://reviews.llvm.org/D20407 llvm-svn: 270808
2016-05-26 08:37:30 +08:00
<< property->getDeclName() << PropertyRValueType
objective-c: perform strict type checking on property type and its accessor type and issue error if types are incompatible, instead of crashing in IRgen. // rdar://1105153 llvm-svn: 156871
2012-05-16 06:37:04 +08:00
<< GetterMethod->getSelector() << GetterType;
Diag(GetterMethod->getLocation(), diag::note_declared_at);
return true;
} else {
compat = true;
[ObjC] Remove _Atomic from return type and parameter type of objective-c properties. This fixes an assert in CodeGen that fires when the getter and setter functions for an objective-c property of type _Atomic(_Bool) are synthesized. rdar://problem/26322972 Differential Revision: http://reviews.llvm.org/D20407 llvm-svn: 270808
2016-05-26 08:37:30 +08:00
QualType lhsType = Context.getCanonicalType(PropertyRValueType);
objective-c: perform strict type checking on property type and its accessor type and issue error if types are incompatible, instead of crashing in IRgen. // rdar://1105153 llvm-svn: 156871
2012-05-16 06:37:04 +08:00
QualType rhsType =Context.getCanonicalType(GetterType).getUnqualifiedType();
if (lhsType != rhsType && lhsType->isArithmeticType())
compat = false;
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
}
}
objective-c: perform strict type checking on property type and its accessor type and issue error if types are incompatible, instead of crashing in IRgen. // rdar://1105153 llvm-svn: 156871
2012-05-16 06:37:04 +08:00
if (!compat) {
Diag(Loc, diag::warn_accessor_property_type_mismatch)
<< property->getDeclName()
<< GetterMethod->getSelector();
Diag(GetterMethod->getLocation(), diag::note_declared_at);
return true;
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
return false;
}
/// CollectImmediateProperties - This routine collects all properties in
Replace some unnecessary O(N^2) lookups for properties with DeclContext lookups. The performance win is negligible in my tests, but it's the Right Thing To Do (TM). llvm-svn: 173068
2013-01-22 02:35:55 +08:00
/// the class and its conforming protocols; but not those in its super class.
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
static void
CollectImmediateProperties(ObjCContainerDecl *CDecl,
ObjCContainerDecl::PropertyMap &PropMap,
ObjCContainerDecl::PropertyMap &SuperPropMap,
bool CollectClassPropsOnly = false,
bool IncludeProtocols = true) {
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
for (auto *Prop : IDecl->properties()) {
if (CollectClassPropsOnly && !Prop->isClassProperty())
continue;
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
PropMap[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] =
Prop;
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
}
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
// Collect the properties from visible extensions.
for (auto *Ext : IDecl->visible_extensions())
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
CollectImmediateProperties(Ext, PropMap, SuperPropMap,
CollectClassPropsOnly, IncludeProtocols);
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
if (IncludeProtocols) {
// Scan through class's protocols.
[C++11] Replacing ObjCInterfaceDecl iterators all_referenced_protocol_begin() and all_referenced_protocol_end() with iterator_range all_referenced_protocols(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203848
2014-03-14 04:55:22 +08:00
for (auto *PI : IDecl->all_referenced_protocols())
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
CollectImmediateProperties(PI, PropMap, SuperPropMap,
CollectClassPropsOnly);
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
}
if (ObjCCategoryDecl *CATDecl = dyn_cast<ObjCCategoryDecl>(CDecl)) {
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
for (auto *Prop : CATDecl->properties()) {
if (CollectClassPropsOnly && !Prop->isClassProperty())
continue;
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
PropMap[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] =
Prop;
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
}
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
if (IncludeProtocols) {
// Scan through class's protocols.
[C++11] Replacing ObjCCategoryDecl iterators protocol_begin() and protocol_end() with iterator_range protocols(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203922
2014-03-14 20:55:57 +08:00
for (auto *PI : CATDecl->protocols())
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
CollectImmediateProperties(PI, PropMap, SuperPropMap,
CollectClassPropsOnly);
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
}
else if (ObjCProtocolDecl *PDecl = dyn_cast<ObjCProtocolDecl>(CDecl)) {
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
for (auto *Prop : PDecl->properties()) {
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
if (CollectClassPropsOnly && !Prop->isClassProperty())
continue;
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
ObjCPropertyDecl *PropertyFromSuper =
SuperPropMap[std::make_pair(Prop->getIdentifier(),
Prop->isClassProperty())];
This patch fixes a bug whereby, clang skipped unimplemented property warning for properties coming from class's conformin protocol. It also simplifies the algorithm in the process. Fixes radar 8035776. llvm-svn: 107174
2010-06-30 02:12:32 +08:00
// Exclude property for protocols which conform to class's super-class,
// as super-class has to implement the property.
objc - don't complain about unimplemented property when conforming protocol declares the property, as well as one of its superclasses. Property will be implemented in the super class. // rdar://10120691 llvm-svn: 140586
2011-09-27 08:23:52 +08:00
if (!PropertyFromSuper ||
PropertyFromSuper->getIdentifier() != Prop->getIdentifier()) {
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
ObjCPropertyDecl *&PropEntry =
PropMap[std::make_pair(Prop->getIdentifier(),
Prop->isClassProperty())];
This patch fixes a bug whereby, clang skipped unimplemented property warning for properties coming from class's conformin protocol. It also simplifies the algorithm in the process. Fixes radar 8035776. llvm-svn: 107174
2010-06-30 02:12:32 +08:00
if (!PropEntry)
PropEntry = Prop;
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
}
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
// Scan through protocol's protocols.
[C++11] Replacing ObjCProtocolDecl iterators protocol_begin() and protocol_end() with iterator_range protocols(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203863
2014-03-14 06:58:06 +08:00
for (auto *PI : PDecl->protocols())
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
CollectImmediateProperties(PI, PropMap, SuperPropMap,
CollectClassPropsOnly);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
}
}
Implement new default property synthesis rules. Essentially, no longer user directive is needed to force a property implementation. It is decided based on those propeties which are declared in the class (or in its protocols) but not those which must be default implemented by one of its super classes. Implements radar 7923851. llvm-svn: 103787
2010-05-15 02:35:57 +08:00
/// CollectSuperClassPropertyImplementations - This routine collects list of
/// properties to be implemented in super class(s) and also coming from their
/// conforming protocols.
static void CollectSuperClassPropertyImplementations(ObjCInterfaceDecl *CDecl,
Address Jordan's review: comments, spaces. llvm-svn: 167091
2012-10-31 09:18:22 +08:00
ObjCInterfaceDecl::PropertyMap &PropMap) {
Implement new default property synthesis rules. Essentially, no longer user directive is needed to force a property implementation. It is decided based on those propeties which are declared in the class (or in its protocols) but not those which must be default implemented by one of its super classes. Implements radar 7923851. llvm-svn: 103787
2010-05-15 02:35:57 +08:00
if (ObjCInterfaceDecl *SDecl = CDecl->getSuperClass()) {
objective-C: synthesize properties in order of their declarations to synthesize their ivars in similar determinstic order so they are laid out in a determinstic order. // rdar://13192366 llvm-svn: 175214
2013-02-15 06:33:34 +08:00
ObjCInterfaceDecl::PropertyDeclOrder PO;
Implement new default property synthesis rules. Essentially, no longer user directive is needed to force a property implementation. It is decided based on those propeties which are declared in the class (or in its protocols) but not those which must be default implemented by one of its super classes. Implements radar 7923851. llvm-svn: 103787
2010-05-15 02:35:57 +08:00
while (SDecl) {
objective-C: synthesize properties in order of their declarations to synthesize their ivars in similar determinstic order so they are laid out in a determinstic order. // rdar://13192366 llvm-svn: 175214
2013-02-15 06:33:34 +08:00
SDecl->collectPropertiesToImplement(PropMap, PO);
Implement new default property synthesis rules. Essentially, no longer user directive is needed to force a property implementation. It is decided based on those propeties which are declared in the class (or in its protocols) but not those which must be default implemented by one of its super classes. Implements radar 7923851. llvm-svn: 103787
2010-05-15 02:35:57 +08:00
SDecl = SDecl->getSuperClass();
}
}
}
objective-C: When implementing custom accessor method for a property, the -Wdirect-ivar-access should not warn when accessing the property's synthesized instance variable. // rdar://13142820 llvm-svn: 175195
2013-02-15 03:07:19 +08:00
/// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is
/// an ivar synthesized for 'Method' and 'Method' is a property accessor
/// declared in class 'IFace'.
bool
Sema::IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,
ObjCMethodDecl *Method, ObjCIvarDecl *IV) {
if (!IV->getSynthesize())
return false;
ObjCMethodDecl *IMD = IFace->lookupMethod(Method->getSelector(),
Method->isInstanceMethod());
if (!IMD || !IMD->isPropertyAccessor())
return false;
// look up a property declaration whose one of its accessors is implemented
// by this method.
Use instance_properties instead of properties. NFC. All current properties are instance properties. This is the second patch in a series of patches to support class properties in addition to instance properties in objective-c. rdar://23891898 llvm-svn: 258824
2016-01-27 02:05:23 +08:00
for (const auto *Property : IFace->instance_properties()) {
[C++11] Replacing ObjCContainerDecl iterators prop_begin() and prop_end() with iterator_range props(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203830
2014-03-14 02:47:37 +08:00
if ((Property->getGetterName() == IMD->getSelector() ||
Property->getSetterName() == IMD->getSelector()) &&
(Property->getPropertyIvarDecl() == IV))
objective-C: When implementing custom accessor method for a property, the -Wdirect-ivar-access should not warn when accessing the property's synthesized instance variable. // rdar://13142820 llvm-svn: 175195
2013-02-15 03:07:19 +08:00
return true;
}
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
// Also look up property declaration in class extension whose one of its
// accessors is implemented by this method.
for (const auto *Ext : IFace->known_extensions())
Use instance_properties instead of properties. NFC. All current properties are instance properties. This is the second patch in a series of patches to support class properties in addition to instance properties in objective-c. rdar://23891898 llvm-svn: 258824
2016-01-27 02:05:23 +08:00
for (const auto *Property : Ext->instance_properties())
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
if ((Property->getGetterName() == IMD->getSelector() ||
Property->getSetterName() == IMD->getSelector()) &&
(Property->getPropertyIvarDecl() == IV))
return true;
objective-C: When implementing custom accessor method for a property, the -Wdirect-ivar-access should not warn when accessing the property's synthesized instance variable. // rdar://13142820 llvm-svn: 175195
2013-02-15 03:07:19 +08:00
return false;
}
Objective-C. Suppress the warning for auto synthesis of property not synthesizing protocol properties if class's super class implements them. // rdar://16089191 llvm-svn: 203028
2014-03-06 07:44:00 +08:00
static bool SuperClassImplementsProperty(ObjCInterfaceDecl *IDecl,
ObjCPropertyDecl *Prop) {
bool SuperClassImplementsGetter = false;
bool SuperClassImplementsSetter = false;
if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readonly)
SuperClassImplementsSetter = true;
Remove trailing whitespace introduced in r203028. llvm-svn: 203588
2014-03-12 01:17:16 +08:00
Objective-C. Suppress the warning for auto synthesis of property not synthesizing protocol properties if class's super class implements them. // rdar://16089191 llvm-svn: 203028
2014-03-06 07:44:00 +08:00
while (IDecl->getSuperClass()) {
ObjCInterfaceDecl *SDecl = IDecl->getSuperClass();
if (!SuperClassImplementsGetter && SDecl->getInstanceMethod(Prop->getGetterName()))
SuperClassImplementsGetter = true;
Remove trailing whitespace introduced in r203028. llvm-svn: 203588
2014-03-12 01:17:16 +08:00
Objective-C. Suppress the warning for auto synthesis of property not synthesizing protocol properties if class's super class implements them. // rdar://16089191 llvm-svn: 203028
2014-03-06 07:44:00 +08:00
if (!SuperClassImplementsSetter && SDecl->getInstanceMethod(Prop->getSetterName()))
SuperClassImplementsSetter = true;
if (SuperClassImplementsGetter && SuperClassImplementsSetter)
return true;
IDecl = IDecl->getSuperClass();
}
return false;
}
objective-C: When implementing custom accessor method for a property, the -Wdirect-ivar-access should not warn when accessing the property's synthesized instance variable. // rdar://13142820 llvm-svn: 175195
2013-02-15 03:07:19 +08:00
Documentation cleanup: * Removed \param comments for parameters that no longer exist; * Fixed a "\para" typo to "\param"; * Escaped @, # and \ symbols as needed in Doxygen comments; * Added use of \brief to output short summaries. llvm-svn: 158498
2012-06-15 15:13:21 +08:00
/// \brief Default synthesizes all properties which must be synthesized
/// in class's \@implementation.
Add a fixit for -Wobjc-protocol-property-synthesis rdar://32132756 Differential Revision: https://reviews.llvm.org/D34886 llvm-svn: 307014
2017-07-03 18:12:24 +08:00
void Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl,
ObjCInterfaceDecl *IDecl,
SourceLocation AtEnd) {
Factor CollectClassPropertyImplementations out of Sema into AST This would make it possible for the analyzer to use the function. llvm-svn: 166210
2012-10-19 03:17:53 +08:00
ObjCInterfaceDecl::PropertyMap PropMap;
objective-C: synthesize properties in order of their declarations to synthesize their ivars in similar determinstic order so they are laid out in a determinstic order. // rdar://13192366 llvm-svn: 175214
2013-02-15 06:33:34 +08:00
ObjCInterfaceDecl::PropertyDeclOrder PropertyOrder;
IDecl->collectPropertiesToImplement(PropMap, PropertyOrder);
Implement new default property synthesis rules. Essentially, no longer user directive is needed to force a property implementation. It is decided based on those propeties which are declared in the class (or in its protocols) but not those which must be default implemented by one of its super classes. Implements radar 7923851. llvm-svn: 103787
2010-05-15 02:35:57 +08:00
if (PropMap.empty())
return;
Factor CollectClassPropertyImplementations out of Sema into AST This would make it possible for the analyzer to use the function. llvm-svn: 166210
2012-10-19 03:17:53 +08:00
ObjCInterfaceDecl::PropertyMap SuperPropMap;
Implement new default property synthesis rules. Essentially, no longer user directive is needed to force a property implementation. It is decided based on those propeties which are declared in the class (or in its protocols) but not those which must be default implemented by one of its super classes. Implements radar 7923851. llvm-svn: 103787
2010-05-15 02:35:57 +08:00
CollectSuperClassPropertyImplementations(IDecl, SuperPropMap);
objective-C: synthesize properties in order of their declarations to synthesize their ivars in similar determinstic order so they are laid out in a determinstic order. // rdar://13192366 llvm-svn: 175214
2013-02-15 06:33:34 +08:00
for (unsigned i = 0, e = PropertyOrder.size(); i != e; i++) {
ObjCPropertyDecl *Prop = PropertyOrder[i];
Objective-C: Another case of issuing warning about misusing property auto-synthesis before knowingit it is to be auto-synthesized. // rdar://14094682 llvm-svn: 183556
2013-06-08 04:26:51 +08:00
// Is there a matching property synthesize/dynamic?
if (Prop->isInvalidDecl() ||
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
Prop->isClassProperty() ||
Objective-C: Another case of issuing warning about misusing property auto-synthesis before knowingit it is to be auto-synthesized. // rdar://14094682 llvm-svn: 183556
2013-06-08 04:26:51 +08:00
Prop->getPropertyImplementation() == ObjCPropertyDecl::Optional)
continue;
// Property may have been synthesized by user.
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
if (IMPDecl->FindPropertyImplDecl(
Prop->getIdentifier(), Prop->getQueryKind()))
Objective-C: Another case of issuing warning about misusing property auto-synthesis before knowingit it is to be auto-synthesized. // rdar://14094682 llvm-svn: 183556
2013-06-08 04:26:51 +08:00
continue;
if (IMPDecl->getInstanceMethod(Prop->getGetterName())) {
if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readonly)
continue;
if (IMPDecl->getInstanceMethod(Prop->getSetterName()))
continue;
}
Objective-C: Removes a bogus warning about auto-synthesis of properties. Fixes // rdar://14085456 llvm-svn: 183542
2013-06-08 02:32:55 +08:00
if (ObjCPropertyImplDecl *PID =
IMPDecl->FindPropertyImplIvarDecl(Prop->getIdentifier())) {
Objective-C. Issue more warning diagnostic when certain properties are not synthesized in property auto-synthesis, as it can potentiall lead to runtime errors. rdar://17774815 llvm-svn: 214032
2014-07-27 04:52:26 +08:00
Diag(Prop->getLocation(), diag::warn_no_autosynthesis_shared_ivar_property)
<< Prop->getIdentifier();
Replace double negation of !FileID.isInvalid() with FileID.isValid(). +couple more of double-negated !SourceLocation.isInvalid() unfixed in r249228. llvm-svn: 249235
2015-10-03 18:46:20 +08:00
if (PID->getLocation().isValid())
Objective-C. Issue more warning diagnostic when certain properties are not synthesized in property auto-synthesis, as it can potentiall lead to runtime errors. rdar://17774815 llvm-svn: 214032
2014-07-27 04:52:26 +08:00
Diag(PID->getLocation(), diag::note_property_synthesize);
Objective-C: Removes a bogus warning about auto-synthesis of properties. Fixes // rdar://14085456 llvm-svn: 183542
2013-06-08 02:32:55 +08:00
continue;
}
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
ObjCPropertyDecl *PropInSuperClass =
SuperPropMap[std::make_pair(Prop->getIdentifier(),
Prop->isClassProperty())];
Enhance "auto synthesis will not synthesize property in protocol" to include property and protocol name. Implements <rdar://problem/15617839>. llvm-svn: 197187
2013-12-13 07:40:14 +08:00
if (ObjCProtocolDecl *Proto =
dyn_cast<ObjCProtocolDecl>(Prop->getDeclContext())) {
objc: do not auto synthesize properties declared in protocols; with a warning. // rdar://10567333 llvm-svn: 146626
2011-12-15 09:03:18 +08:00
// We won't auto-synthesize properties declared in protocols.
Objective-C. Suppress the warning for auto synthesis of property not synthesizing protocol properties if class's super class implements them. // rdar://16089191 llvm-svn: 203028
2014-03-06 07:44:00 +08:00
// Suppress the warning if class's superclass implements property's
// getter and implements property's setter (if readwrite property).
Objective-C [qoi]. If property is going to be implemented in the super class, do not issue the warning about property in current class's protocol will not be auto synthesized. // rdar://18179833 llvm-svn: 216769
2014-08-30 04:29:31 +08:00
// Or, if property is going to be implemented in its super class.
if (!SuperClassImplementsProperty(IDecl, Prop) && !PropInSuperClass) {
Objective-C. Suppress the warning for auto synthesis of property not synthesizing protocol properties if class's super class implements them. // rdar://16089191 llvm-svn: 203028
2014-03-06 07:44:00 +08:00
Diag(IMPDecl->getLocation(),
diag::warn_auto_synthesizing_protocol_property)
<< Prop << Proto;
Diag(Prop->getLocation(), diag::note_property_declare);
Add a fixit for -Wobjc-protocol-property-synthesis rdar://32132756 Differential Revision: https://reviews.llvm.org/D34886 llvm-svn: 307014
2017-07-03 18:12:24 +08:00
std::string FixIt =
(Twine("@synthesize ") + Prop->getName() + ";\n\n").str();
Diag(AtEnd, diag::note_add_synthesize_directive)
<< FixItHint::CreateInsertion(AtEnd, FixIt);
Objective-C. Suppress the warning for auto synthesis of property not synthesizing protocol properties if class's super class implements them. // rdar://16089191 llvm-svn: 203028
2014-03-06 07:44:00 +08:00
}
objc: do not auto synthesize properties declared in protocols; with a warning. // rdar://10567333 llvm-svn: 146626
2011-12-15 09:03:18 +08:00
continue;
}
Objective-C. Tweak diagnosing properties that are not auto-synthesized. Do not warn when property declared in class's protocol will be auto-synthesized by its uper class implementation because super class has also declared this property while this class has not. Continue to warn if current class has declared the property also (because this declaration will not result in a 2nd synthesis). rdar://18152478 llvm-svn: 216753
2014-08-30 02:31:16 +08:00
// If property to be implemented in the super class, ignore.
Objective-C [qoi]. If property is going to be implemented in the super class, do not issue the warning about property in current class's protocol will not be auto synthesized. // rdar://18179833 llvm-svn: 216769
2014-08-30 04:29:31 +08:00
if (PropInSuperClass) {
Objective-C. Tweak diagnosing properties that are not auto-synthesized. Do not warn when property declared in class's protocol will be auto-synthesized by its uper class implementation because super class has also declared this property while this class has not. Continue to warn if current class has declared the property also (because this declaration will not result in a 2nd synthesis). rdar://18152478 llvm-svn: 216753
2014-08-30 02:31:16 +08:00
if ((Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readwrite) &&
(PropInSuperClass->getPropertyAttributes() &
ObjCPropertyDecl::OBJC_PR_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 {
Diag(Prop->getLocation(), diag::warn_autosynthesis_property_in_superclass)
<< Prop->getIdentifier();
Objective-C [qoi]. When reporting that a property is not auto synthesized because it is synthesized in its super class. locate property declaration in super class which will default synthesize the property. rdar://18488727 llvm-svn: 219535
2014-10-11 06:08:23 +08:00
Diag(PropInSuperClass->getLocation(), diag::note_property_declare);
Objective-C. Tweak diagnosing properties that are not auto-synthesized. Do not warn when property declared in class's protocol will be auto-synthesized by its uper class implementation because super class has also declared this property while this class has not. Continue to warn if current class has declared the property also (because this declaration will not result in a 2nd synthesis). rdar://18152478 llvm-svn: 216753
2014-08-30 02:31:16 +08:00
Diag(IMPDecl->getLocation(), diag::note_while_in_implementation);
}
continue;
}
Default synthesized ivars don't really have a location in the source. Using the location of the @implementation is just confusing for clients that want to use SourceLocations for syntactic references. Fixes: <rdar://problem/8470540> llvm-svn: 114714
2010-09-24 09:23:01 +08:00
// We use invalid SourceLocations for the synthesized ivars since they
// aren't really synthesized at a particular location; they just exist.
// Saying that they are located at the @implementation isn't really going
// to help users.
objective-c: warn for properties being default synthesized under -Wobjc-missing-property-synthesis which must be opted-in. // rdar://11295716 llvm-svn: 156078
2012-05-04 00:43:30 +08:00
ObjCPropertyImplDecl *PIDecl = dyn_cast_or_null<ObjCPropertyImplDecl>(
ActOnPropertyImplDecl(S, SourceLocation(), SourceLocation(),
true,
/* property = */ Prop->getIdentifier(),
Make getDefaultSynthIvarName() a member of ObjCPropertyDecl. llvm-svn: 164789
2012-09-28 03:45:11 +08:00
/* ivar = */ Prop->getDefaultSynthIvarName(Context),
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
Prop->getLocation(), Prop->getQueryKind()));
[Sema] Silence -Wobjc-missing-property-synthesis for unavailable properties rdar://30296911 llvm-svn: 310916
2017-08-15 20:40:01 +08:00
if (PIDecl && !Prop->isUnavailable()) {
objective-c: warn for properties being default synthesized under -Wobjc-missing-property-synthesis which must be opted-in. // rdar://11295716 llvm-svn: 156078
2012-05-04 00:43:30 +08:00
Diag(Prop->getLocation(), diag::warn_missing_explicit_synthesis);
Fixes a typo. note_xxx not not_xxx. llvm-svn: 156391
2012-05-09 02:03:39 +08:00
Diag(IMPDecl->getLocation(), diag::note_while_in_implementation);
objective-c: warn for properties being default synthesized under -Wobjc-missing-property-synthesis which must be opted-in. // rdar://11295716 llvm-svn: 156078
2012-05-04 00:43:30 +08:00
}
Default synthesized ivars don't really have a location in the source. Using the location of the @implementation is just confusing for clients that want to use SourceLocations for syntactic references. Fixes: <rdar://problem/8470540> llvm-svn: 114714
2010-09-24 09:23:01 +08:00
}
Implement new default property synthesis rules. Essentially, no longer user directive is needed to force a property implementation. It is decided based on those propeties which are declared in the class (or in its protocols) but not those which must be default implemented by one of its super classes. Implements radar 7923851. llvm-svn: 103787
2010-05-15 02:35:57 +08:00
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Add a fixit for -Wobjc-protocol-property-synthesis rdar://32132756 Differential Revision: https://reviews.llvm.org/D34886 llvm-svn: 307014
2017-07-03 18:12:24 +08:00
void Sema::DefaultSynthesizeProperties(Scope *S, Decl *D,
SourceLocation AtEnd) {
Restructure how the driver communicates information about the target Objective-C runtime down to the frontend: break this down into a single target runtime kind and version, and compute all the relevant information from that. This makes it relatively painless to add support for new runtimes to the compiler. Make the new -cc1 flag, -fobjc-runtime=blah-x.y.z, available at the driver level as a better and more general alternative to -fgnu-runtime and -fnext-runtime. This new concept of an Objective-C runtime also encompasses what we were previously separating out as the "Objective-C ABI", so fragile vs. non-fragile runtimes are now really modelled as different kinds of runtime, paving the way for better overall differentiation. As a sort of special case, continue to accept the -cc1 flag -fobjc-runtime-has-weak, as a sop to PLCompatibilityWeak. I won't go so far as to say "no functionality change", even ignoring the new driver flag, but subtle changes in driver semantics are almost certainly not intended. llvm-svn: 158793
2012-06-20 14:18:46 +08:00
if (!LangOpts.ObjCDefaultSynthProperties || LangOpts.ObjCRuntime.isFragile())
objective-c: this patch (re)introduces objective-c's default property synthesis. This new feature is currently placed under -fobjc-default-synthesize-properties option and is off by default pending further testing. It will become the default feature soon. // rdar://8843851 llvm-svn: 138913
2011-09-01 06:24:06 +08:00
return;
ObjCImplementationDecl *IC=dyn_cast_or_null<ObjCImplementationDecl>(D);
if (!IC)
return;
if (ObjCInterfaceDecl* IDecl = IC->getClassInterface())
After further discussion, rename attribute 'objc_disable_automatic_synthesis' to 'objc_requires_property_definitions'. llvm-svn: 147622
2012-01-06 06:47:47 +08:00
if (!IDecl->isObjCRequiresPropertyDefs())
Add a fixit for -Wobjc-protocol-property-synthesis rdar://32132756 Differential Revision: https://reviews.llvm.org/D34886 llvm-svn: 307014
2017-07-03 18:12:24 +08:00
DefaultSynthesizeProperties(S, IC, IDecl, AtEnd);
objective-c: this patch (re)introduces objective-c's default property synthesis. This new feature is currently placed under -fobjc-default-synthesize-properties option and is off by default pending further testing. It will become the default feature soon. // rdar://8843851 llvm-svn: 138913
2011-09-01 06:24:06 +08:00
}
ObjectiveC Class Properties: warn if a class property accessor is mistakenly an instance method. When diagnosing unimplemented class property, make sure we emit a warning when we only see an instance method with the right selector. Also warn when we only see a class method for an instance property. rdar://26141719 llvm-svn: 269968
2016-05-19 02:12:34 +08:00
static void DiagnoseUnimplementedAccessor(
Sema &S, ObjCInterfaceDecl *PrimaryClass, Selector Method,
ObjCImplDecl *IMPDecl, ObjCContainerDecl *CDecl, ObjCCategoryDecl *C,
ObjCPropertyDecl *Prop,
llvm::SmallPtrSet<const ObjCMethodDecl *, 8> &SMap) {
// Check to see if we have a corresponding selector in SMap and with the
// right method type.
auto I = std::find_if(SMap.begin(), SMap.end(),
[&](const ObjCMethodDecl *x) {
return x->getSelector() == Method &&
x->isClassMethod() == Prop->isClassProperty();
});
[ObjC] Condense logic for diagnosing unimplemented setter/getters into help method. No functionality change. llvm-svn: 201877
2014-02-22 03:41:30 +08:00
// When reporting on missing property setter/getter implementation in
// categories, do not report when they are declared in primary class,
// class's protocol, or one of it super classes. This is because,
// the class is going to implement them.
ObjectiveC Class Properties: warn if a class property accessor is mistakenly an instance method. When diagnosing unimplemented class property, make sure we emit a warning when we only see an instance method with the right selector. Also warn when we only see a class method for an instance property. rdar://26141719 llvm-svn: 269968
2016-05-19 02:12:34 +08:00
if (I == SMap.end() &&
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
(PrimaryClass == nullptr ||
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
!PrimaryClass->lookupPropertyAccessor(Method, C,
Prop->isClassProperty()))) {
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
unsigned diag =
isa<ObjCCategoryDecl>(CDecl)
? (Prop->isClassProperty()
? diag::warn_impl_required_in_category_for_class_property
: diag::warn_setter_getter_impl_required_in_category)
: (Prop->isClassProperty()
? diag::warn_impl_required_for_class_property
: diag::warn_setter_getter_impl_required);
S.Diag(IMPDecl->getLocation(), diag) << Prop->getDeclName() << Method;
S.Diag(Prop->getLocation(), diag::note_property_declare);
if (S.LangOpts.ObjCDefaultSynthProperties &&
S.LangOpts.ObjCRuntime.isNonFragile())
if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CDecl))
if (const ObjCInterfaceDecl *RID = ID->isObjCRequiresPropertyDefs())
S.Diag(RID->getLocation(), diag::note_suppressed_class_declare);
}
[ObjC] Condense logic for diagnosing unimplemented setter/getters into help method. No functionality change. llvm-svn: 201877
2014-02-22 03:41:30 +08:00
}
This patch deals with Sema Part of Setter/Getter synthesis of properties which are of C++ objects. Code Gen to follow (Radar 7468090). llvm-svn: 103123
2010-05-06 05:52:17 +08:00
void Sema::DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
[ObjC] Change default property synthesis logic to not completely skip DiagnoseUnimplementedProperties. We're going to extend DiagnoseUnimplementedProperties shortly to look for more cases that aren't handled by default property synthesis. llvm-svn: 201878
2014-02-22 03:41:34 +08:00
ObjCContainerDecl *CDecl,
bool SynthesizeProperties) {
Factor CollectClassPropertyImplementations out of Sema into AST This would make it possible for the analyzer to use the function. llvm-svn: 166210
2012-10-19 03:17:53 +08:00
ObjCContainerDecl::PropertyMap PropMap;
[ObjC] add support for properties in attribute 'objc_protocol_requires_explicit_implementation'. llvm-svn: 201880
2014-02-22 03:41:39 +08:00
ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl);
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
// Since we don't synthesize class properties, we should emit diagnose even
// if SynthesizeProperties is true.
ObjCContainerDecl::PropertyMap NoNeedToImplPropMap;
// Gather properties which need not be implemented in this class
// or category.
if (!IDecl)
if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
// For categories, no need to implement properties declared in
// its primary class (and its super classes) if property is
// declared in one of those containers.
if ((IDecl = C->getClassInterface())) {
ObjCInterfaceDecl::PropertyDeclOrder PO;
IDecl->collectPropertiesToImplement(NoNeedToImplPropMap, PO);
[ObjC] Change default property synthesis logic to not completely skip DiagnoseUnimplementedProperties. We're going to extend DiagnoseUnimplementedProperties shortly to look for more cases that aren't handled by default property synthesis. llvm-svn: 201878
2014-02-22 03:41:34 +08:00
}
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
}
if (IDecl)
CollectSuperClassPropertyImplementations(IDecl, NoNeedToImplPropMap);
[ObjC] Change default property synthesis logic to not completely skip DiagnoseUnimplementedProperties. We're going to extend DiagnoseUnimplementedProperties shortly to look for more cases that aren't handled by default property synthesis. llvm-svn: 201878
2014-02-22 03:41:34 +08:00
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
// When SynthesizeProperties is true, we only check class properties.
CollectImmediateProperties(CDecl, PropMap, NoNeedToImplPropMap,
SynthesizeProperties/*CollectClassPropsOnly*/);
[ObjC] Change default property synthesis logic to not completely skip DiagnoseUnimplementedProperties. We're going to extend DiagnoseUnimplementedProperties shortly to look for more cases that aren't handled by default property synthesis. llvm-svn: 201878
2014-02-22 03:41:34 +08:00
[ObjC] add support for properties in attribute 'objc_protocol_requires_explicit_implementation'. llvm-svn: 201880
2014-02-22 03:41:39 +08:00
// Scan the @interface to see if any of the protocols it adopts
// require an explicit implementation, via attribute
// 'objc_protocol_requires_explicit_implementation'.
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
if (IDecl) {
Replace OwningPtr with std::unique_ptr. This compiles cleanly with lldb/lld/clang-tools-extra/llvm. llvm-svn: 203279
2014-03-08 04:03:18 +08:00
std::unique_ptr<ObjCContainerDecl::PropertyMap> LazyMap;
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
[C++11] Replacing ObjCInterfaceDecl iterators all_referenced_protocol_begin() and all_referenced_protocol_end() with iterator_range all_referenced_protocols(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203848
2014-03-14 04:55:22 +08:00
for (auto *PDecl : IDecl->all_referenced_protocols()) {
[ObjC] add support for properties in attribute 'objc_protocol_requires_explicit_implementation'. llvm-svn: 201880
2014-02-22 03:41:39 +08:00
if (!PDecl->hasAttr<ObjCExplicitProtocolImplAttr>())
continue;
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
// Lazily construct a set of all the properties in the @interface
// of the class, without looking at the superclass. We cannot
// use the call to CollectImmediateProperties() above as that
Clean up language and grammar. Based on a patch by jfcaron3@gmail.com! PR19806 llvm-svn: 209215
2014-05-21 01:10:39 +08:00
// utilizes information from the super class's properties as well
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
// as scans the adopted protocols. This work only triggers for protocols
// with the attribute, which is very rare, and only occurs when
// analyzing the @implementation.
if (!LazyMap) {
ObjCContainerDecl::PropertyMap NoNeedToImplPropMap;
LazyMap.reset(new ObjCContainerDecl::PropertyMap());
CollectImmediateProperties(CDecl, *LazyMap, NoNeedToImplPropMap,
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
/* CollectClassPropsOnly */ false,
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
/* IncludeProtocols */ false);
}
[ObjC] add support for properties in attribute 'objc_protocol_requires_explicit_implementation'. llvm-svn: 201880
2014-02-22 03:41:39 +08:00
// Add the properties of 'PDecl' to the list of properties that
// need to be implemented.
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
for (auto *PropDecl : PDecl->properties()) {
if ((*LazyMap)[std::make_pair(PropDecl->getIdentifier(),
PropDecl->isClassProperty())])
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
continue;
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
PropMap[std::make_pair(PropDecl->getIdentifier(),
PropDecl->isClassProperty())] = PropDecl;
[ObjC] add support for properties in attribute 'objc_protocol_requires_explicit_implementation'. llvm-svn: 201880
2014-02-22 03:41:39 +08:00
}
}
[ObjC] Make attribute 'objc_protocol_requires_explicit_implementation' behave correctly with default property synthesis. In particular, if we see an @property within the @interface of a class conforming to a protocol with this attribute, we treat that as if the implementation were available, per the rules of default property synthesis. llvm-svn: 201911
2014-02-22 08:02:03 +08:00
}
[ObjC] add support for properties in attribute 'objc_protocol_requires_explicit_implementation'. llvm-svn: 201880
2014-02-22 03:41:39 +08:00
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
if (PropMap.empty())
return;
llvm::DenseSet<ObjCPropertyDecl *> PropImplMap;
[C++11] Replacing ObjCCategoryDecl iterators propimpl_begin() and propimpl_end() with iterator_range property_impls(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203930
2014-03-14 23:02:45 +08:00
for (const auto *I : IMPDecl->property_impls())
Remove the ref/value inconsistency in filter_decl_iterator. filter_decl_iterator had a weird mismatch where both op* and op-> returned T* making it difficult to generalize this filtering behavior into a reusable library of any kind. This change errs on the side of value, making op-> return T* and op* return T&. (reviewed by Richard Smith) llvm-svn: 155808
2012-04-30 10:36:29 +08:00
PropImplMap.insert(I->getPropertyDecl());
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
ObjectiveC Class Properties: warn if a class property accessor is mistakenly an instance method. When diagnosing unimplemented class property, make sure we emit a warning when we only see an instance method with the right selector. Also warn when we only see a class method for an instance property. rdar://26141719 llvm-svn: 269968
2016-05-19 02:12:34 +08:00
llvm::SmallPtrSet<const ObjCMethodDecl *, 8> InsMap;
Objective-C: When reporting on missing property accessor implementation in categories, do not report when they are declared in primary class, class's protocol, or one of it super classes. This is because, its class is going to implement them. // rdar://13713098 llvm-svn: 180198
2013-04-25 01:06:38 +08:00
// Collect property accessors implemented in current implementation.
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
for (const auto *I : IMPDecl->methods())
ObjectiveC Class Properties: warn if a class property accessor is mistakenly an instance method. When diagnosing unimplemented class property, make sure we emit a warning when we only see an instance method with the right selector. Also warn when we only see a class method for an instance property. rdar://26141719 llvm-svn: 269968
2016-05-19 02:12:34 +08:00
InsMap.insert(I);
Objective-C: When reporting on missing property accessor implementation in categories, do not report when they are declared in primary class, class's protocol, or one of it super classes. This is because, its class is going to implement them. // rdar://13713098 llvm-svn: 180198
2013-04-25 01:06:38 +08:00
ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl);
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
ObjCInterfaceDecl *PrimaryClass = nullptr;
Objective-C: When reporting on missing property accessor implementation in categories, do not report when they are declared in primary class, class's protocol, or one of it super classes. This is because, its class is going to implement them. // rdar://13713098 llvm-svn: 180198
2013-04-25 01:06:38 +08:00
if (C && !C->IsClassExtension())
if ((PrimaryClass = C->getClassInterface()))
// Report unimplemented properties in the category as well.
if (ObjCImplDecl *IMP = PrimaryClass->getImplementation()) {
// When reporting on missing setter/getters, do not report when
// setter/getter is implemented in category's primary class
// implementation.
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
for (const auto *I : IMP->methods())
ObjectiveC Class Properties: warn if a class property accessor is mistakenly an instance method. When diagnosing unimplemented class property, make sure we emit a warning when we only see an instance method with the right selector. Also warn when we only see a class method for an instance property. rdar://26141719 llvm-svn: 269968
2016-05-19 02:12:34 +08:00
InsMap.insert(I);
Objective-C: When reporting on missing property accessor implementation in categories, do not report when they are declared in primary class, class's protocol, or one of it super classes. This is because, its class is going to implement them. // rdar://13713098 llvm-svn: 180198
2013-04-25 01:06:38 +08:00
}
Factor CollectClassPropertyImplementations out of Sema into AST This would make it possible for the analyzer to use the function. llvm-svn: 166210
2012-10-19 03:17:53 +08:00
for (ObjCContainerDecl::PropertyMap::iterator
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
P = PropMap.begin(), E = PropMap.end(); P != E; ++P) {
ObjCPropertyDecl *Prop = P->second;
ObjC class properties: add diagnostics for unimplemented class properties. rdar://24711047 llvm-svn: 266146
2016-04-13 07:01:55 +08:00
// Is there a matching property synthesize/dynamic?
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
if (Prop->isInvalidDecl() ||
Prop->getPropertyImplementation() == ObjCPropertyDecl::Optional ||
Use Decl::getAvailability() rather than checking for the "unavailable" attribute when determining whether we need to see an implementation of a property. Fixes <rdar://problem/12958191>. llvm-svn: 171877
2013-01-09 02:16:18 +08:00
PropImplMap.count(Prop) ||
Prop->getAvailability() == AR_Unavailable)
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
continue;
[ObjC] Condense logic for diagnosing unimplemented setter/getters into help method. No functionality change. llvm-svn: 201877
2014-02-22 03:41:30 +08:00
// Diagnose unimplemented getters and setters.
DiagnoseUnimplementedAccessor(*this,
PrimaryClass, Prop->getGetterName(), IMPDecl, CDecl, C, Prop, InsMap);
if (!Prop->isReadOnly())
DiagnoseUnimplementedAccessor(*this,
PrimaryClass, Prop->getSetterName(),
IMPDecl, CDecl, C, Prop, InsMap);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
}
}
Replace __double_underscored type nullability qualifiers with _Uppercase_underscored Addresses a conflict with glibc's __nonnull macro by renaming the type nullability qualifiers as follows: __nonnull -> _Nonnull __nullable -> _Nullable __null_unspecified -> _Null_unspecified This is the major part of rdar://problem/21530726, but does not yet provide the Darwin-specific behavior for the old names. llvm-svn: 240596
2015-06-25 06:02:08 +08:00
void Sema::diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl) {
Implement the 'null_resettable' attribute for Objective-C properties. 'null_resettable' properties are those whose getters return nonnull but whose setters take nil, to "reset" the property to some default. Implements rdar://problem/19051334. llvm-svn: 240155
2015-06-20 02:14:46 +08:00
for (const auto *propertyImpl : impDecl->property_impls()) {
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 &&
(property->getPropertyAttributes() &
ObjCPropertyDecl::OBJC_PR_null_resettable) &&
property->getGetterMethodDecl() &&
property->getSetterMethodDecl()) {
auto *getterMethod = property->getGetterMethodDecl();
auto *setterMethod = property->getSetterMethodDecl();
if (!impDecl->getInstanceMethod(setterMethod->getSelector()) &&
!impDecl->getInstanceMethod(getterMethod->getSelector())) {
SourceLocation loc = propertyImpl->getLocation();
if (loc.isInvalid())
loc = impDecl->getLocStart();
Diag(loc, diag::warn_null_resettable_setter)
<< setterMethod->getSelector() << property->getDeclName();
}
}
}
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
void
Sema::AtomicPropertySetterGetterRules (ObjCImplDecl* IMPDecl,
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
ObjCInterfaceDecl* IDecl) {
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
// Rules apply in non-GC mode only
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().getGC() != LangOptions::NonGC)
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
return;
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
ObjCContainerDecl::PropertyMap PM;
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
for (auto *Prop : IDecl->properties())
PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
for (const auto *Ext : IDecl->known_extensions())
Class Property: change PropertyMap to include isClassProperty. PropertyMap used to map IdentifierInfo (name of the property) to ObjcPropertyDecl *. Now that a class property can have the same name as an instance property, we change PropertyMap to map a pair <IdentifierInfo *, unsigned> to ObjcPropertyDecl *. Also update a few places from iterating over instance_properties to iterating over all properties. rdar://23891898 llvm-svn: 259119
2016-01-29 07:36:05 +08:00
for (auto *Prop : Ext->properties())
PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
Class Property: handle class properties. At places where we handle instance properties, if necessary. rdar://23891898 llvm-svn: 258979
2016-01-28 04:00:32 +08:00
for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end();
I != E; ++I) {
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
const ObjCPropertyDecl *Property = I->second;
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
ObjCMethodDecl *GetterMethod = nullptr;
ObjCMethodDecl *SetterMethod = nullptr;
Add -Wcustom-atomic-properties which warns if an atomic-by-default property has custom getter or setter. The rationale is that it is highly likely that the user's getter/setter isn't atomically implemented. Off by default. Addresses rdar://8782645. -Wcustom-atomic-properties and -Wimplicit-atomic-properties are under the -Watomic-properties group. llvm-svn: 124609
2011-02-01 05:34:11 +08:00
bool LookedUpGetterSetter = false;
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
unsigned Attributes = Property->getPropertyAttributes();
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
unsigned AttributesAsWritten = Property->getPropertyAttributesAsWritten();
Add -Wcustom-atomic-properties which warns if an atomic-by-default property has custom getter or setter. The rationale is that it is highly likely that the user's getter/setter isn't atomically implemented. Off by default. Addresses rdar://8782645. -Wcustom-atomic-properties and -Wimplicit-atomic-properties are under the -Watomic-properties group. llvm-svn: 124609
2011-02-01 05:34:11 +08:00
Refactoring, mostly to give ObjCPropertyDecls stronger invariants for their semantic attributes and then to take advantage of that. llvm-svn: 139615
2011-09-14 02:31:23 +08:00
if (!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic) &&
!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_nonatomic)) {
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
GetterMethod = Property->isClassProperty() ?
IMPDecl->getClassMethod(Property->getGetterName()) :
IMPDecl->getInstanceMethod(Property->getGetterName());
SetterMethod = Property->isClassProperty() ?
IMPDecl->getClassMethod(Property->getSetterName()) :
IMPDecl->getInstanceMethod(Property->getSetterName());
Add -Wcustom-atomic-properties which warns if an atomic-by-default property has custom getter or setter. The rationale is that it is highly likely that the user's getter/setter isn't atomically implemented. Off by default. Addresses rdar://8782645. -Wcustom-atomic-properties and -Wimplicit-atomic-properties are under the -Watomic-properties group. llvm-svn: 124609
2011-02-01 05:34:11 +08:00
LookedUpGetterSetter = true;
if (GetterMethod) {
Diag(GetterMethod->getLocation(),
diag::warn_default_atomic_custom_getter_setter)
Improve the diagnostic for -Wcustom-atomic-properties. Suggestion by Fariborz! llvm-svn: 124620
2011-02-01 07:20:03 +08:00
<< Property->getIdentifier() << 0;
Add -Wcustom-atomic-properties which warns if an atomic-by-default property has custom getter or setter. The rationale is that it is highly likely that the user's getter/setter isn't atomically implemented. Off by default. Addresses rdar://8782645. -Wcustom-atomic-properties and -Wimplicit-atomic-properties are under the -Watomic-properties group. llvm-svn: 124609
2011-02-01 05:34:11 +08:00
Diag(Property->getLocation(), diag::note_property_declare);
}
if (SetterMethod) {
Diag(SetterMethod->getLocation(),
diag::warn_default_atomic_custom_getter_setter)
Improve the diagnostic for -Wcustom-atomic-properties. Suggestion by Fariborz! llvm-svn: 124620
2011-02-01 07:20:03 +08:00
<< Property->getIdentifier() << 1;
Add -Wcustom-atomic-properties which warns if an atomic-by-default property has custom getter or setter. The rationale is that it is highly likely that the user's getter/setter isn't atomically implemented. Off by default. Addresses rdar://8782645. -Wcustom-atomic-properties and -Wimplicit-atomic-properties are under the -Watomic-properties group. llvm-svn: 124609
2011-02-01 05:34:11 +08:00
Diag(Property->getLocation(), diag::note_property_declare);
}
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
// We only care about readwrite atomic property.
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if ((Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) ||
!(Attributes & ObjCPropertyDecl::OBJC_PR_readwrite))
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
continue;
Class Property: class property and instance property can have the same name. Add "enum ObjCPropertyQueryKind" to a few APIs that used to only take the name of the property: ObjCPropertyDecl::findPropertyDecl, ObjCContainerDecl::FindPropertyDeclaration, ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass, ObjCImplDecl::FindPropertyImplDecl, and Sema::ActOnPropertyImplDecl. ObjCPropertyQueryKind currently has 3 values: OBJC_PR_query_unknown, OBJC_PR_query_instance, OBJC_PR_query_class This extra parameter specifies that we are looking for an instance property with the given name, or a class property with the given name, or any property with the given name (if both exist, the instance property will be returned). rdar://23891898 llvm-svn: 259070
2016-01-29 02:49:28 +08:00
if (const ObjCPropertyImplDecl *PIDecl = IMPDecl->FindPropertyImplDecl(
Property->getIdentifier(), Property->getQueryKind())) {
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
continue;
Add -Wcustom-atomic-properties which warns if an atomic-by-default property has custom getter or setter. The rationale is that it is highly likely that the user's getter/setter isn't atomically implemented. Off by default. Addresses rdar://8782645. -Wcustom-atomic-properties and -Wimplicit-atomic-properties are under the -Watomic-properties group. llvm-svn: 124609
2011-02-01 05:34:11 +08:00
if (!LookedUpGetterSetter) {
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
GetterMethod = Property->isClassProperty() ?
IMPDecl->getClassMethod(Property->getGetterName()) :
IMPDecl->getInstanceMethod(Property->getGetterName());
SetterMethod = Property->isClassProperty() ?
IMPDecl->getClassMethod(Property->getSetterName()) :
IMPDecl->getInstanceMethod(Property->getSetterName());
Add -Wcustom-atomic-properties which warns if an atomic-by-default property has custom getter or setter. The rationale is that it is highly likely that the user's getter/setter isn't atomically implemented. Off by default. Addresses rdar://8782645. -Wcustom-atomic-properties and -Wimplicit-atomic-properties are under the -Watomic-properties group. llvm-svn: 124609
2011-02-01 05:34:11 +08:00
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
if ((GetterMethod && !SetterMethod) || (!GetterMethod && SetterMethod)) {
SourceLocation MethodLoc =
(GetterMethod ? GetterMethod->getLocation()
: SetterMethod->getLocation());
Diag(MethodLoc, diag::warn_atomic_property_rule)
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
<< Property->getIdentifier() << (GetterMethod != nullptr)
<< (SetterMethod != nullptr);
objective-c: provide fixit hint when atomic property does not have matching user defined setter/getter and a warning is issued. In this case, a fixit note is displayed. // rdar://10267155 llvm-svn: 151766
2012-03-01 06:18:55 +08:00
// fixit stuff.
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
if (Property->getLParenLoc().isValid() &&
!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic)) {
objective-c: provide fixit hint when atomic property does not have matching user defined setter/getter and a warning is issued. In this case, a fixit note is displayed. // rdar://10267155 llvm-svn: 151766
2012-03-01 06:18:55 +08:00
// @property () ... case.
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
SourceLocation AfterLParen =
getLocForEndOfToken(Property->getLParenLoc());
StringRef NonatomicStr = AttributesAsWritten? "nonatomic, "
: "nonatomic";
Diag(Property->getLocation(),
diag::note_atomic_property_fixup_suggest)
<< FixItHint::CreateInsertion(AfterLParen, NonatomicStr);
} else if (Property->getLParenLoc().isInvalid()) {
//@property id etc.
SourceLocation startLoc =
Property->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
Diag(Property->getLocation(),
diag::note_atomic_property_fixup_suggest)
<< FixItHint::CreateInsertion(startLoc, "(nonatomic) ");
objective-c: provide fixit hint when atomic property does not have matching user defined setter/getter and a warning is issued. In this case, a fixit note is displayed. // rdar://10267155 llvm-svn: 151766
2012-03-01 06:18:55 +08:00
}
else
Diag(MethodLoc, diag::note_atomic_property_fixup_suggest);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Diag(Property->getLocation(), diag::note_property_declare);
}
}
}
}
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
void Sema::DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D) {
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().getGC() == LangOptions::GCOnly)
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
return;
[C++11] Replacing ObjCCategoryDecl iterators propimpl_begin() and propimpl_end() with iterator_range property_impls(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203930
2014-03-14 23:02:45 +08:00
for (const auto *PID : D->property_impls()) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
const ObjCPropertyDecl *PD = PID->getPropertyDecl();
objc-arc/mrc: Allow ns_returns_not_retained attribute on properties to turn off warning on those properties which follow Cocoa naming convention for retaining objects and yet they were not meant for such purposes. Also, perform consistancy checking for declared getters of such methods. // rdar://9636091 llvm-svn: 133849
2011-06-25 08:17:46 +08:00
if (PD && !PD->hasAttr<NSReturnsNotRetainedAttr>() &&
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
!PD->isClassProperty() &&
objc-arc/mrc: Allow ns_returns_not_retained attribute on properties to turn off warning on those properties which follow Cocoa naming convention for retaining objects and yet they were not meant for such purposes. Also, perform consistancy checking for declared getters of such methods. // rdar://9636091 llvm-svn: 133849
2011-06-25 08:17:46 +08:00
!D->getInstanceMethod(PD->getGetterName())) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
ObjCMethodDecl *method = PD->getGetterMethodDecl();
if (!method)
continue;
ObjCMethodFamily family = method->getMethodFamily();
if (family == OMF_alloc || family == OMF_copy ||
family == OMF_mutableCopy || family == OMF_new) {
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().ObjCAutoRefCount)
ObjectiveC. 1) Warn when @dynamic (as well as synthesize) property has the naming convention that implies 'ownership'. 2) improve on diagnostic and make it property specific. 3) fix the line number in the case of default property synthesis. // rdar://15757510 llvm-svn: 198905
2014-01-10 08:53:48 +08:00
Diag(PD->getLocation(), diag::err_cocoa_naming_owned_rule);
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
else
ObjectiveC. 1) Warn when @dynamic (as well as synthesize) property has the naming convention that implies 'ownership'. 2) improve on diagnostic and make it property specific. 3) fix the line number in the case of default property synthesis. // rdar://15757510 llvm-svn: 198905
2014-01-10 08:53:48 +08:00
Diag(PD->getLocation(), diag::warn_cocoa_naming_owned_rule);
Suggest objc_method_family(none) for a property named -newFoo or similar. As mentioned in the previous commit, if a property (declared with @property) has a name that matches a special Objective-C method family, the getter picks up that family despite being declared by the property. The most correct way to solve this problem is to add the 'objc_method_family' attribute to the getter with an argument of 'none', which unfortunately requires an explicit declaration of the getter. This commit adds a note to the existing error (ARC) or warning (MRR) for such a poorly-named property that suggests the solution; if there's already a declaration of the getter, it even includes a fix-it. llvm-svn: 226339
2015-01-17 07:04:31 +08:00
// Look for a getter explicitly declared alongside the property.
// If we find one, use its location for the note.
SourceLocation noteLoc = PD->getLocation();
SourceLocation fixItLoc;
for (auto *getterRedecl : method->redecls()) {
if (getterRedecl->isImplicit())
continue;
if (getterRedecl->getDeclContext() != PD->getDeclContext())
continue;
noteLoc = getterRedecl->getLocation();
fixItLoc = getterRedecl->getLocEnd();
}
Preprocessor &PP = getPreprocessor();
TokenValue tokens[] = {
tok::kw___attribute, tok::l_paren, tok::l_paren,
PP.getIdentifierInfo("objc_method_family"), tok::l_paren,
PP.getIdentifierInfo("none"), tok::r_paren,
tok::r_paren, tok::r_paren
};
StringRef spelling = "__attribute__((objc_method_family(none)))";
StringRef macroName = PP.getLastMacroWithSpelling(noteLoc, tokens);
if (!macroName.empty())
spelling = macroName;
auto noteDiag = Diag(noteLoc, diag::note_cocoa_naming_declare_family)
<< method->getDeclName() << spelling;
if (fixItLoc.isValid()) {
SmallString<64> fixItText(" ");
fixItText += spelling;
noteDiag << FixItHint::CreateInsertion(fixItLoc, fixItText);
}
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
}
}
}
[objc] Add a warning when a class that provides a designated initializer, does not override all of the designated initializers of its superclass. llvm-svn: 196319
2013-12-04 05:11:54 +08:00
void Sema::DiagnoseMissingDesignatedInitOverrides(
revert r231700 (designated initializer patch) which broke several projects. rdar://20120666. llvm-svn: 231939
2015-03-12 00:59:48 +08:00
const ObjCImplementationDecl *ImplD,
const ObjCInterfaceDecl *IFD) {
assert(IFD->hasDesignatedInitializers());
[objc] Add a warning when a class that provides a designated initializer, does not override all of the designated initializers of its superclass. llvm-svn: 196319
2013-12-04 05:11:54 +08:00
const ObjCInterfaceDecl *SuperD = IFD->getSuperClass();
if (!SuperD)
return;
SelectorSet InitSelSet;
[C++11] Replacing ObjCContainerDecl iterators instmeth_begin() and instmeth_end() with iterator_range instance_methods(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203839
2014-03-14 03:50:17 +08:00
for (const auto *I : ImplD->instance_methods())
if (I->getMethodFamily() == OMF_init)
InitSelSet.insert(I->getSelector());
[objc] Add a warning when a class that provides a designated initializer, does not override all of the designated initializers of its superclass. llvm-svn: 196319
2013-12-04 05:11:54 +08:00
SmallVector<const ObjCMethodDecl *, 8> DesignatedInits;
SuperD->getDesignatedInitializers(DesignatedInits);
for (SmallVector<const ObjCMethodDecl *, 8>::iterator
I = DesignatedInits.begin(), E = DesignatedInits.end(); I != E; ++I) {
const ObjCMethodDecl *MD = *I;
if (!InitSelSet.count(MD->getSelector())) {
[sema] Allow to opt-out of overriding the super class's designated initializers by marking the initializer as unavailable in the subclass. rdar://20281322 llvm-svn: 243676
2015-07-31 03:06:04 +08:00
bool Ignore = false;
if (auto *IMD = IFD->getInstanceMethod(MD->getSelector())) {
Ignore = IMD->isUnavailable();
}
if (!Ignore) {
Diag(ImplD->getLocation(),
diag::warn_objc_implementation_missing_designated_init_override)
<< MD->getSelector();
Diag(MD->getLocation(), diag::note_objc_designated_init_marked_here);
}
[objc] Add a warning when a class that provides a designated initializer, does not override all of the designated initializers of its superclass. llvm-svn: 196319
2013-12-04 05:11:54 +08:00
}
}
}
Propagate the deprecated and unavailable attributes from a @property declaration to the autogenerated methods. I'm uncertain whether this should apply to attributes in general, but these are a reasonable core. Implements rdar://problem/8617301 llvm-svn: 118676
2010-11-10 15:01:40 +08:00
/// AddPropertyAttrs - Propagates attributes from a property to the
/// implicitly-declared getter or setter for that property.
static void AddPropertyAttrs(Sema &S, ObjCMethodDecl *PropertyMethod,
ObjCPropertyDecl *Property) {
// Should we just clone all attributes over?
[C++11] Replacing Decl iterators attr_begin() and attr_end() with iterator_range attrs(). Updating all of the usages of the iterators with range-based for loops. This is a reapplication of r203236 with modifications to the definition of attrs() and following the new style guidelines on auto usage. llvm-svn: 203362
2014-03-09 06:19:01 +08:00
for (const auto *A : Property->attrs()) {
if (isa<DeprecatedAttr>(A) ||
isa<UnavailableAttr>(A) ||
isa<AvailabilityAttr>(A))
PropertyMethod->addAttr(A->clone(S.Context));
Implement a new 'availability' attribute, that allows one to specify which versions of an OS provide a certain facility. For example, void foo() __attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6))); says that the function "foo" was introduced in 10.2, deprecated in 10.4, and completely obsoleted in 10.6. This attribute ties in with the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that we want to deploy back to Mac OS X 10.1). There are several concrete behaviors that this attribute enables, as illustrated with the function foo() above: - If we choose a deployment target >= Mac OS X 10.4, uses of "foo" will result in a deprecation warning, as if we had placed attribute((deprecated)) on it (but with a better diagnostic) - If we choose a deployment target >= Mac OS X 10.6, uses of "foo" will result in an "unavailable" warning (in C)/error (in C++), as if we had placed attribute((unavailable)) on it - If we choose a deployment target prior to 10.2, foo() is weak-imported (if it is a kind of entity that can be weak imported), as if we had placed the weak_import attribute on it. Naturally, there can be multiple availability attributes on a declaration, for different platforms; only the current platform matters when checking availability attributes. The only platforms this attribute currently works for are "ios" and "macosx", since we already have -mxxxx-version-min flags for them and we have experience there with macro tricks translating down to the deprecated/unavailable/weak_import attributes. The end goal is to open this up to other platforms, and even extension to other "platforms" that are really libraries (say, through a #pragma clang define_system), but that hasn't yet been designed and we may want to shake out more issues with this narrower problem first. Addresses <rdar://problem/6690412>. As a drive-by bug-fix, if an entity is both deprecated and unavailable, we only emit the "unavailable" diagnostic. llvm-svn: 128127
2011-03-23 08:50:03 +08:00
}
Propagate the deprecated and unavailable attributes from a @property declaration to the autogenerated methods. I'm uncertain whether this should apply to attributes in general, but these are a reasonable core. Implements rdar://problem/8617301 llvm-svn: 118676
2010-11-10 15:01:40 +08:00
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
/// ProcessPropertyDecl - Make sure that any user-defined setter/getter methods
/// have the property type and issue diagnostics if they don't.
/// Also synthesize a getter/setter method if none exist (and update the
Simplify Sema::ProcessPropertyDecl. NFC Now that the properties created within Objective-C class extensions go into the extension themselves, we don't need any of the extra complexity here. llvm-svn: 251949
2015-11-04 01:02:34 +08:00
/// appropriate lookup tables.
void Sema::ProcessPropertyDecl(ObjCPropertyDecl *property) {
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
ObjCMethodDecl *GetterMethod, *SetterMethod;
Simplify Sema::ProcessPropertyDecl. NFC Now that the properties created within Objective-C class extensions go into the extension themselves, we don't need any of the extra complexity here. llvm-svn: 251949
2015-11-04 01:02:34 +08:00
ObjCContainerDecl *CD = cast<ObjCContainerDecl>(property->getDeclContext());
Objective-C. Fixes an obscuer crash caused by multiple inclusion of same framework after complaining about duplicate class definition. // rdar://17024681 llvm-svn: 209672
2014-05-28 02:26:09 +08:00
if (CD->isInvalidDecl())
return;
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
bool IsClassProperty = property->isClassProperty();
GetterMethod = IsClassProperty ?
CD->getClassMethod(property->getGetterName()) :
CD->getInstanceMethod(property->getGetterName());
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
// if setter or getter is not found in class extension, it might be
// in the primary class.
if (!GetterMethod)
if (const ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CD))
if (CatDecl->IsClassExtension())
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
GetterMethod = IsClassProperty ? CatDecl->getClassInterface()->
getClassMethod(property->getGetterName()) :
CatDecl->getClassInterface()->
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
getInstanceMethod(property->getGetterName());
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
SetterMethod = IsClassProperty ?
CD->getClassMethod(property->getSetterName()) :
CD->getInstanceMethod(property->getSetterName());
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
if (!SetterMethod)
if (const ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CD))
if (CatDecl->IsClassExtension())
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
SetterMethod = IsClassProperty ? CatDecl->getClassInterface()->
getClassMethod(property->getSetterName()) :
CatDecl->getClassInterface()->
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
getInstanceMethod(property->getSetterName());
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
DiagnosePropertyAccessorMismatch(property, GetterMethod,
property->getLocation());
[Sema][ObjC] Avoid the "type of property does not match type of accessor" warning for methods that resemble the setters of readonly properties rdar://30415679 llvm-svn: 299078
2017-03-30 21:33:51 +08:00
if (!property->isReadOnly() && SetterMethod) {
if (Context.getCanonicalType(SetterMethod->getReturnType()) !=
Context.VoidTy)
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Diag(SetterMethod->getLocation(), diag::err_setter_type_void);
if (SetterMethod->param_size() != 1 ||
objc - compare setter/property types using hasSameUnqualifiedType in //rdar://10156674 llvm-svn: 140576
2011-09-27 06:59:09 +08:00
!Context.hasSameUnqualifiedType(
obj-c++: allow the getter/setter to return/take parameters by reference. // rdar://10188258 llvm-svn: 142075
2011-10-16 01:36:49 +08:00
(*SetterMethod->param_begin())->getType().getNonReferenceType(),
property->getType().getNonReferenceType())) {
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Diag(property->getLocation(),
diag::warn_accessor_property_type_mismatch)
<< property->getDeclName()
<< SetterMethod->getSelector();
Diag(SetterMethod->getLocation(), diag::note_declared_at);
}
}
// Synthesize getter/setter methods if none exist.
// Find the default getter and if one not found, add one.
// FIXME: The synthesized property we set here is misleading. We almost always
// synthesize these methods unless the user explicitly provided prototypes
// (which is odd, but allowed). Sema should be typechecking that the
// declarations jive in that situation (which it is not currently).
if (!GetterMethod) {
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
// No instance/class method of same name as property getter name was found.
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
// Declare a getter method and add it to the list of methods
// for this class.
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
SourceLocation Loc = property->getLocation();
Correctly register the class extension as the lexical DeclContext for ObjC methods declared with @property in class extensions. This matches the behavior for setters. Also pass the class extension to ProcessPropertyDecl as the lexical DeclContext, even when not redeclaring the @property. This fixes the remaining issues in <rdar://problem/7410145>. llvm-svn: 114477
2010-09-22 04:52:59 +08:00
[ObjC] Remove _Atomic from return type and parameter type of objective-c properties. This fixes an assert in CodeGen that fires when the getter and setter functions for an objective-c property of type _Atomic(_Bool) are synthesized. rdar://problem/26322972 Differential Revision: http://reviews.llvm.org/D20407 llvm-svn: 270808
2016-05-26 08:37:30 +08:00
// The getter returns the declared property type with all qualifiers
// removed.
QualType resultTy = property->getType().getAtomicUnqualifiedType();
Implement the 'null_resettable' attribute for Objective-C properties. 'null_resettable' properties are those whose getters return nonnull but whose setters take nil, to "reset" the property to some default. Implements rdar://problem/19051334. llvm-svn: 240155
2015-06-20 02:14:46 +08:00
// If the property is null_resettable, the getter returns nonnull.
if (property->getPropertyAttributes() &
ObjCPropertyDecl::OBJC_PR_null_resettable) {
QualType modifiedTy = resultTy;
Replace __double_underscored type nullability qualifiers with _Uppercase_underscored Addresses a conflict with glibc's __nonnull macro by renaming the type nullability qualifiers as follows: __nonnull -> _Nonnull __nullable -> _Nullable __null_unspecified -> _Null_unspecified This is the major part of rdar://problem/21530726, but does not yet provide the Darwin-specific behavior for the old names. llvm-svn: 240596
2015-06-25 06:02:08 +08:00
if (auto nullability = AttributedType::stripOuterNullability(modifiedTy)) {
Implement the 'null_resettable' attribute for Objective-C properties. 'null_resettable' properties are those whose getters return nonnull but whose setters take nil, to "reset" the property to some default. Implements rdar://problem/19051334. llvm-svn: 240155
2015-06-20 02:14:46 +08:00
if (*nullability == NullabilityKind::Unspecified)
resultTy = Context.getAttributedType(AttributedType::attr_nonnull,
modifiedTy, modifiedTy);
}
}
Correctly register the class extension as the lexical DeclContext for ObjC methods declared with @property in class extensions. This matches the behavior for setters. Also pass the class extension to ProcessPropertyDecl as the lexical DeclContext, even when not redeclaring the @property. This fixes the remaining issues in <rdar://problem/7410145>. llvm-svn: 114477
2010-09-22 04:52:59 +08:00
GetterMethod = ObjCMethodDecl::Create(Context, Loc, Loc,
property->getGetterName(),
Implement the 'null_resettable' attribute for Objective-C properties. 'null_resettable' properties are those whose getters return nonnull but whose setters take nil, to "reset" the property to some default. Implements rdar://problem/19051334. llvm-svn: 240155
2015-06-20 02:14:46 +08:00
resultTy, nullptr, CD,
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
!IsClassProperty, /*isVariadic=*/false,
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
/*isPropertyAccessor=*/true,
Mark objc methods that are implicitly declared for properties (not user-declared) as implicit. This results in libclang ignoring such methods. llvm-svn: 137852
2011-08-18 03:25:08 +08:00
/*isImplicitlyDeclared=*/true, /*isDefined=*/false,
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
(property->getPropertyImplementation() ==
ObjCPropertyDecl::Optional) ?
ObjCMethodDecl::Optional :
ObjCMethodDecl::Required);
CD->addDecl(GetterMethod);
Propagate the deprecated and unavailable attributes from a @property declaration to the autogenerated methods. I'm uncertain whether this should apply to attributes in general, but these are a reasonable core. Implements rdar://problem/8617301 llvm-svn: 118676
2010-11-10 15:01:40 +08:00
AddPropertyAttrs(*this, GetterMethod, property);
objc-arc/mrc: Allow ns_returns_not_retained attribute on properties to turn off warning on those properties which follow Cocoa naming convention for retaining objects and yet they were not meant for such purposes. Also, perform consistancy checking for declared getters of such methods. // rdar://9636091 llvm-svn: 133849
2011-06-25 08:17:46 +08:00
if (property->hasAttr<NSReturnsNotRetainedAttr>())
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
GetterMethod->addAttr(NSReturnsNotRetainedAttr::CreateImplicit(Context,
Loc));
ObjectiveC: Allow NS_RETURNS_INNER_POINTER annotation of ObjectiveC properties to mean annotation of NS_RETURNS_INNER_POINTER on its synthesized getter. This also facilitates more migration to properties when methods are annotated with NS_RETURNS_INNER_POINTER. // rdar://14990439 llvm-svn: 191009
2013-09-20 00:37:20 +08:00
if (property->hasAttr<ObjCReturnsInnerPointerAttr>())
GetterMethod->addAttr(
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
ObjCReturnsInnerPointerAttr::CreateImplicit(Context, Loc));
ObjectiveC. support "section" attribute on properties and methods. rdar://15450637 llvm-svn: 197625
2013-12-19 07:09:57 +08:00
if (const SectionAttr *SA = property->getAttr<SectionAttr>())
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
GetterMethod->addAttr(
SectionAttr::CreateImplicit(Context, SectionAttr::GNU_section,
SA->getName(), Loc));
Be sure to check ARC conventions on the implicit method declarations of a property just in case the property's getter happens to be +1. We won't synthesize a getter for such a property, but we will allow the user to define a +1 method for it. rdar://13115896 llvm-svn: 178731
2013-04-04 09:38:37 +08:00
if (getLangOpts().ObjCAutoRefCount)
CheckARCMethodDecl(GetterMethod);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
} else
// A user declared getter will be synthesize when @synthesize of
// the property with the same name is seen in the @implementation
Rename ObjCMethodDecl::isSynthesized to isPropertyAccessor. This more accurately reflects its use: this flag is set when a method matches the getter or setter name for a property in the same class, and does not actually specify whether or not the definition of the method will be synthesized (either implicitly or explicitly with @synthesize). This renames the setter and backing field as well, and changes the (soon-to-be-obsolete?) XML dump format to use 'property_accessor' instead of 'synthesized'. llvm-svn: 165626
2012-10-11 00:42:25 +08:00
GetterMethod->setPropertyAccessor(true);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
property->setGetterMethodDecl(GetterMethod);
// Skip setter if property is read-only.
if (!property->isReadOnly()) {
// Find the default setter and if one not found, add one.
if (!SetterMethod) {
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
// No instance/class method of same name as property setter name was
// found.
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
// Declare a setter method and add it to the list of methods
// for this class.
Stop back-patching 'readonly' Objective-C properties with 'readwrite' ones. A 'readonly' Objective-C property declared in the primary class can effectively be shadowed by a 'readwrite' property declared within an extension of that class, so long as the types and attributes of the two property declarations are compatible. Previously, this functionality was implemented by back-patching the original 'readonly' property to make it 'readwrite', destroying source information and causing some hideously redundant, incorrect code. Simplify the implementation to express how this should actually be modeled: as a separate property declaration in the extension that shadows (via the name lookup rules) the declaration in the primary class. While here, correct some broken Fix-Its, eliminate a pile of redundant code, clean up the ARC migrator's handling of properties declared in extensions, and fix debug info's naming of methods that come from categories. A wonderous side effect of doing this write is that it eliminates the "AddedObjCPropertyInClassExtension" method from the AST mutation listener, which in turn eliminates the last place where we rewrite entire declarations in a chained PCH file or a module file. This change (which fixes rdar://problem/18475765) will allow us to eliminate the rewritten-decls logic from the serialization library, and fixes a crash (rdar://problem/23247794) illustrated by the test/PCH/chain-categories.m example. llvm-svn: 251874
2015-11-03 09:15:46 +08:00
SourceLocation Loc = property->getLocation();
For ObjCPropertyDecls in class extensions, use the class extension as the lexical DeclContext for newly created ObjCMethodDecls. Further, use the location of the new property declaration as the location of new ObjCMethodDecls (if they didn't previously exist). This fixes more of the issues reported in <rdar://problem/7410145>. llvm-svn: 114456
2010-09-22 02:28:43 +08:00
SetterMethod =
Allow getting all source locations of selector identifiers in a ObjCMethodDecl. Instead of always storing all source locations for the selector identifiers we check whether all the identifiers are in a "standard" position; "standard" position is -Immediately before the arguments: -(id)first:(int)x second:(int)y; -With a space between the arguments: -(id)first: (int)x second: (int)y; -For nullary selectors, immediately before ';': -(void)release; In such cases we infer the locations instead of storing them. llvm-svn: 140989
2011-10-03 14:37:04 +08:00
ObjCMethodDecl::Create(Context, Loc, Loc,
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
property->getSetterName(), Context.VoidTy,
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
nullptr, CD, !IsClassProperty,
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
/*isVariadic=*/false,
Rename ObjCMethodDecl::isSynthesized to isPropertyAccessor. This more accurately reflects its use: this flag is set when a method matches the getter or setter name for a property in the same class, and does not actually specify whether or not the definition of the method will be synthesized (either implicitly or explicitly with @synthesize). This renames the setter and backing field as well, and changes the (soon-to-be-obsolete?) XML dump format to use 'property_accessor' instead of 'synthesized'. llvm-svn: 165626
2012-10-11 00:42:25 +08:00
/*isPropertyAccessor=*/true,
Mark objc methods that are implicitly declared for properties (not user-declared) as implicit. This results in libclang ignoring such methods. llvm-svn: 137852
2011-08-18 03:25:08 +08:00
/*isImplicitlyDeclared=*/true,
/*isDefined=*/false,
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
(property->getPropertyImplementation() ==
ObjCPropertyDecl::Optional) ?
For ObjCPropertyDecls in class extensions, use the class extension as the lexical DeclContext for newly created ObjCMethodDecls. Further, use the location of the new property declaration as the location of new ObjCMethodDecls (if they didn't previously exist). This fixes more of the issues reported in <rdar://problem/7410145>. llvm-svn: 114456
2010-09-22 02:28:43 +08:00
ObjCMethodDecl::Optional :
ObjCMethodDecl::Required);
[ObjC] Remove _Atomic from return type and parameter type of objective-c properties. This fixes an assert in CodeGen that fires when the getter and setter functions for an objective-c property of type _Atomic(_Bool) are synthesized. rdar://problem/26322972 Differential Revision: http://reviews.llvm.org/D20407 llvm-svn: 270808
2016-05-26 08:37:30 +08:00
// Remove all qualifiers from the setter's parameter type.
QualType paramTy =
property->getType().getUnqualifiedType().getAtomicUnqualifiedType();
Implement the 'null_resettable' attribute for Objective-C properties. 'null_resettable' properties are those whose getters return nonnull but whose setters take nil, to "reset" the property to some default. Implements rdar://problem/19051334. llvm-svn: 240155
2015-06-20 02:14:46 +08:00
// If the property is null_resettable, the setter accepts a
// nullable value.
if (property->getPropertyAttributes() &
ObjCPropertyDecl::OBJC_PR_null_resettable) {
QualType modifiedTy = paramTy;
if (auto nullability = AttributedType::stripOuterNullability(modifiedTy)){
if (*nullability == NullabilityKind::Unspecified)
paramTy = Context.getAttributedType(AttributedType::attr_nullable,
modifiedTy, modifiedTy);
}
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
// Invent the arguments for the setter. We don't bother making a
// nice name for the argument.
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
ParmVarDecl *Argument = ParmVarDecl::Create(Context, SetterMethod,
Loc, Loc,
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
property->getIdentifier(),
Implement the 'null_resettable' attribute for Objective-C properties. 'null_resettable' properties are those whose getters return nonnull but whose setters take nil, to "reset" the property to some default. Implements rdar://problem/19051334. llvm-svn: 240155
2015-06-20 02:14:46 +08:00
paramTy,
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
/*TInfo=*/nullptr,
De-memberify the VarDecl and FunctionDecl StorageClass enums. This lets us remove Sema.h's dependency on Expr.h and Decl.h. llvm-svn: 112156
2010-08-26 11:08:43 +08:00
SC_None,
[C++11] Use 'nullptr'. Sema edition. llvm-svn: 209613
2014-05-26 14:22:03 +08:00
nullptr);
Replace ArrayRef<T>() with None, now that we have an implicit ArrayRef constructor from None Patch by Robert Wilhelm. llvm-svn: 181139
2013-05-05 08:41:58 +08:00
SetterMethod->setMethodParams(Context, Argument, None);
Propagate the deprecated and unavailable attributes from a @property declaration to the autogenerated methods. I'm uncertain whether this should apply to attributes in general, but these are a reasonable core. Implements rdar://problem/8617301 llvm-svn: 118676
2010-11-10 15:01:40 +08:00
AddPropertyAttrs(*this, SetterMethod, property);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
CD->addDecl(SetterMethod);
ObjectiveC. support "section" attribute on properties and methods. rdar://15450637 llvm-svn: 197625
2013-12-19 07:09:57 +08:00
if (const SectionAttr *SA = property->getAttr<SectionAttr>())
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
SetterMethod->addAttr(
SectionAttr::CreateImplicit(Context, SectionAttr::GNU_section,
SA->getName(), Loc));
Be sure to check ARC conventions on the implicit method declarations of a property just in case the property's getter happens to be +1. We won't synthesize a getter for such a property, but we will allow the user to define a +1 method for it. rdar://13115896 llvm-svn: 178731
2013-04-04 09:38:37 +08:00
// It's possible for the user to have set a very odd custom
// setter selector that causes it to have a method family.
if (getLangOpts().ObjCAutoRefCount)
CheckARCMethodDecl(SetterMethod);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
} else
// A user declared setter will be synthesize when @synthesize of
// the property with the same name is seen in the @implementation
Rename ObjCMethodDecl::isSynthesized to isPropertyAccessor. This more accurately reflects its use: this flag is set when a method matches the getter or setter name for a property in the same class, and does not actually specify whether or not the definition of the method will be synthesized (either implicitly or explicitly with @synthesize). This renames the setter and backing field as well, and changes the (soon-to-be-obsolete?) XML dump format to use 'property_accessor' instead of 'synthesized'. llvm-svn: 165626
2012-10-11 00:42:25 +08:00
SetterMethod->setPropertyAccessor(true);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
property->setSetterMethodDecl(SetterMethod);
}
// Add any synthesized methods to the global pool. This allows us to
// handle the following, which is supported by GCC (and part of the design).
//
// @interface Foo
// @property double bar;
// @end
//
// void thisIsUnfortunate() {
// id foo;
// double bar = [foo bar];
// }
//
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
if (!IsClassProperty) {
if (GetterMethod)
AddInstanceMethodToGlobalPool(GetterMethod);
if (SetterMethod)
AddInstanceMethodToGlobalPool(SetterMethod);
ObjC: add getter/setter for class properties to global pool. rdar://problem/25323072 llvm-svn: 264196
2016-03-24 05:39:31 +08:00
} else {
if (GetterMethod)
AddFactoryMethodToGlobalPool(GetterMethod);
if (SetterMethod)
AddFactoryMethodToGlobalPool(SetterMethod);
Class Property: create accessors (class methods) for class property. Change a few places where we assume property accessors can only be instance methods. rdar://23891898 llvm-svn: 258980
2016-01-28 04:10:32 +08:00
}
[AST/libclang] Speed up clang_getOverriddenCursors() considerably by reserving a bit in ObjCMethodDecl to indicate whether the method does not override any other method, which is the majority of cases. That way we can avoid unnecessary work doing lookups, especially when PCH is involved. rdar://11360082 llvm-svn: 156476
2012-05-10 00:12:57 +08:00
ObjCInterfaceDecl *CurrentClass = dyn_cast<ObjCInterfaceDecl>(CD);
if (!CurrentClass) {
if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(CD))
CurrentClass = Cat->getClassInterface();
else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(CD))
CurrentClass = Impl->getClassInterface();
}
if (GetterMethod)
CheckObjCMethodOverrides(GetterMethod, CurrentClass, Sema::RTC_Unknown);
if (SetterMethod)
CheckObjCMethodOverrides(SetterMethod, CurrentClass, Sema::RTC_Unknown);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
void Sema::CheckObjCPropertyAttributes(Decl *PDecl,
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
SourceLocation Loc,
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
unsigned &Attributes,
objective-c: Normally, a property cannot be both 'readonly' and having a "write" attribute (copy/retain/etc.). But, property declaration in primary class and protcols are tentative as they may be overridden into a 'readwrite' property in class extensions. Postpone diagnosing such warnings until the class implementation is seen. // rdar://11656982 llvm-svn: 158869
2012-06-21 06:57:42 +08:00
bool propertyInPrimaryClass) {
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
// FIXME: Improve the reported location.
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
if (!PDecl || PDecl->isInvalidDecl())
Fix possible null dereference by bailing out of CheckObjCPropertyAttributes() early if the Decl* is null. llvm-svn: 100483
2010-04-06 06:39:42 +08:00
return;
ObjectiveC: Warn when 'readonly' property has explicit ownership attribute (such as 'copy', 'assign' etc.) // rdar://15131088 llvm-svn: 192115
2013-10-08 01:20:02 +08:00
if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
(Attributes & ObjCDeclSpec::DQ_PR_readwrite))
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "readonly" << "readwrite";
Fix possible null dereference by bailing out of CheckObjCPropertyAttributes() early if the Decl* is null. llvm-svn: 100483
2010-04-06 06:39:42 +08:00
ObjCPropertyDecl *PropertyDecl = cast<ObjCPropertyDecl>(PDecl);
ObjectiveC: Warn when 'readonly' property has explicit ownership attribute (such as 'copy', 'assign' etc.) // rdar://15131088 llvm-svn: 192115
2013-10-08 01:20:02 +08:00
QualType PropertyTy = PropertyDecl->getType();
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Check for copy or retain on non-object types.
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if ((Attributes & (ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong)) &&
!PropertyTy->isObjCRetainableType() &&
Replacing calls to getAttr with calls to hasAttr for clarity. No functional change intended -- this only replaces Boolean uses of getAttr. llvm-svn: 197648
2013-12-19 10:39:40 +08:00
!PropertyDecl->hasAttr<ObjCNSObjectAttr>()) {
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Diag(Loc, diag::err_objc_property_requires_object)
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
<< (Attributes & ObjCDeclSpec::DQ_PR_weak ? "weak" :
Attributes & ObjCDeclSpec::DQ_PR_copy ? "copy" : "retain (or strong)");
Attributes &= ~(ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong);
Don't crash on attempts to synthesize an invalid property. rdar://problem/10904479 llvm-svn: 151089
2012-02-22 05:48:05 +08:00
PropertyDecl->setInvalidDecl();
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Check for more than one of { assign, copy, retain }.
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_assign) {
if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "assign" << "copy";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "assign" << "retain";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "assign" << "strong";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().ObjCAutoRefCount &&
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
(Attributes & ObjCDeclSpec::DQ_PR_weak)) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "assign" << "weak";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
Replacing calls to getAttr with calls to hasAttr for clarity. No functional change intended -- this only replaces Boolean uses of getAttr. llvm-svn: 197648
2013-12-19 10:39:40 +08:00
if (PropertyDecl->hasAttr<IBOutletCollectionAttr>())
Objective-C: Warn when IBOutletCollection property is declared to have 'assign' attribute. // rdar://14212998 llvm-svn: 184863
2013-06-26 01:34:50 +08:00
Diag(Loc, diag::warn_iboutletcollection_property_assign);
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
} else if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) {
if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "unsafe_unretained" << "copy";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "unsafe_unretained" << "retain";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "unsafe_unretained" << "strong";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().ObjCAutoRefCount &&
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
(Attributes & ObjCDeclSpec::DQ_PR_weak)) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "unsafe_unretained" << "weak";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
} else if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "copy" << "retain";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "copy" << "strong";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_weak) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "copy" << "weak";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
(Attributes & ObjCDeclSpec::DQ_PR_weak)) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "retain" << "weak";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
else if ((Attributes & ObjCDeclSpec::DQ_PR_strong) &&
(Attributes & ObjCDeclSpec::DQ_PR_weak)) {
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "strong" << "weak";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Introduced pragmas for audited nullability regions. Introduce the clang pragmas "assume_nonnull begin" and "assume_nonnull end" in which we make default assumptions about the nullability of many unannotated pointers: - Single-level pointers are inferred to __nonnull - NSError** in a (function or method) parameter list is inferred to NSError * __nullable * __nullable. - CFErrorRef * in a (function or method) parameter list is inferred to CFErrorRef __nullable * __nullable. - Other multi-level pointers are never inferred to anything. Implements rdar://problem/19191042. llvm-svn: 240156
2015-06-20 02:25:57 +08:00
if (Attributes & ObjCDeclSpec::DQ_PR_weak) {
Extend type nullability qualifiers for Objective-C. Introduce context-sensitive, non-underscored nullability specifiers (nonnull, nullable, null_unspecified) for Objective-C method return types, method parameter types, and properties. Introduce Objective-C-specific semantics, including computation of the nullability of the result of a message send, merging of nullability information from the @interface of a class into its @implementation, etc . This is the Objective-C part of rdar://problem/18868820. llvm-svn: 240154
2015-06-20 02:14:38 +08:00
// 'weak' and 'nonnull' are mutually exclusive.
if (auto nullability = PropertyTy->getNullability(Context)) {
if (*nullability == NullabilityKind::NonNull)
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "nonnull" << "weak";
}
}
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if ((Attributes & ObjCDeclSpec::DQ_PR_atomic) &&
(Attributes & ObjCDeclSpec::DQ_PR_nonatomic)) {
objc: err on a property designated both atomic and nonatomic. // rdar://10260017 llvm-svn: 141580
2011-10-11 05:53:24 +08:00
Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
<< "atomic" << "nonatomic";
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
Attributes &= ~ObjCDeclSpec::DQ_PR_atomic;
objc: err on a property designated both atomic and nonatomic. // rdar://10260017 llvm-svn: 141580
2011-10-11 05:53:24 +08:00
}
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// Warn if user supplied no assignment attribute, property is
// readwrite, and this is an object type.
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
if (!getOwnershipRule(Attributes) && PropertyTy->isObjCRetainableType()) {
if (Attributes & ObjCDeclSpec::DQ_PR_readonly) {
// do nothing
} else if (getLangOpts().ObjCAutoRefCount) {
// With arc, @property definitions should default to strong when
// not specified.
PropertyDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
} else if (PropertyTy->isObjCObjectPointerType()) {
In non-gc, non-arc mode, property of 'Class' type variety is treated as a 'void *'. No need to issue warning reserved for objc object properties. // rdar://10565506 llvm-svn: 147504
2012-01-04 08:31:53 +08:00
bool isAnyClassTy =
(PropertyTy->isObjCClassType() ||
PropertyTy->isObjCQualifiedClassType());
// In non-gc, non-arc mode, 'Class' is treated as a 'void *' no need to
// issue any warning.
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (isAnyClassTy && getLangOpts().getGC() == LangOptions::NonGC)
In non-gc, non-arc mode, property of 'Class' type variety is treated as a 'void *'. No need to issue warning reserved for objc object properties. // rdar://10565506 llvm-svn: 147504
2012-01-04 08:31:53 +08:00
;
objective-C: don't warn about class extension property's missing 'assign' attribute as it is determined by its overridden property in primary class. // rdar://12214070 llvm-svn: 164080
2012-09-18 07:57:35 +08:00
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.
objc-arc: @property definitions should default to (strong) when not specified. // rdar://9971982 llvm-svn: 138062
2011-08-20 03:28:44 +08:00
// Skip this warning in gc-only mode.
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().getGC() != LangOptions::GCOnly)
objc-arc: @property definitions should default to (strong) when not specified. // rdar://9971982 llvm-svn: 138062
2011-08-20 03:28:44 +08:00
Diag(Loc, diag::warn_objc_property_no_assignment_attribute);
[ARC] Complain about property without storage attribute when @synthesizing it, not at its declaration. For this sample: @interface Foo @property id x; @end we get: t.m:2:1: error: ARC forbids properties of Objective-C objects with unspecified storage attribute @property id x; ^ 1 error generated. The error should be imposed on the implementor of the interface, not the user. If the user uses a header of a non-ARC library whose source code he does not have, we are basically asking him to go change the header of the library (bad in general), possible overriding how the property is implemented if he gets confused and says "Oh I'll just add 'copy' then" (even worse). Second issue is that we don't emit any error for 'readonly' properties, e.g: @interface Foo @property (readonly) id x; // no error here @end @implementation Foo @synthesize x; // no error here too @end We should give an error when the implementor is @synthesizing a property which doesn't have any storage specifier; this is when the explicit specifier is important, because we are going to create an ivar and we want its ownership to be explicit. Related improvements: -OBJC_PR_unsafe_unretained turned out to not fit in ObjCPropertyDecl's bitfields, fix it. -For properties of extension classes don't drop PropertyAttributesAsWritten values. -Have PropertyAttributesAsWritten actually only reflect what the user wrote rdar://9756610. llvm-svn: 134960
2011-07-12 12:30:16 +08:00
objc-arc: @property definitions should default to (strong) when not specified. // rdar://9971982 llvm-svn: 138062
2011-08-20 03:28:44 +08:00
// If non-gc code warn that this is likely inappropriate.
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (getLangOpts().getGC() == LangOptions::NonGC)
objc-arc: @property definitions should default to (strong) when not specified. // rdar://9971982 llvm-svn: 138062
2011-08-20 03:28:44 +08:00
Diag(Loc, diag::warn_objc_property_default_assign_on_object);
In non-gc, non-arc mode, property of 'Class' type variety is treated as a 'void *'. No need to issue warning reserved for objc object properties. // rdar://10565506 llvm-svn: 147504
2012-01-04 08:31:53 +08:00
}
Be more conservative about diagnosing "incorrect" uses of __weak: allow them to be written in certain kinds of user declaration and diagnose on the use-site instead. Also, improve and fix some diagnostics relating to __weak and properties. rdar://23228631 llvm-svn: 251384
2015-10-27 12:54:50 +08:00
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
// FIXME: Implement warning dependent on NSCopying being
// implemented. See also:
// <rdar://5168496&4855821&5607453&5096644&4947311&5698469&4947014&5168496>
// (please trim this list while you are at it).
}
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if (!(Attributes & ObjCDeclSpec::DQ_PR_copy)
&&!(Attributes & ObjCDeclSpec::DQ_PR_readonly)
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
&& getLangOpts().getGC() == LangOptions::GCOnly
Move 'ActOn' methods to the beginning of the file so we can clearly see the parser entry points. llvm-svn: 98319
2010-03-12 08:46:40 +08:00
&& PropertyTy->isBlockPointerType())
Diag(Loc, diag::warn_objc_property_copy_missing_on_block);
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
!(Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
!(Attributes & ObjCDeclSpec::DQ_PR_strong) &&
objc-arc: warn when a 'retain' block property is declared which does not force a 'copy' of the block literal object. // rdar://9829425 llvm-svn: 139706
2011-09-15 02:03:46 +08:00
PropertyTy->isBlockPointerType())
Diag(Loc, diag::warn_objc_property_retain_of_block);
objc: warn if a readonly property has a setter attribute too. // rdar://10357768 llvm-svn: 143518
2011-11-02 07:02:16 +08:00
Revert r170500. It over-zealously converted *ALL* things named Attributes, which is wrong here. llvm-svn: 170721
2012-12-21 03:22:21 +08:00
if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
(Attributes & ObjCDeclSpec::DQ_PR_setter))
objc: warn if a readonly property has a setter attribute too. // rdar://10357768 llvm-svn: 143518
2011-11-02 07:02:16 +08:00
Diag(Loc, diag::warn_objc_readonly_property_has_setter);
Split Sema logic for ObjC @property and @synthesize into a separate file. llvm-svn: 98317
2010-03-12 08:38:38 +08:00
}