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/SemaDeclObjC.cpp

2690 lines
107 KiB
C++
Raw Normal View History

split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
//===--- SemaDeclObjC.cpp - Semantic Analysis for ObjC Declarations -------===//
//
// The LLVM Compiler Infrastructure
//
Don't attribute in file headers anymore. See llvmdev for the discussion of this change. llvm-svn: 45410
2007-12-30 03:59:25 +08:00
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
//
//===----------------------------------------------------------------------===//
//
// This file implements semantic analysis for Objective C 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"
Move Sema's headers into include/clang/Sema, renaming a few along the way. llvm-svn: 110945
2010-08-13 04:07:10 +08:00
#include "clang/Sema/Lookup.h"
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
#include "clang/Sema/ExternalSemaSource.h"
More header elimination. The goal of all this is to allow Parser to #include Sema.h while keeping all the AST declarations opaque. That may not be reasonably attainable, though. llvm-svn: 111907
2010-08-24 16:50:51 +08:00
#include "clang/Sema/Scope.h"
Split FunctionScopeInfo and BlockScopeInfo into their own header. llvm-svn: 112038
2010-08-25 16:40:02 +08:00
#include "clang/Sema/ScopeInfo.h"
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
#include "clang/AST/ASTConsumer.h"
Fix <rdar://problem/6497608> clang does not catch ivar type mismatches in @implementation. llvm-svn: 65948
2009-03-03 22:49:36 +08:00
#include "clang/AST/Expr.h"
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
#include "clang/AST/ExprObjC.h"
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"
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
#include "clang/Basic/SourceManager.h"
Another step in the process of making the parser depend on Sema: - move DeclSpec &c into the Sema library - move ParseAST into the Parse library Reflect this change in a thousand different includes. Reflect this change in the link orders. llvm-svn: 111667
2010-08-21 02:27:03 +08:00
#include "clang/Sema/DeclSpec.h"
Remove the DenseSet dependency from Sema.h. llvm-svn: 112030
2010-08-25 15:03:20 +08:00
#include "llvm/ADT/DenseSet.h"
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
using namespace clang;
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
/// Check whether the given method, which must be in the 'init'
/// family, is a valid member of that family.
///
/// \param receiverTypeIfCall - if null, check this as if declaring it;
/// if non-null, check this as if making a call to it with the given
/// receiver type
///
/// \return true to indicate that there was an error and appropriate
/// actions were taken
bool Sema::checkInitMethod(ObjCMethodDecl *method,
QualType receiverTypeIfCall) {
if (method->isInvalidDecl()) return true;
// This castAs is safe: methods that don't return an object
// pointer won't be inferred as inits and will reject an explicit
// objc_method_family(init).
// We ignore protocols here. Should we? What about Class?
const ObjCObjectType *result = method->getResultType()
->castAs<ObjCObjectPointerType>()->getObjectType();
if (result->isObjCId()) {
return false;
} else if (result->isObjCClass()) {
// fall through: always an error
} else {
ObjCInterfaceDecl *resultClass = result->getInterface();
assert(resultClass && "unexpected object type!");
// It's okay for the result type to still be a forward declaration
// if we're checking an interface declaration.
if (resultClass->isForwardDecl()) {
if (receiverTypeIfCall.isNull() &&
!isa<ObjCImplementationDecl>(method->getDeclContext()))
return false;
// Otherwise, we try to compare class types.
} else {
// If this method was declared in a protocol, we can't check
// anything unless we have a receiver type that's an interface.
const ObjCInterfaceDecl *receiverClass = 0;
if (isa<ObjCProtocolDecl>(method->getDeclContext())) {
if (receiverTypeIfCall.isNull())
return false;
receiverClass = receiverTypeIfCall->castAs<ObjCObjectPointerType>()
->getInterfaceDecl();
// This can be null for calls to e.g. id<Foo>.
if (!receiverClass) return false;
} else {
receiverClass = method->getClassInterface();
assert(receiverClass && "method not associated with a class!");
}
// If either class is a subclass of the other, it's fine.
if (receiverClass->isSuperClassOf(resultClass) ||
resultClass->isSuperClassOf(receiverClass))
return false;
}
}
SourceLocation loc = method->getLocation();
// If we're in a system header, and this is not a call, just make
// the method unusable.
if (receiverTypeIfCall.isNull() && getSourceManager().isInSystemHeader(loc)) {
method->addAttr(new (Context) UnavailableAttr(loc, Context,
"init method returns a type unrelated to its receiver type"));
return true;
}
// Otherwise, it's an error.
Diag(loc, diag::err_arc_init_method_unrelated_result_type);
method->setInvalidDecl();
return true;
}
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
bool Sema::CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
const ObjCMethodDecl *Overridden,
bool IsImplementation) {
if (Overridden->hasRelatedResultType() &&
!NewMethod->hasRelatedResultType()) {
// This can only happen when the method follows a naming convention that
// implies a related result type, and the original (overridden) method has
// a suitable return type, but the new (overriding) method does not have
// a suitable return type.
QualType ResultType = NewMethod->getResultType();
SourceRange ResultTypeRange;
if (const TypeSourceInfo *ResultTypeInfo
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
= NewMethod->getResultTypeSourceInfo())
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
ResultTypeRange = ResultTypeInfo->getTypeLoc().getSourceRange();
// Figure out which class this method is part of, if any.
ObjCInterfaceDecl *CurrentClass
= dyn_cast<ObjCInterfaceDecl>(NewMethod->getDeclContext());
if (!CurrentClass) {
DeclContext *DC = NewMethod->getDeclContext();
if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(DC))
CurrentClass = Cat->getClassInterface();
else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(DC))
CurrentClass = Impl->getClassInterface();
else if (ObjCCategoryImplDecl *CatImpl
= dyn_cast<ObjCCategoryImplDecl>(DC))
CurrentClass = CatImpl->getClassInterface();
}
if (CurrentClass) {
Diag(NewMethod->getLocation(),
diag::warn_related_result_type_compatibility_class)
<< Context.getObjCInterfaceType(CurrentClass)
<< ResultType
<< ResultTypeRange;
} else {
Diag(NewMethod->getLocation(),
diag::warn_related_result_type_compatibility_protocol)
<< ResultType
<< ResultTypeRange;
}
Diag(Overridden->getLocation(), diag::note_related_result_type_overridden)
<< Overridden->getMethodFamily();
}
return false;
}
Document CheckObjCMethodOverrides llvm-svn: 132917
2011-06-14 00:07:18 +08:00
/// \brief Check for consistency between a given method declaration and the
/// methods it overrides within the class hierarchy.
///
/// This method walks the inheritance hierarchy starting at the given
/// declaration context (\p DC), invoking Sema::CheckObjCMethodOverride() with
/// the given new method (\p NewMethod) and any method it directly overrides
/// in the hierarchy. Sema::CheckObjCMethodOverride() is responsible for
/// checking consistency, e.g., among return types for methods that return a
/// related result type.
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
static bool CheckObjCMethodOverrides(Sema &S, ObjCMethodDecl *NewMethod,
DeclContext *DC,
bool SkipCurrent = true) {
if (!DC)
return false;
if (!SkipCurrent) {
// Look for this method. If we find it, we're done.
Selector Sel = NewMethod->getSelector();
bool IsInstance = NewMethod->isInstanceMethod();
DeclContext::lookup_const_iterator Meth, MethEnd;
for (llvm::tie(Meth, MethEnd) = DC->lookup(Sel); Meth != MethEnd; ++Meth) {
ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
if (MD && MD->isInstanceMethod() == IsInstance)
return S.CheckObjCMethodOverride(NewMethod, MD, false);
}
}
if (ObjCInterfaceDecl *Class = llvm::dyn_cast<ObjCInterfaceDecl>(DC)) {
// Look through categories.
for (ObjCCategoryDecl *Category = Class->getCategoryList();
Category; Category = Category->getNextClassCategory()) {
if (CheckObjCMethodOverrides(S, NewMethod, Category, false))
return true;
}
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
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
// Look through protocols.
for (ObjCList<ObjCProtocolDecl>::iterator I = Class->protocol_begin(),
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
IEnd = Class->protocol_end();
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
I != IEnd; ++I)
if (CheckObjCMethodOverrides(S, NewMethod, *I, false))
return true;
// Look in our superclass.
return CheckObjCMethodOverrides(S, NewMethod, Class->getSuperClass(),
false);
}
if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(DC)) {
// Look through protocols.
for (ObjCList<ObjCProtocolDecl>::iterator I = Category->protocol_begin(),
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
IEnd = Category->protocol_end();
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
I != IEnd; ++I)
if (CheckObjCMethodOverrides(S, NewMethod, *I, false))
return true;
return false;
}
if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(DC)) {
// Look through protocols.
for (ObjCList<ObjCProtocolDecl>::iterator I = Protocol->protocol_begin(),
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
IEnd = Protocol->protocol_end();
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
I != IEnd; ++I)
if (CheckObjCMethodOverrides(S, NewMethod, *I, false))
return true;
return false;
}
return false;
}
bool Sema::CheckObjCMethodOverrides(ObjCMethodDecl *NewMethod,
DeclContext *DC) {
if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(DC))
return ::CheckObjCMethodOverrides(*this, NewMethod, Class);
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
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(DC))
return ::CheckObjCMethodOverrides(*this, NewMethod, Category);
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
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(DC))
return ::CheckObjCMethodOverrides(*this, NewMethod, Protocol);
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
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(DC))
return ::CheckObjCMethodOverrides(*this, NewMethod,
Impl->getClassInterface());
if (ObjCCategoryImplDecl *CatImpl = dyn_cast<ObjCCategoryImplDecl>(DC))
return ::CheckObjCMethodOverrides(*this, NewMethod,
CatImpl->getClassInterface());
return ::CheckObjCMethodOverrides(*this, NewMethod, CurContext);
}
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
/// \brief Check a method declaration for compatibility with the Objective-C
/// ARC conventions.
static bool CheckARCMethodDecl(Sema &S, ObjCMethodDecl *method) {
ObjCMethodFamily family = method->getMethodFamily();
switch (family) {
case OMF_None:
case OMF_dealloc:
case OMF_retain:
case OMF_release:
case OMF_autorelease:
case OMF_retainCount:
case OMF_self:
return false;
case OMF_init:
// If the method doesn't obey the init rules, don't bother annotating it.
if (S.checkInitMethod(method, QualType()))
return true;
method->addAttr(new (S.Context) NSConsumesSelfAttr(SourceLocation(),
S.Context));
// Don't add a second copy of this attribute, but otherwise don't
// let it be suppressed.
if (method->hasAttr<NSReturnsRetainedAttr>())
return false;
break;
case OMF_alloc:
case OMF_copy:
case OMF_mutableCopy:
case OMF_new:
if (method->hasAttr<NSReturnsRetainedAttr>() ||
method->hasAttr<NSReturnsNotRetainedAttr>() ||
method->hasAttr<NSReturnsAutoreleasedAttr>())
return false;
break;
objc-arc: enforce performSelector rules in rejecting retaining selectors passed to it, and unknown selectors causing potential leak. // rdar://9659270 llvm-svn: 134449
2011-07-06 06:38:59 +08:00
case OMF_performSelector:
// we don't annotate performSelector's
return true;
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
}
method->addAttr(new (S.Context) NSReturnsRetainedAttr(SourceLocation(),
S.Context));
return false;
}
Refactoring of code to issue warning on implemented deprecated class and methods in objective-c. llvm-svn: 125573
2011-02-16 01:49:58 +08:00
static void DiagnoseObjCImplementedDeprecations(Sema &S,
NamedDecl *ND,
SourceLocation ImplLoc,
int select) {
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
if (ND && ND->isDeprecated()) {
Check for deprecated implementation unconditionally. Warning and its note will be ignored in default case. llvm-svn: 125621
2011-02-16 08:30:31 +08:00
S.Diag(ImplLoc, diag::warn_deprecated_def) << select;
Refactoring of code to issue warning on implemented deprecated class and methods in objective-c. llvm-svn: 125573
2011-02-16 01:49:58 +08:00
if (select == 0)
S.Diag(ND->getLocation(), diag::note_method_declared_at);
else
S.Diag(ND->getLocation(), diag::note_previous_decl) << "class";
}
}
Minor name change (move the ObjC prefix to a more appropriate place). llvm-svn: 65695
2009-03-01 00:59:13 +08:00
/// ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
/// and user declared, in the method definition's AST.
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
void Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, Decl *D) {
Replace CurFunctionDecl and CurMethodDecl with methods getCurFunctionDecl() and getCurMethodDecl() that return the appropriate Decl through CurContext. llvm-svn: 52852
2008-06-28 14:07:14 +08:00
assert(getCurMethodDecl() == 0 && "Method parsing confused");
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Move fix in r54013 from the parser to sema. llvm-svn: 54032
2008-07-26 01:57:26 +08:00
// If we don't have a valid method decl, simply return.
if (!MDecl)
return;
Improve how we find private method decls. This involved: - Changed Sema::ObjcActOnStartOfMethodDef() to register the methods with the global pools. - Changed Sema::ActOnInstanceMessage() to look in global pools (should be much less error prone). - Added a test case to message.m (for lookup that was broken). Misc changes while I was investigating this... - Changed Sema::ActOnAtEnd() to call AddFactoryMethodToGlobalPool (this looked like a cut/paste error). - Added a comment and tweaked another where I was using the first person. llvm-svn: 45142
2007-12-18 09:30:32 +08:00
// Allow the rest of sema to find private method decl implementations.
Provide a new kind of iterator, the specific_decl_iterator, that filters the decls seen by decl_iterator with two criteria: the dynamic type of the declaration and a run-time predicate described by a member function. This simplifies EnumDecl, RecordDecl, and ObjCContainerDecl considerably. It has no measurable performance impact. llvm-svn: 61994
2009-01-10 01:18:27 +08:00
if (MDecl->isInstanceMethod())
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
AddInstanceMethodToGlobalPool(MDecl, true);
Improve how we find private method decls. This involved: - Changed Sema::ObjcActOnStartOfMethodDef() to register the methods with the global pools. - Changed Sema::ActOnInstanceMessage() to look in global pools (should be much less error prone). - Added a test case to message.m (for lookup that was broken). Misc changes while I was investigating this... - Changed Sema::ActOnAtEnd() to call AddFactoryMethodToGlobalPool (this looked like a cut/paste error). - Added a comment and tweaked another where I was using the first person. llvm-svn: 45142
2007-12-18 09:30:32 +08:00
else
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
AddFactoryMethodToGlobalPool(MDecl, true);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Allow all of Sema to see that we are entering a method definition.
Unifies the name-lookup mechanisms used in various parts of the AST and separates lexical name lookup from qualified name lookup. In particular: * Make DeclContext the central data structure for storing and looking up declarations within existing declarations, e.g., members of structs/unions/classes, enumerators in C++0x enums, members of C++ namespaces, and (later) members of Objective-C interfaces/implementations. DeclContext uses a lazily-constructed data structure optimized for fast lookup (array for small contexts, hash table for larger contexts). * Implement C++ qualified name lookup in terms of lookup into DeclContext. * Implement C++ unqualified name lookup in terms of qualified+unqualified name lookup (since unqualified lookup is not purely lexical in C++!) * Limit the use of the chains of declarations stored in IdentifierInfo to those names declared lexically. * Eliminate CXXFieldDecl, collapsing its behavior into FieldDecl. (FieldDecl is now a ScopedDecl). * Make RecordDecl into a DeclContext and eliminates its Members/NumMembers fields (since one can just iterate through the DeclContext to get the fields). llvm-svn: 60878
2008-12-12 00:49:14 +08:00
PushDeclContext(FnBodyScope, MDecl);
Keep an explicit stack of function and block scopes, each element of which has the label map, switch statement stack, etc. Previously, we had a single set of maps in Sema (for the function) along with a stack of block scopes. However, this lead to funky behavior with nested functions, e.g., in the member functions of local classes. The explicit-stack approach is far cleaner, and we retain a 1-element cache so that we're not malloc/free'ing every time we enter a function. Fixes PR6382. Also, tweaked the unused-variable warning suppression logic to look at errors within a given Scope rather than within a given function. The prior code wasn't looking at the right number-of-errors count when dealing with blocks, since the block's count would be deallocated before we got to ActOnPopScope. This approach works with nested blocks/functions, and gives tighter error recovery. llvm-svn: 97518
2010-03-02 07:15:13 +08:00
PushFunctionScope();
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Create Decl objects for each parameter, entrring them in the scope for
// binding to their use.
// Insert the invisible arguments, self and _cmd!
Support for implementation of property in the case where the synthesis is in an implementation of s subclass of a super class where the property has been declared. llvm-svn: 60792
2008-12-10 04:23:04 +08:00
MDecl->createImplicitParams(Context, MDecl->getClassInterface());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Move implicit Obj-C param creation into ObjCMethodDecl. - Add ObjCMethodDecl::createImplicitParams. - Remove ObjCMethodDecl::set{Self,Cmd}Decl - Remove Sema::CreateImplicitParameter No (intended) functionality change. llvm-svn: 55356
2008-08-26 14:07:48 +08:00
PushOnScopeChains(MDecl->getSelfDecl(), FnBodyScope);
PushOnScopeChains(MDecl->getCmdDecl(), FnBodyScope);
Add support for C++ default arguments, and rework Parse-Sema interaction for function parameters, fixing PR2046. Patch by Doug Gregor! llvm-svn: 49369
2008-04-08 12:40:51 +08:00
Several improvements from Doug Gregor related to default argument handling. I'll fix up the c89 (void) thing next. llvm-svn: 49459
2008-04-10 10:22:51 +08:00
// Introduce all of the other parameters into this scope.
remove some more methods from objc decls, using the iterator interfaces more consistently. llvm-svn: 65138
2009-02-21 02:43:26 +08:00
for (ObjCMethodDecl::param_iterator PI = MDecl->param_begin(),
Diagnose use of incomplete type on method argument type of method definitions instead of crashing in code gen. Fixes radar 8421082. llvm-svn: 114223
2010-09-18 06:07:07 +08:00
E = MDecl->param_end(); PI != E; ++PI) {
ParmVarDecl *Param = (*PI);
if (!Param->isInvalidDecl() &&
RequireCompleteType(Param->getLocation(), Param->getType(),
diag::err_typecheck_decl_incomplete_type))
Param->setInvalidDecl();
remove some more methods from objc decls, using the iterator interfaces more consistently. llvm-svn: 65138
2009-02-21 02:43:26 +08:00
if ((*PI)->getIdentifier())
PushOnScopeChains(*PI, FnBodyScope);
Diagnose use of incomplete type on method argument type of method definitions instead of crashing in code gen. Fixes radar 8421082. llvm-svn: 114223
2010-09-18 06:07:07 +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
// In ARC, disallow definition of retain/release/autorelease/retainCount
if (getLangOptions().ObjCAutoRefCount) {
switch (MDecl->getMethodFamily()) {
case OMF_retain:
case OMF_retainCount:
case OMF_release:
case OMF_autorelease:
Diag(MDecl->getLocation(), diag::err_arc_illegal_method_def)
<< MDecl->getSelector();
break;
case OMF_None:
case OMF_dealloc:
case OMF_alloc:
case OMF_init:
case OMF_mutableCopy:
case OMF_copy:
case OMF_new:
case OMF_self:
objc-arc: enforce performSelector rules in rejecting retaining selectors passed to it, and unknown selectors causing potential leak. // rdar://9659270 llvm-svn: 134449
2011-07-06 06:38:59 +08:00
case OMF_performSelector:
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
break;
}
}
Warn if method for a deprecated method is implemented. Warn if class for a deprecated class is implemented. Warn if category for a deprecated class is implemented. All under control of -Wdeprecated-implementations. // rdar://8973810. llvm-svn: 125545
2011-02-15 08:59:30 +08:00
// Warn on implementating deprecated methods under
// -Wdeprecated-implementations flag.
Refactoring of code to issue warning on implemented deprecated class and methods in objective-c. llvm-svn: 125573
2011-02-16 01:49:58 +08:00
if (ObjCInterfaceDecl *IC = MDecl->getClassInterface())
if (ObjCMethodDecl *IMD =
Warn if method for a deprecated method is implemented. Warn if class for a deprecated class is implemented. Warn if category for a deprecated class is implemented. All under control of -Wdeprecated-implementations. // rdar://8973810. llvm-svn: 125545
2011-02-15 08:59:30 +08:00
IC->lookupMethod(MDecl->getSelector(), MDecl->isInstanceMethod()))
Refactoring of code to issue warning on implemented deprecated class and methods in objective-c. llvm-svn: 125573
2011-02-16 01:49:58 +08:00
DiagnoseObjCImplementedDeprecations(*this,
dyn_cast<NamedDecl>(IMD),
MDecl->getLocation(), 0);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *Sema::
minor cleanup to the actions interface to pass around SmallVectorImpl instead of a specific smallvector size. Fix protocol lists to pass down proper location info, so we get diagnostics like this: t.m:3:35: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ instead of this: t.m:3:44: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ Add a new IdentifierLocPair typedef which is just a pair<IdentifierInfo*, SourceLocation> llvm-svn: 53883
2008-07-22 06:17:28 +08:00
ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
IdentifierInfo *ClassName, SourceLocation ClassLoc,
IdentifierInfo *SuperName, SourceLocation SuperLoc,
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl * const *ProtoRefs, unsigned NumProtoRefs,
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
const SourceLocation *ProtoLocs,
minor cleanup to the actions interface to pass around SmallVectorImpl instead of a specific smallvector size. Fix protocol lists to pass down proper location info, so we get diagnostics like this: t.m:3:35: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ instead of this: t.m:3:44: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ Add a new IdentifierLocPair typedef which is just a pair<IdentifierInfo*, SourceLocation> llvm-svn: 53883
2008-07-22 06:17:28 +08:00
SourceLocation EndProtoLoc, AttributeList *AttrList) {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
assert(ClassName && "Missing class identifier");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Check for another declaration kind with the same name.
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
NamedDecl *PrevDecl = LookupSingleName(TUScope, ClassName, ClassLoc,
Audit uses of Sema::LookupSingleName for those lookups that are intended for redeclarations, fixing those that need it. Fixes PR6831. This uncovered an issue where the C++ type-specifier-seq parsing logic would try to perform name lookup on an identifier after it already had a type-specifier, which could also lead to spurious ambiguity errors (as in PR6831, but with a different test case). llvm-svn: 101419
2010-04-16 07:40:53 +08:00
LookupOrdinaryName, ForRedeclaration);
Representation of template type parameters and non-type template parameters, with some semantic analysis: - Template parameters are introduced into template parameter scope - Complain about template parameter shadowing (except in Microsoft mode) Note that we leak template parameter declarations like crazy, a problem we'll remedy once we actually create proper declarations for templates. Next up: dependent types and value-dependent/type-dependent expressions. llvm-svn: 60597
2008-12-06 02:15:24 +08:00
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(PrevDecl->getLocation(), diag::note_previous_definition);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
ObjCInterfaceDecl* IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
if (IDecl) {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Class already seen. Is it a forward declaration?
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
if (!IDecl->isForwardDecl()) {
IDecl->setInvalidDecl();
Diag(AtInterfaceLoc, diag::err_duplicate_class_def)<<IDecl->getDeclName();
Diag(IDecl->getLocation(), diag::note_previous_definition);
make some objc redefinition warnings more consistent: call definitions "definitions", not declarations. Point out the location of the original definition. llvm-svn: 59919
2008-11-24 06:46:27 +08:00
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
// Return the previous class interface.
// FIXME: don't leak the objects passed in!
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return IDecl;
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
} else {
IDecl->setLocation(AtInterfaceLoc);
IDecl->setForwardDecl(false);
IDecl->setClassLoc(ClassLoc);
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
// If the forward decl was in a PCH, we need to write it again in a
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// dependent AST file.
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
IDecl->setChangedSinceDeserialization(true);
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
// Since this ObjCInterfaceDecl was created by a forward declaration,
// we now add it to the DeclContext since it wasn't added before
// (see ActOnForwardClassDeclaration).
IDecl->setLexicalDeclContext(CurContext);
CurContext->addDecl(IDecl);
if (AttrList)
ProcessDeclAttributeList(TUScope, IDecl, AttrList);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
} else {
IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtInterfaceLoc,
ClassName, ClassLoc);
if (AttrList)
ProcessDeclAttributeList(TUScope, IDecl, AttrList);
- Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition. - Eagerly create ObjCInterfaceTypes for declarations. - The two above changes lead to a 0.5% increase in memory use and no speed regression when parsing Cocoa.h. On the other hand, now chained PCH works when there's a forward declaration in one PCH and the interface definition in another. - Add HandleInterestingDecl to ASTConsumer. PCHReader passes the "interesting" decls it finds to this function instead of HandleTopLevelDecl. The default implementation forwards to HandleTopLevelDecl, but ASTUnit's handler for example ignores them. This fixes a potential crash when lazy loading of PCH data would cause ASTUnit's "top level" declaration collection to change while being iterated. llvm-svn: 110610
2010-08-10 05:55:28 +08:00
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
PushOnScopeChains(IDecl, TUScope);
}
- Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition. - Eagerly create ObjCInterfaceTypes for declarations. - The two above changes lead to a 0.5% increase in memory use and no speed regression when parsing Cocoa.h. On the other hand, now chained PCH works when there's a forward declaration in one PCH and the interface definition in another. - Add HandleInterestingDecl to ASTConsumer. PCHReader passes the "interesting" decls it finds to this function instead of HandleTopLevelDecl. The default implementation forwards to HandleTopLevelDecl, but ASTUnit's handler for example ignores them. This fixes a potential crash when lazy loading of PCH data would cause ASTUnit's "top level" declaration collection to change while being iterated. llvm-svn: 110610
2010-08-10 05:55:28 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (SuperName) {
// Check if a different kind of symbol declared in this scope.
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
PrevDecl = LookupSingleName(TUScope, SuperName, SuperLoc,
LookupOrdinaryName);
Implement typo correction for a variety of Objective-C-specific constructs: - Instance variable lookup ("foo->ivar" and, in instance methods, "ivar") - Property name lookup ("foo.prop") - Superclasses - Various places where a class name is required - Protocol names (e.g., id<proto>) This seems to cover many of the common places where typos could occur. llvm-svn: 92449
2010-01-04 02:01:57 +08:00
if (!PrevDecl) {
// Try to correct for a typo in the superclass name.
Add support for C++ namespace-aware typo correction, e.g., correcting vector<int> to std::vector<int> Patch by Kaelyn Uhrain, with minor tweaks + PCH support from me. Fixes PR5776/<rdar://problem/8652971>. Thanks Kaelyn! llvm-svn: 134007
2011-06-29 00:20:02 +08:00
TypoCorrection Corrected = CorrectTypo(
DeclarationNameInfo(SuperName, SuperLoc), LookupOrdinaryName, TUScope,
NULL, NULL, false, CTC_NoKeywords);
if ((PrevDecl = Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>())) {
Implement typo correction for a variety of Objective-C-specific constructs: - Instance variable lookup ("foo->ivar" and, in instance methods, "ivar") - Property name lookup ("foo.prop") - Superclasses - Various places where a class name is required - Protocol names (e.g., id<proto>) This seems to cover many of the common places where typos could occur. llvm-svn: 92449
2010-01-04 02:01:57 +08:00
Diag(SuperLoc, diag::err_undef_superclass_suggest)
<< SuperName << ClassName << PrevDecl->getDeclName();
Whenever we emit a typo-correction diagnostic, also emit a note pointing to the declaration that we found that has that name (if it is unique). llvm-svn: 92877
2010-01-07 08:17:44 +08:00
Diag(PrevDecl->getLocation(), diag::note_previous_decl)
<< PrevDecl->getDeclName();
Implement typo correction for a variety of Objective-C-specific constructs: - Instance variable lookup ("foo->ivar" and, in instance methods, "ivar") - Property name lookup ("foo.prop") - Superclasses - Various places where a class name is required - Protocol names (e.g., id<proto>) This seems to cover many of the common places where typos could occur. llvm-svn: 92449
2010-01-04 02:01:57 +08:00
}
}
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
if (PrevDecl == IDecl) {
Diag(SuperLoc, diag::err_recursive_superclass)
<< SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
IDecl->setLocEnd(ClassLoc);
Canonicalize else. llvm-svn: 78102
2009-08-05 05:02:39 +08:00
} else {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCInterfaceDecl *SuperClassDecl =
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
// Diagnose classes that inherit from deprecated classes.
if (SuperClassDecl)
(void)DiagnoseUseOfDecl(SuperClassDecl, SuperLoc);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
if (PrevDecl && SuperClassDecl == 0) {
// The previous declaration was not a class decl. Check if we have a
// typedef. If we do, get the underlying class type.
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (const TypedefNameDecl *TDecl =
dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
QualType T = TDecl->getUnderlyingType();
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 (T->isObjCObjectType()) {
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface())
SuperClassDecl = dyn_cast<ObjCInterfaceDecl>(IDecl);
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
}
Fix <rdar://problem/6552648> error: redefinition of 'XCElementAnchorDelegate' as different kind of symbol. At first glance, this looked like a recent regression (possibly created by http://llvm.org/viewvc/llvm-project?view=rev&revision=63354, which was the only recent change to this section of Sema::ActOnStartClassInterface()). After more investigation, it looks like an edge case bug that we didn't cover in our tests. llvm-svn: 63738
2009-02-05 01:14:05 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
// This handles the following case:
//
// typedef int SuperClass;
// @interface MyClass : SuperClass {} @end
//
if (!SuperClassDecl) {
Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName;
Diag(PrevDecl->getLocation(), diag::note_previous_definition);
}
Fix <rdar://problem/6552648> error: redefinition of 'XCElementAnchorDelegate' as different kind of symbol. At first glance, this looked like a recent regression (possibly created by http://llvm.org/viewvc/llvm-project?view=rev&revision=63354, which was the only recent change to this section of Sema::ActOnStartClassInterface()). After more investigation, it looks like an edge case bug that we didn't cover in our tests. llvm-svn: 63738
2009-02-05 01:14:05 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (!dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
if (!SuperClassDecl)
Diag(SuperLoc, diag::err_undef_superclass)
<< SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
When forming a cycle in objc's inheritance hierarchy, diagnose it properly and don't throw clang into an infinit loop. // rdar://9653341 llvm-svn: 133773
2011-06-24 07:16:19 +08:00
else if (SuperClassDecl->isForwardDecl()) {
Diag(SuperLoc, diag::err_forward_superclass)
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
<< SuperClassDecl->getDeclName() << ClassName
<< SourceRange(AtInterfaceLoc, ClassLoc);
When forming a cycle in objc's inheritance hierarchy, diagnose it properly and don't throw clang into an infinit loop. // rdar://9653341 llvm-svn: 133773
2011-06-24 07:16:19 +08:00
Diag(SuperClassDecl->getLocation(), diag::note_forward_class);
SuperClassDecl = 0;
}
don't crash if class is using itself as its super class. llvm-svn: 75178
2009-07-10 06:08:26 +08:00
}
IDecl->setSuperClass(SuperClassDecl);
IDecl->setSuperClassLoc(SuperLoc);
IDecl->setLocEnd(SuperLoc);
Fix <rdar://problem/6552648> error: redefinition of 'XCElementAnchorDelegate' as different kind of symbol. At first glance, this looked like a recent regression (possibly created by http://llvm.org/viewvc/llvm-project?view=rev&revision=63354, which was the only recent change to this section of Sema::ActOnStartClassInterface()). After more investigation, it looks like an edge case bug that we didn't cover in our tests. llvm-svn: 63738
2009-02-05 01:14:05 +08:00
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
} else { // we have a root class.
IDecl->setLocEnd(ClassLoc);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
// Check then save referenced protocols.
Pull protocol resolution of out ActOnStartClassInterface, this is also the last client of the old ParseObjCProtocolReferences, so it also removes it. llvm-svn: 54094
2008-07-26 12:13:19 +08:00
if (NumProtoRefs) {
add plumbing to get ASTContext& down to allocation/deallocation points in ObjCList, but don't start using it yet. Renamed some methods to be more consistent. llvm-svn: 65168
2009-02-21 05:35:13 +08:00
IDecl->setProtocolList((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs,
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
ProtoLocs, Context);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
IDecl->setLocEnd(EndProtoLoc);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
CheckObjCDeclScope(IDecl);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return IDecl;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
/// ActOnCompatiblityAlias - this action is called after complete parsing of
Prevent invalid warnings about incomplete implementations for methods which are inherited from base clases or protocols. llvm-svn: 55790
2008-09-05 04:01:15 +08:00
/// @compatibility_alias declaration. It sets up the alias relationships.
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *Sema::ActOnCompatiblityAlias(SourceLocation AtLoc,
IdentifierInfo *AliasName,
SourceLocation AliasLocation,
IdentifierInfo *ClassName,
SourceLocation ClassLocation) {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Look for previous declaration of alias name
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
NamedDecl *ADecl = LookupSingleName(TUScope, AliasName, AliasLocation,
Audit uses of Sema::LookupSingleName for those lookups that are intended for redeclarations, fixing those that need it. Fixes PR6831. This uncovered an issue where the C++ type-specifier-seq parsing logic would try to perform name lookup on an identifier after it already had a type-specifier, which could also lead to spurious ambiguity errors (as in PR6831, but with a different test case). llvm-svn: 101419
2010-04-16 07:40:53 +08:00
LookupOrdinaryName, ForRedeclaration);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (ADecl) {
remove warn_previous_declaration llvm-svn: 59922
2008-11-24 07:20:13 +08:00
if (isa<ObjCCompatibleAliasDecl>(ADecl))
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Diag(AliasLocation, diag::warn_previous_alias_decl);
remove warn_previous_declaration llvm-svn: 59922
2008-11-24 07:20:13 +08:00
else
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(AliasLocation, diag::err_conflicting_aliasing_type) << AliasName;
remove warn_previous_declaration llvm-svn: 59922
2008-11-24 07:20:13 +08:00
Diag(ADecl->getLocation(), diag::note_previous_declaration);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return 0;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
// Check for class declaration
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
NamedDecl *CDeclU = LookupSingleName(TUScope, ClassName, ClassLocation,
Audit uses of Sema::LookupSingleName for those lookups that are intended for redeclarations, fixing those that need it. Fixes PR6831. This uncovered an issue where the C++ type-specifier-seq parsing logic would try to perform name lookup on an identifier after it already had a type-specifier, which could also lead to spurious ambiguity errors (as in PR6831, but with a different test case). llvm-svn: 101419
2010-04-16 07:40:53 +08:00
LookupOrdinaryName, ForRedeclaration);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
if (const TypedefNameDecl *TDecl =
dyn_cast_or_null<TypedefNameDecl>(CDeclU)) {
Objc's compatibility-alias semantics and code gen issue fix. llvm-svn: 61901
2009-01-08 09:10:55 +08:00
QualType T = TDecl->getUnderlyingType();
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 (T->isObjCObjectType()) {
if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface()) {
Objc's compatibility-alias semantics and code gen issue fix. llvm-svn: 61901
2009-01-08 09:10:55 +08:00
ClassName = IDecl->getIdentifier();
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
CDeclU = LookupSingleName(TUScope, ClassName, ClassLocation,
Audit uses of Sema::LookupSingleName for those lookups that are intended for redeclarations, fixing those that need it. Fixes PR6831. This uncovered an issue where the C++ type-specifier-seq parsing logic would try to perform name lookup on an identifier after it already had a type-specifier, which could also lead to spurious ambiguity errors (as in PR6831, but with a different test case). llvm-svn: 101419
2010-04-16 07:40:53 +08:00
LookupOrdinaryName, ForRedeclaration);
Objc's compatibility-alias semantics and code gen issue fix. llvm-svn: 61901
2009-01-08 09:10:55 +08:00
}
}
}
add the last two Create methods for decls, woo! llvm-svn: 48432
2008-03-17 05:17:37 +08:00
ObjCInterfaceDecl *CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDeclU);
if (CDecl == 0) {
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(ClassLocation, diag::warn_undef_interface) << ClassName;
add the last two Create methods for decls, woo! llvm-svn: 48432
2008-03-17 05:17:37 +08:00
if (CDeclU)
remove warn_previous_declaration llvm-svn: 59922
2008-11-24 07:20:13 +08:00
Diag(CDeclU->getLocation(), diag::note_previous_declaration);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return 0;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add the last two Create methods for decls, woo! llvm-svn: 48432
2008-03-17 05:17:37 +08:00
// Everything checked out, instantiate a new alias declaration AST.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCCompatibleAliasDecl *AliasDecl =
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
ObjCCompatibleAliasDecl::Create(Context, CurContext, AtLoc, AliasName, CDecl);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
if (!CheckObjCDeclScope(AliasDecl))
Eliminate Sema::ObjCAliasDecls. This is based on Steve's fix, but also updates name lookup so that we see through @compatibility_alias declarations to their underlying interfaces. llvm-svn: 69950
2009-04-24 10:57:34 +08:00
PushOnScopeChains(AliasDecl, TUScope);
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return AliasDecl;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
refactor CheckForwardProtocolDeclarationForCircularDependency returns 'true' on detecting protocol cycles. No functionality change. llvm-svn: 131297
2011-05-14 02:02:08 +08:00
bool Sema::CheckForwardProtocolDeclarationForCircularDependency(
Fix <rdar://problem/6144382> [sema] gcc inconsistency w.r.t. forward protocol declarations. llvm-svn: 66161
2009-03-05 23:22:01 +08:00
IdentifierInfo *PName,
SourceLocation &Ploc, SourceLocation PrevLoc,
refactor CheckForwardProtocolDeclarationForCircularDependency returns 'true' on detecting protocol cycles. No functionality change. llvm-svn: 131297
2011-05-14 02:02:08 +08:00
const ObjCList<ObjCProtocolDecl> &PList) {
bool res = false;
Fix <rdar://problem/6144382> [sema] gcc inconsistency w.r.t. forward protocol declarations. llvm-svn: 66161
2009-03-05 23:22:01 +08:00
for (ObjCList<ObjCProtocolDecl>::iterator I = PList.begin(),
E = PList.end(); I != E; ++I) {
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
if (ObjCProtocolDecl *PDecl = LookupProtocol((*I)->getIdentifier(),
Ploc)) {
Fix <rdar://problem/6144382> [sema] gcc inconsistency w.r.t. forward protocol declarations. llvm-svn: 66161
2009-03-05 23:22:01 +08:00
if (PDecl->getIdentifier() == PName) {
Diag(Ploc, diag::err_protocol_has_circular_dependency);
Diag(PrevLoc, diag::note_previous_definition);
refactor CheckForwardProtocolDeclarationForCircularDependency returns 'true' on detecting protocol cycles. No functionality change. llvm-svn: 131297
2011-05-14 02:02:08 +08:00
res = true;
Fix <rdar://problem/6144382> [sema] gcc inconsistency w.r.t. forward protocol declarations. llvm-svn: 66161
2009-03-05 23:22:01 +08:00
}
refactor CheckForwardProtocolDeclarationForCircularDependency returns 'true' on detecting protocol cycles. No functionality change. llvm-svn: 131297
2011-05-14 02:02:08 +08:00
if (CheckForwardProtocolDeclarationForCircularDependency(PName, Ploc,
PDecl->getLocation(), PDecl->getReferencedProtocols()))
res = true;
Fix <rdar://problem/6144382> [sema] gcc inconsistency w.r.t. forward protocol declarations. llvm-svn: 66161
2009-03-05 23:22:01 +08:00
}
}
refactor CheckForwardProtocolDeclarationForCircularDependency returns 'true' on detecting protocol cycles. No functionality change. llvm-svn: 131297
2011-05-14 02:02:08 +08:00
return res;
Fix <rdar://problem/6144382> [sema] gcc inconsistency w.r.t. forward protocol declarations. llvm-svn: 66161
2009-03-05 23:22:01 +08:00
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *
pull protocol resolution out into ActOnStartProtocolInterface. This temporarily duplicates ParseObjCProtocolReferences, but it will be removed in the future. llvm-svn: 54092
2008-07-26 12:03:38 +08:00
Sema::ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc,
IdentifierInfo *ProtocolName,
SourceLocation ProtocolLoc,
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl * const *ProtoRefs,
pull protocol resolution out into ActOnStartProtocolInterface. This temporarily duplicates ParseObjCProtocolReferences, but it will be removed in the future. llvm-svn: 54092
2008-07-26 12:03:38 +08:00
unsigned NumProtoRefs,
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
const SourceLocation *ProtoLocs,
Parser support for prefix __attribute__ on @protocol. llvm-svn: 56642
2008-09-26 12:48:09 +08:00
SourceLocation EndProtoLoc,
AttributeList *AttrList) {
After issuing diagnostics on circular protocol list, don't build circular AST in protocol's protocol list when user code has introduced it. Indexer and other clients may crash. // rdar://9221614 llvm-svn: 131254
2011-05-13 06:04:39 +08:00
bool err = false;
Parser support for prefix __attribute__ on @protocol. llvm-svn: 56642
2008-09-26 12:48:09 +08:00
// FIXME: Deal with AttrList.
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
assert(ProtocolName && "Missing protocol identifier");
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
ObjCProtocolDecl *PDecl = LookupProtocol(ProtocolName, ProtocolLoc);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (PDecl) {
// Protocol already seen. Better be a forward protocol declaration
fix a crasher where an invalid program that multiply defined a protocol could smash more references in than are allocated. llvm-svn: 48411
2008-03-16 09:25:17 +08:00
if (!PDecl->isForwardDecl()) {
Warn instead of error on duplicate protocol definitions. Be kind to so many projects which are doing this (and be like gcc). llvm-svn: 68474
2009-04-07 07:43:32 +08:00
Diag(ProtocolLoc, diag::warn_duplicate_protocol_def) << ProtocolName;
make some objc redefinition warnings more consistent: call definitions "definitions", not declarations. Point out the location of the original definition. llvm-svn: 59919
2008-11-24 06:46:27 +08:00
Diag(PDecl->getLocation(), diag::note_previous_definition);
fix a crasher where an invalid program that multiply defined a protocol could smash more references in than are allocated. llvm-svn: 48411
2008-03-16 09:25:17 +08:00
// Just return the protocol we already had.
// FIXME: don't leak the objects passed in!
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return PDecl;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Fix <rdar://problem/6144382> [sema] gcc inconsistency w.r.t. forward protocol declarations. llvm-svn: 66161
2009-03-05 23:22:01 +08:00
ObjCList<ObjCProtocolDecl> PList;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PList.set((ObjCProtocolDecl *const*)ProtoRefs, NumProtoRefs, Context);
refactor CheckForwardProtocolDeclarationForCircularDependency returns 'true' on detecting protocol cycles. No functionality change. llvm-svn: 131297
2011-05-14 02:02:08 +08:00
err = CheckForwardProtocolDeclarationForCircularDependency(
ProtocolName, ProtocolLoc, PDecl->getLocation(), PList);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Sema::ActOnStartProtocolInterface(): Make sure the protocol decl has a valid start location. The following case resulted in an invalid start location: // start location not being set for ObjCProtocolDecl AST (when a forward reference is in scope). @protocol Buggy; @protocol Buggy @optional - whatever; @end llvm-svn: 54740
2008-08-14 00:39:22 +08:00
// Make sure the cached decl gets a valid start location.
PDecl->setLocation(AtProtoInterfaceLoc);
fix a crasher where an invalid program that multiply defined a protocol could smash more references in than are allocated. llvm-svn: 48411
2008-03-16 09:25:17 +08:00
PDecl->setForwardDecl(false);
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
CurContext->addDecl(PDecl);
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// Repeat in dependent AST files.
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
PDecl->setChangedSinceDeserialization(true);
fix a crasher where an invalid program that multiply defined a protocol could smash more references in than are allocated. llvm-svn: 48411
2008-03-16 09:25:17 +08:00
} else {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PDecl = ObjCProtocolDecl::Create(Context, CurContext,
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
AtProtoInterfaceLoc,ProtocolName);
Eliminate Sema::ObjCProtocols. Instead, we place ObjCProtocolDecls in their own namespace (IDNS_Protocol) and use the normal name-lookup routines to find them. Aside from the simplification this provides (one less DenseMap!), it means that protocols will be lazily deserialized from PCH files. Make the code size of the selector table block match the code size of the type and decl blocks. llvm-svn: 69939
2009-04-24 07:18:26 +08:00
PushOnScopeChains(PDecl, TUScope);
minor cleanups, make getNumInstanceMethods always return unsigned. llvm-svn: 48423
2008-03-17 04:19:15 +08:00
PDecl->setForwardDecl(false);
Give ObjCProtocolDecl a Create method. llvm-svn: 48410
2008-03-16 09:23:04 +08:00
}
Semantics of @protocol attributes. llvm-svn: 61114
2008-12-17 09:07:27 +08:00
if (AttrList)
Support dependent extended vector types and template instantiation thereof. Patch by Anders Johnsen! llvm-svn: 73641
2009-06-18 05:51:59 +08:00
ProcessDeclAttributeList(TUScope, PDecl, AttrList);
After issuing diagnostics on circular protocol list, don't build circular AST in protocol's protocol list when user code has introduced it. Indexer and other clients may crash. // rdar://9221614 llvm-svn: 131254
2011-05-13 06:04:39 +08:00
if (!err && NumProtoRefs ) {
minor cleanups, make getNumInstanceMethods always return unsigned. llvm-svn: 48423
2008-03-17 04:19:15 +08:00
/// Check then save referenced protocols.
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
PDecl->setProtocolList((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs,
ProtoLocs, Context);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
PDecl->setLocEnd(EndProtoLoc);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
CheckObjCDeclScope(PDecl);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return PDecl;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
/// FindProtocolDeclaration - This routine looks up protocols and
Prevent invalid warnings about incomplete implementations for methods which are inherited from base clases or protocols. llvm-svn: 55790
2008-09-05 04:01:15 +08:00
/// issues an error if they are not declared. It returns list of
/// protocol declarations in its 'Protocols' argument.
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
void
pull protocol resolution out into ActOnStartProtocolInterface. This temporarily duplicates ParseObjCProtocolReferences, but it will be removed in the future. llvm-svn: 54092
2008-07-26 12:03:38 +08:00
Sema::FindProtocolDeclaration(bool WarnOnDeclarations,
minor cleanup to the actions interface to pass around SmallVectorImpl instead of a specific smallvector size. Fix protocol lists to pass down proper location info, so we get diagnostics like this: t.m:3:35: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ instead of this: t.m:3:44: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ Add a new IdentifierLocPair typedef which is just a pair<IdentifierInfo*, SourceLocation> llvm-svn: 53883
2008-07-22 06:17:28 +08:00
const IdentifierLocPair *ProtocolId,
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
unsigned NumProtocols,
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
llvm::SmallVectorImpl<Decl *> &Protocols) {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
for (unsigned i = 0; i != NumProtocols; ++i) {
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
ObjCProtocolDecl *PDecl = LookupProtocol(ProtocolId[i].first,
ProtocolId[i].second);
Implement typo correction for a variety of Objective-C-specific constructs: - Instance variable lookup ("foo->ivar" and, in instance methods, "ivar") - Property name lookup ("foo.prop") - Superclasses - Various places where a class name is required - Protocol names (e.g., id<proto>) This seems to cover many of the common places where typos could occur. llvm-svn: 92449
2010-01-04 02:01:57 +08:00
if (!PDecl) {
Add support for C++ namespace-aware typo correction, e.g., correcting vector<int> to std::vector<int> Patch by Kaelyn Uhrain, with minor tweaks + PCH support from me. Fixes PR5776/<rdar://problem/8652971>. Thanks Kaelyn! llvm-svn: 134007
2011-06-29 00:20:02 +08:00
TypoCorrection Corrected = CorrectTypo(
DeclarationNameInfo(ProtocolId[i].first, ProtocolId[i].second),
LookupObjCProtocolName, TUScope, NULL, NULL, false, CTC_NoKeywords);
if ((PDecl = Corrected.getCorrectionDeclAs<ObjCProtocolDecl>())) {
Implement typo correction for a variety of Objective-C-specific constructs: - Instance variable lookup ("foo->ivar" and, in instance methods, "ivar") - Property name lookup ("foo.prop") - Superclasses - Various places where a class name is required - Protocol names (e.g., id<proto>) This seems to cover many of the common places where typos could occur. llvm-svn: 92449
2010-01-04 02:01:57 +08:00
Diag(ProtocolId[i].second, diag::err_undeclared_protocol_suggest)
Add support for C++ namespace-aware typo correction, e.g., correcting vector<int> to std::vector<int> Patch by Kaelyn Uhrain, with minor tweaks + PCH support from me. Fixes PR5776/<rdar://problem/8652971>. Thanks Kaelyn! llvm-svn: 134007
2011-06-29 00:20:02 +08:00
<< ProtocolId[i].first << Corrected.getCorrection();
Whenever we emit a typo-correction diagnostic, also emit a note pointing to the declaration that we found that has that name (if it is unique). llvm-svn: 92877
2010-01-07 08:17:44 +08:00
Diag(PDecl->getLocation(), diag::note_previous_decl)
<< PDecl->getDeclName();
Implement typo correction for a variety of Objective-C-specific constructs: - Instance variable lookup ("foo->ivar" and, in instance methods, "ivar") - Property name lookup ("foo.prop") - Superclasses - Various places where a class name is required - Protocol names (e.g., id<proto>) This seems to cover many of the common places where typos could occur. llvm-svn: 92449
2010-01-04 02:01:57 +08:00
}
}
simplify some code. llvm-svn: 54091
2008-07-26 11:47:43 +08:00
if (!PDecl) {
Switch several more Sema Diag methods over. This simplifies the __builtin_prefetch code to only emit one diagnostic per builtin_prefetch. While this has nothing to do with the rest of the patch, the code seemed like overkill when I was updating it. llvm-svn: 59588
2008-11-19 13:08:23 +08:00
Diag(ProtocolId[i].second, diag::err_undeclared_protocol)
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
<< ProtocolId[i].first;
simplify some code. llvm-svn: 54091
2008-07-26 11:47:43 +08:00
continue;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Downgrade complaints about calling unavailable functions to a warning (as GCC does), except when we've performed overload resolution and found an unavailable function: in this case, we actually error. Merge the checking of unavailable functions with the checking for deprecated functions. This unifies a bit of code, and makes sure that we're checking for unavailable functions in the right places. Also, this check can cause an error. We may, eventually, want an option to make "unavailable" warnings into errors. Implement much of the logic needed for C++0x deleted functions, which are effectively the same as "unavailable" functions (but always cause an error when referenced). However, we don't have the syntax to specify deleted functions yet :) llvm-svn: 64955
2009-02-19 05:56:37 +08:00
(void)DiagnoseUseOfDecl(PDecl, ProtocolId[i].second);
simplify some code. llvm-svn: 54091
2008-07-26 11:47:43 +08:00
// If this is a forward declaration and we are supposed to warn in this
// case, do it.
if (WarnOnDeclarations && PDecl->isForwardDecl())
Switch several more Sema Diag methods over. This simplifies the __builtin_prefetch code to only emit one diagnostic per builtin_prefetch. While this has nothing to do with the rest of the patch, the code seemed like overkill when I was updating it. llvm-svn: 59588
2008-11-19 13:08:23 +08:00
Diag(ProtocolId[i].second, diag::warn_undef_protocolref)
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
<< ProtocolId[i].first;
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Protocols.push_back(PDecl);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
}
Fixed a typo. llvm-svn: 65855
2009-03-03 03:06:08 +08:00
/// DiagnoseClassExtensionDupMethods - Check for duplicate declaration of
Check for duplicate declaration of method of a class in its extension. llvm-svn: 65854
2009-03-03 03:05:07 +08:00
/// a class method in its extension.
///
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
void Sema::DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
Check for duplicate declaration of method of a class in its extension. llvm-svn: 65854
2009-03-03 03:05:07 +08:00
ObjCInterfaceDecl *ID) {
if (!ID)
return; // Possibly due to previous error
llvm::DenseMap<Selector, const ObjCMethodDecl*> MethodMap;
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
for (ObjCInterfaceDecl::method_iterator i = ID->meth_begin(),
e = ID->meth_end(); i != e; ++i) {
Check for duplicate declaration of method of a class in its extension. llvm-svn: 65854
2009-03-03 03:05:07 +08:00
ObjCMethodDecl *MD = *i;
MethodMap[MD->getSelector()] = MD;
}
if (MethodMap.empty())
return;
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
for (ObjCCategoryDecl::method_iterator i = CAT->meth_begin(),
e = CAT->meth_end(); i != e; ++i) {
Check for duplicate declaration of method of a class in its extension. llvm-svn: 65854
2009-03-03 03:05:07 +08:00
ObjCMethodDecl *Method = *i;
const ObjCMethodDecl *&PrevMethod = MethodMap[Method->getSelector()];
if (PrevMethod && !MatchTwoMethodDeclarations(Method, PrevMethod)) {
Diag(Method->getLocation(), diag::err_duplicate_method_decl)
<< Method->getDeclName();
Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
}
}
}
Fix rdar://6771034: don't warn on use of forward declared protocol in protocol list of another protocol definition. This warning is very noisy and GCC doesn't produce it so existing code doesn't expect it. llvm-svn: 68894
2009-04-12 16:43:13 +08:00
/// ActOnForwardProtocolDeclaration - Handle @protocol foo;
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
minor cleanup to the actions interface to pass around SmallVectorImpl instead of a specific smallvector size. Fix protocol lists to pass down proper location info, so we get diagnostics like this: t.m:3:35: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ instead of this: t.m:3:44: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ Add a new IdentifierLocPair typedef which is just a pair<IdentifierInfo*, SourceLocation> llvm-svn: 53883
2008-07-22 06:17:28 +08:00
const IdentifierLocPair *IdentList,
Semantics of @protocol attributes. llvm-svn: 61114
2008-12-17 09:07:27 +08:00
unsigned NumElts,
AttributeList *attrList) {
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
llvm::SmallVector<ObjCProtocolDecl*, 32> Protocols;
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
llvm::SmallVector<SourceLocation, 8> ProtoLocs;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
for (unsigned i = 0; i != NumElts; ++i) {
minor cleanup to the actions interface to pass around SmallVectorImpl instead of a specific smallvector size. Fix protocol lists to pass down proper location info, so we get diagnostics like this: t.m:3:35: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ instead of this: t.m:3:44: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ Add a new IdentifierLocPair typedef which is just a pair<IdentifierInfo*, SourceLocation> llvm-svn: 53883
2008-07-22 06:17:28 +08:00
IdentifierInfo *Ident = IdentList[i].first;
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
ObjCProtocolDecl *PDecl = LookupProtocol(Ident, IdentList[i].second);
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
bool isNew = false;
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
if (PDecl == 0) { // Not already seen?
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PDecl = ObjCProtocolDecl::Create(Context, CurContext,
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
IdentList[i].second, Ident);
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
PushOnScopeChains(PDecl, TUScope, false);
isNew = true;
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
}
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
if (attrList) {
Support dependent extended vector types and template instantiation thereof. Patch by Anders Johnsen! llvm-svn: 73641
2009-06-18 05:51:59 +08:00
ProcessDeclAttributeList(TUScope, PDecl, attrList);
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
if (!isNew)
PDecl->setChangedSinceDeserialization(true);
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Protocols.push_back(PDecl);
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
ProtoLocs.push_back(IdentList[i].second);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCForwardProtocolDecl *PDecl =
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
ObjCForwardProtocolDecl::Create(Context, CurContext, AtProtocolLoc,
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
Protocols.data(), Protocols.size(),
ProtoLocs.data());
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
CurContext->addDecl(PDecl);
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
CheckObjCDeclScope(PDecl);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return PDecl;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *Sema::
minor cleanup to the actions interface to pass around SmallVectorImpl instead of a specific smallvector size. Fix protocol lists to pass down proper location info, so we get diagnostics like this: t.m:3:35: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ instead of this: t.m:3:44: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ Add a new IdentifierLocPair typedef which is just a pair<IdentifierInfo*, SourceLocation> llvm-svn: 53883
2008-07-22 06:17:28 +08:00
ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
IdentifierInfo *ClassName, SourceLocation ClassLoc,
IdentifierInfo *CategoryName,
SourceLocation CategoryLoc,
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl * const *ProtoRefs,
minor cleanup to the actions interface to pass around SmallVectorImpl instead of a specific smallvector size. Fix protocol lists to pass down proper location info, so we get diagnostics like this: t.m:3:35: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ instead of this: t.m:3:44: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ Add a new IdentifierLocPair typedef which is just a pair<IdentifierInfo*, SourceLocation> llvm-svn: 53883
2008-07-22 06:17:28 +08:00
unsigned NumProtoRefs,
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
const SourceLocation *ProtoLocs,
minor cleanup to the actions interface to pass around SmallVectorImpl instead of a specific smallvector size. Fix protocol lists to pass down proper location info, so we get diagnostics like this: t.m:3:35: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ instead of this: t.m:3:44: error: cannot find protocol definition for 'NSCopying', referenced by 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ Add a new IdentifierLocPair typedef which is just a pair<IdentifierInfo*, SourceLocation> llvm-svn: 53883
2008-07-22 06:17:28 +08:00
SourceLocation EndProtoLoc) {
Patch to provide separate ASTs for multiple ObjC class extension declarations (implements radar 7928731). llvm-svn: 106597
2010-06-23 07:20:40 +08:00
ObjCCategoryDecl *CDecl;
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);
Fix another crash on invalid code. In this case, handle ObjC categories (with no names) that refer to an undefined class. llvm-svn: 96976
2010-02-24 03:39:46 +08:00
/// Check that class of this category is already completely declared.
if (!IDecl || IDecl->isForwardDecl()) {
// Create an invalid ObjCCategoryDecl to serve as context for
// the enclosing method declarations. We mark the decl invalid
// to make it clear that this isn't a valid AST.
CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
ClassLoc, CategoryLoc, CategoryName);
CDecl->setInvalidDecl();
Diag(ClassLoc, diag::err_undef_interface) << ClassName;
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return CDecl;
Fix another crash on invalid code. In this case, handle ObjC categories (with no names) that refer to an undefined class. llvm-svn: 96976
2010-02-24 03:39:46 +08:00
}
Patch to provide separate ASTs for multiple ObjC class extension declarations (implements radar 7928731). llvm-svn: 106597
2010-06-23 07:20:40 +08:00
if (!CategoryName && IDecl->getImplementation()) {
Diag(ClassLoc, diag::err_class_extension_after_impl) << ClassName;
Diag(IDecl->getImplementation()->getLocation(),
diag::note_implementation_declared);
Fix another crash on invalid code. In this case, handle ObjC categories (with no names) that refer to an undefined class. llvm-svn: 96976
2010-02-24 03:39:46 +08:00
}
Patch to provide separate ASTs for multiple ObjC class extension declarations (implements radar 7928731). llvm-svn: 106597
2010-06-23 07:20:40 +08:00
CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
ClassLoc, CategoryLoc, CategoryName);
// FIXME: PushOnScopeChains?
CurContext->addDecl(CDecl);
Class continuation now has its own property ast for those declared in it. This is to allow duplicate property diagnostics for properties declared in class extensions multiple times (radar 7629420) and for future use. llvm-svn: 96276
2010-02-16 05:55:26 +08:00
Patch to provide separate ASTs for multiple ObjC class extension declarations (implements radar 7928731). llvm-svn: 106597
2010-06-23 07:20:40 +08:00
CDecl->setClassInterface(IDecl);
// Insert class extension to the list of class's categories.
if (!CategoryName)
CDecl->insertNextClassCategory();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
warn about categories that implement deprecated interfaces. llvm-svn: 64670
2009-02-17 05:30:01 +08:00
// If the interface is deprecated, warn about it.
Downgrade complaints about calling unavailable functions to a warning (as GCC does), except when we've performed overload resolution and found an unavailable function: in this case, we actually error. Merge the checking of unavailable functions with the checking for deprecated functions. This unifies a bit of code, and makes sure that we're checking for unavailable functions in the right places. Also, this check can cause an error. We may, eventually, want an option to make "unavailable" warnings into errors. Implement much of the logic needed for C++0x deleted functions, which are effectively the same as "unavailable" functions (but always cause an error when referenced). However, we don't have the syntax to specify deleted functions yet :) llvm-svn: 64955
2009-02-19 05:56:37 +08:00
(void)DiagnoseUseOfDecl(IDecl, ClassLoc);
early exit on error. This code is creating an invalid decl on error. This is dubious, but at least mark it as an invalid decl. llvm-svn: 64668
2009-02-17 05:26:43 +08:00
Class continuation now has its own property ast for those declared in it. This is to allow duplicate property diagnostics for properties declared in class extensions multiple times (radar 7629420) and for future use. llvm-svn: 96276
2010-02-16 05:55:26 +08:00
if (CategoryName) {
/// Check for duplicate interface declaration for this category
ObjCCategoryDecl *CDeclChain;
for (CDeclChain = IDecl->getCategoryList(); CDeclChain;
CDeclChain = CDeclChain->getNextClassCategory()) {
if (CDeclChain->getIdentifier() == CategoryName) {
// Class extensions can be declared multiple times.
Diag(CategoryLoc, diag::warn_dup_category_def)
<< ClassName << CategoryName;
Diag(CDeclChain->getLocation(), diag::note_previous_definition);
break;
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Class continuation now has its own property ast for those declared in it. This is to allow duplicate property diagnostics for properties declared in class extensions multiple times (radar 7629420) and for future use. llvm-svn: 96276
2010-02-16 05:55:26 +08:00
if (!CDeclChain)
CDecl->insertNextClassCategory();
Don't ICE on missing interface declaration when declaring one of its protocols. llvm-svn: 46141
2008-01-18 04:33:24 +08:00
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (NumProtoRefs) {
tweaked my last patch to 1) preserve the protocol in extension class's protocol list so its AST is complete. 2) Because of this no need to issue warning on unimplemeted methods coming from the extended class protocols because warning is issued when class definition is seen. llvm-svn: 83326
2009-10-06 05:32:49 +08:00
CDecl->setProtocolList((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs,
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
ProtoLocs, Context);
Patch to implement Protocols on class extensions. <rdar://problem/7269631> Protocols on class extensions don't work llvm-svn: 83322
2009-10-06 04:41:32 +08:00
// Protocols in the class extension belong to the class.
Class continuation now has its own property ast for those declared in it. This is to allow duplicate property diagnostics for properties declared in class extensions multiple times (radar 7629420) and for future use. llvm-svn: 96276
2010-02-16 05:55:26 +08:00
if (CDecl->IsClassExtension())
Patch to implement Protocols on class extensions. <rdar://problem/7269631> Protocols on class extensions don't work llvm-svn: 83322
2009-10-06 04:41:32 +08:00
IDecl->mergeClassExtensionProtocolList((ObjCProtocolDecl**)ProtoRefs,
Split ObjCInterfaceDecl::ReferencedProtocols into two lists: ReferencedProtocols and AllReferencedProtocols. ReferencedProtocols (and thus protocol_begin(), protocol_end()) now only contains the list of protocols that were directly referenced in an @interface declaration. 'all_referenced_protocol_[begin,end]()' now returns the set of protocols that were referenced in both the @interface and class extensions. The latter is needed for semantic analysis/codegen, while the former is needed to maintain the lexical information of the original source. Fixes <rdar://problem/8380046>. llvm-svn: 112691
2010-09-01 09:21:15 +08:00
NumProtoRefs, Context);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
CheckObjCDeclScope(CDecl);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return CDecl;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
/// ActOnStartCategoryImplementation - Perform semantic checks on the
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
/// category implementation declaration and build an ObjCCategoryImplDecl
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
/// object.
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *Sema::ActOnStartCategoryImplementation(
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
SourceLocation AtCatImplLoc,
IdentifierInfo *ClassName, SourceLocation ClassLoc,
IdentifierInfo *CatName, SourceLocation CatLoc) {
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);
- Introduce ASTContext::getObjCImplementation() and ASTContext::setObjCImplementation() which use a DenseMap to associate an interface/category with its implementation (if one exists). - Introduce ObjCInterfaceDecl::get/setImplementation() and ObjCCategoryDecl::get/setImplementation() that use the above methods. - Add a compiler error for when a category is reimplemented. llvm-svn: 76508
2009-07-21 08:05:53 +08:00
ObjCCategoryDecl *CatIDecl = 0;
if (IDecl) {
CatIDecl = IDecl->FindCategoryDeclaration(CatName);
if (!CatIDecl) {
// Category @implementation with no corresponding @interface.
// Create and install one.
CatIDecl = ObjCCategoryDecl::Create(Context, CurContext, SourceLocation(),
Improve location information for Objective-C category declarations. We previously only had a single location (the @ in @interface); now we know where the @ is (for the start of the declaration), where the class name is (that's the normal "location" now for diagnostics), and where the category name is. Also, eliminated the redundant "end" location, since ObjCContainerDecl already has better @end information. The only XFAIL'd test is temporary; will un-XFAIL-it once I've taught CIndex how to use the new locations. llvm-svn: 93639
2010-01-17 00:38:58 +08:00
SourceLocation(), SourceLocation(),
- Introduce ASTContext::getObjCImplementation() and ASTContext::setObjCImplementation() which use a DenseMap to associate an interface/category with its implementation (if one exists). - Introduce ObjCInterfaceDecl::get/setImplementation() and ObjCCategoryDecl::get/setImplementation() that use the above methods. - Add a compiler error for when a category is reimplemented. llvm-svn: 76508
2009-07-21 08:05:53 +08:00
CatName);
CatIDecl->setClassInterface(IDecl);
CatIDecl->insertNextClassCategory();
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCCategoryImplDecl *CDecl =
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
ObjCCategoryImplDecl::Create(Context, CurContext, AtCatImplLoc, CatName,
IDecl);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
/// Check that class of this category is already completely declared.
if (!IDecl || IDecl->isForwardDecl())
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(ClassLoc, diag::err_undef_interface) << ClassName;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
// FIXME: PushOnScopeChains?
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
CurContext->addDecl(CDecl);
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
- Introduce ASTContext::getObjCImplementation() and ASTContext::setObjCImplementation() which use a DenseMap to associate an interface/category with its implementation (if one exists). - Introduce ObjCInterfaceDecl::get/setImplementation() and ObjCCategoryDecl::get/setImplementation() that use the above methods. - Add a compiler error for when a category is reimplemented. llvm-svn: 76508
2009-07-21 08:05:53 +08:00
/// Check that CatName, category name, is not used in another implementation.
if (CatIDecl) {
if (CatIDecl->getImplementation()) {
Diag(ClassLoc, diag::err_dup_implementation_category) << ClassName
<< CatName;
Diag(CatIDecl->getImplementation()->getLocation(),
diag::note_previous_definition);
Warn if method for a deprecated method is implemented. Warn if class for a deprecated class is implemented. Warn if category for a deprecated class is implemented. All under control of -Wdeprecated-implementations. // rdar://8973810. llvm-svn: 125545
2011-02-15 08:59:30 +08:00
} else {
- Introduce ASTContext::getObjCImplementation() and ASTContext::setObjCImplementation() which use a DenseMap to associate an interface/category with its implementation (if one exists). - Introduce ObjCInterfaceDecl::get/setImplementation() and ObjCCategoryDecl::get/setImplementation() that use the above methods. - Add a compiler error for when a category is reimplemented. llvm-svn: 76508
2009-07-21 08:05:53 +08:00
CatIDecl->setImplementation(CDecl);
Warn if method for a deprecated method is implemented. Warn if class for a deprecated class is implemented. Warn if category for a deprecated class is implemented. All under control of -Wdeprecated-implementations. // rdar://8973810. llvm-svn: 125545
2011-02-15 08:59:30 +08:00
// Warn on implementating category of deprecated class under
// -Wdeprecated-implementations flag.
Refactoring of code to issue warning on implemented deprecated class and methods in objective-c. llvm-svn: 125573
2011-02-16 01:49:58 +08:00
DiagnoseObjCImplementedDeprecations(*this,
dyn_cast<NamedDecl>(IDecl),
CDecl->getLocation(), 2);
Warn if method for a deprecated method is implemented. Warn if class for a deprecated class is implemented. Warn if category for a deprecated class is implemented. All under control of -Wdeprecated-implementations. // rdar://8973810. llvm-svn: 125545
2011-02-15 08:59:30 +08:00
}
- Introduce ASTContext::getObjCImplementation() and ASTContext::setObjCImplementation() which use a DenseMap to associate an interface/category with its implementation (if one exists). - Introduce ObjCInterfaceDecl::get/setImplementation() and ObjCCategoryDecl::get/setImplementation() that use the above methods. - Add a compiler error for when a category is reimplemented. llvm-svn: 76508
2009-07-21 08:05:53 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
CheckObjCDeclScope(CDecl);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return CDecl;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *Sema::ActOnStartClassImplementation(
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
SourceLocation AtClassImplLoc,
IdentifierInfo *ClassName, SourceLocation ClassLoc,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
IdentifierInfo *SuperClassname,
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
SourceLocation SuperClassLoc) {
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
ObjCInterfaceDecl* IDecl = 0;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Check for another declaration kind with the same name.
Refactor the LookupResult API to simplify most common operations. Require users to pass a LookupResult reference to lookup routines. Call out uses which assume a single result. llvm-svn: 83674
2009-10-10 05:13:30 +08:00
NamedDecl *PrevDecl
Audit uses of Sema::LookupSingleName for those lookups that are intended for redeclarations, fixing those that need it. Fixes PR6831. This uncovered an issue where the C++ type-specifier-seq parsing logic would try to perform name lookup on an identifier after it already had a type-specifier, which could also lead to spurious ambiguity errors (as in PR6831, but with a different test case). llvm-svn: 101419
2010-04-16 07:40:53 +08:00
= LookupSingleName(TUScope, ClassName, ClassLoc, LookupOrdinaryName,
ForRedeclaration);
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
} else if ((IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl))) {
// If this is a forward declaration of an interface, warn.
if (IDecl->isForwardDecl()) {
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(ClassLoc, diag::warn_undef_interface) << ClassName;
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
IDecl = 0;
Diagnose if an implementation implements a forward class declaration (and avoid issuing bogus error later on). llvm-svn: 69928
2009-04-24 05:49:04 +08:00
}
When declaring an Objective-C implementation without a corresponding interface, suggest correction of typos. For example, given: @interface NSString @end @implementation NSstring @end we'll warn with: t.m:4:19: warning: cannot find interface declaration for 'NSstring'; did you mean 'NSString'? @implementation NSstring ^ However, since this is just a warning, we don't provide a fix-it hint. Good idea, Ted! llvm-svn: 92488
2010-01-05 01:27:12 +08:00
} else {
// We did not find anything with the name ClassName; try to correct for
// typos in the class name.
Add support for C++ namespace-aware typo correction, e.g., correcting vector<int> to std::vector<int> Patch by Kaelyn Uhrain, with minor tweaks + PCH support from me. Fixes PR5776/<rdar://problem/8652971>. Thanks Kaelyn! llvm-svn: 134007
2011-06-29 00:20:02 +08:00
TypoCorrection Corrected = CorrectTypo(
DeclarationNameInfo(ClassName, ClassLoc), LookupOrdinaryName, TUScope,
NULL, NULL, false, CTC_NoKeywords);
if ((IDecl = Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>())) {
When suggesting a typo correction for an @implementation without a corresponding @interface, provide a note showing which interface we're referring to. This note has the fix-it hint on it. Also, don't automatically apply fix-it hints for notes. They're meant to express fix-its that would change semantics. llvm-svn: 92870
2010-01-07 07:44:25 +08:00
// Suggest the (potentially) correct interface name. However, put the
// fix-it hint itself in a separate note, since changing the name in
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
// the warning would make the fix-it change semantics.However, don't
When declaring an Objective-C implementation without a corresponding interface, suggest correction of typos. For example, given: @interface NSString @end @implementation NSstring @end we'll warn with: t.m:4:19: warning: cannot find interface declaration for 'NSstring'; did you mean 'NSString'? @implementation NSstring ^ However, since this is just a warning, we don't provide a fix-it hint. Good idea, Ted! llvm-svn: 92488
2010-01-05 01:27:12 +08:00
// provide a code-modification hint or use the typo name for recovery,
// because this is just a warning. The program may actually be correct.
Add support for C++ namespace-aware typo correction, e.g., correcting vector<int> to std::vector<int> Patch by Kaelyn Uhrain, with minor tweaks + PCH support from me. Fixes PR5776/<rdar://problem/8652971>. Thanks Kaelyn! llvm-svn: 134007
2011-06-29 00:20:02 +08:00
DeclarationName CorrectedName = Corrected.getCorrection();
When declaring an Objective-C implementation without a corresponding interface, suggest correction of typos. For example, given: @interface NSString @end @implementation NSstring @end we'll warn with: t.m:4:19: warning: cannot find interface declaration for 'NSstring'; did you mean 'NSString'? @implementation NSstring ^ However, since this is just a warning, we don't provide a fix-it hint. Good idea, Ted! llvm-svn: 92488
2010-01-05 01:27:12 +08:00
Diag(ClassLoc, diag::warn_undef_interface_suggest)
Add support for C++ namespace-aware typo correction, e.g., correcting vector<int> to std::vector<int> Patch by Kaelyn Uhrain, with minor tweaks + PCH support from me. Fixes PR5776/<rdar://problem/8652971>. Thanks Kaelyn! llvm-svn: 134007
2011-06-29 00:20:02 +08:00
<< ClassName << CorrectedName;
Diag(IDecl->getLocation(), diag::note_previous_decl) << CorrectedName
<< FixItHint::CreateReplacement(ClassLoc, CorrectedName.getAsString());
When declaring an Objective-C implementation without a corresponding interface, suggest correction of typos. For example, given: @interface NSString @end @implementation NSstring @end we'll warn with: t.m:4:19: warning: cannot find interface declaration for 'NSstring'; did you mean 'NSString'? @implementation NSstring ^ However, since this is just a warning, we don't provide a fix-it hint. Good idea, Ted! llvm-svn: 92488
2010-01-05 01:27:12 +08:00
IDecl = 0;
} else {
Diag(ClassLoc, diag::warn_undef_interface) << ClassName;
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Check that super class name is valid class name
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
ObjCInterfaceDecl* SDecl = 0;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (SuperClassname) {
// Check if a different kind of symbol declared in this scope.
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
PrevDecl = LookupSingleName(TUScope, SuperClassname, SuperClassLoc,
LookupOrdinaryName);
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(SuperClassLoc, diag::err_redefinition_different_kind)
<< SuperClassname;
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(PrevDecl->getLocation(), diag::note_previous_definition);
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
} else {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (!SDecl)
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(SuperClassLoc, diag::err_undef_superclass)
<< SuperClassname << ClassName;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
else if (IDecl && IDecl->getSuperClass() != SDecl) {
// This implementation and its interface do not have the same
// super class.
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(SuperClassLoc, diag::err_conflicting_super_class)
Convert IdentifierInfo's to be printed the same as DeclarationNames with implicit quotes around them. This has a bunch of follow-on effects and requires tweaking to a whole lot of code. This causes a regression in two tests (xfailed) by causing it to emit things like: Line 10: duplicate interface declaration for category 'MyClass1' ('Category1') instead of: Line 10: duplicate interface declaration for category 'MyClass1(Category1)' I will fix this in a follow-up commit. As part of this, I had to start switching stuff to use ->getDeclName() instead of Decl::getName() for consistency. This is good, but I was planning to do this as an independent patch. There will be several follow-on patches to clean up some of the mess, but this patch is already too big. llvm-svn: 59917
2008-11-24 05:45:46 +08:00
<< SDecl->getDeclName();
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(SDecl->getLocation(), diag::note_previous_definition);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (!IDecl) {
// Legacy case of @implementation with no corresponding @interface.
// Build, chain & install the interface decl into the identifier.
Fix attributes on Obj-C interfaces & methods. - Drop MethodAttrs parameter to ObjCMethodDecl - Call ProcessDeclAttributeList for interface & method decls. llvm-svn: 55068
2008-08-21 02:02:42 +08:00
Reflow some comments. llvm-svn: 71936
2009-05-16 15:39:55 +08:00
// FIXME: Do we support attributes on the @implementation? If so we should
// copy them over.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassImplLoc,
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
ClassName, ClassLoc, false, true);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
IDecl->setSuperClass(SDecl);
IDecl->setLocEnd(ClassLoc);
Eliminate Sema::ObjCInterfaceDecls llvm-svn: 69942
2009-04-24 08:16:12 +08:00
PushOnScopeChains(IDecl, TUScope);
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
} else {
// Mark the interface as being completed, even if it was just as
// @class ....;
// declaration; the user cannot reopen it.
IDecl->setForwardDecl(false);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCImplementationDecl* IMPDecl =
ObjCImplementationDecl::Create(Context, CurContext, AtClassImplLoc,
Remove ScopedDecl, collapsing all of its functionality into Decl, so that every declaration lives inside a DeclContext. Moved several things that don't have names but were ScopedDecls (and, therefore, NamedDecls) to inherit from Decl rather than NamedDecl, including ObjCImplementationDecl and LinkageSpecDecl. Now, we don't store empty DeclarationNames for these things, nor do we try to insert them into DeclContext's lookup structure. The serialization tests are temporarily disabled. We'll re-enable them once we've sorted out the remaining ownership/serialiazation issues between DeclContexts and TranslationUnion, DeclGroups, etc. llvm-svn: 62562
2009-01-20 09:17:11 +08:00
IDecl, SDecl);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
if (CheckObjCDeclScope(IMPDecl))
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return IMPDecl;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Check that there is no duplicate implementation of this class.
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
if (IDecl->getImplementation()) {
// FIXME: Don't leak everything!
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(ClassLoc, diag::err_dup_implementation_class) << ClassName;
Remove Sema::LookupObjCImplementation and replace it with just calling ObjCInterfaceDecl::getImplementation(). llvm-svn: 76509
2009-07-21 08:06:04 +08:00
Diag(IDecl->getImplementation()->getLocation(),
diag::note_previous_definition);
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
} else { // add it to the list.
- Introduce ASTContext::getObjCImplementation() and ASTContext::setObjCImplementation() which use a DenseMap to associate an interface/category with its implementation (if one exists). - Introduce ObjCInterfaceDecl::get/setImplementation() and ObjCCategoryDecl::get/setImplementation() that use the above methods. - Add a compiler error for when a category is reimplemented. llvm-svn: 76508
2009-07-21 08:05:53 +08:00
IDecl->setImplementation(IMPDecl);
Eliminate Sema::ObjCImplementations, relying instead on name lookup. What's good for uniformity is good for PCH (or is it the other way around?). As part of this, make ObjCImplDecl inherit from NamedDecl (since ObjCImplementationDecls now need to have names so that they can be found). This brings ObjCImplDecl very, very close to ObjCContainerDecl; we may be able to merge them soon. llvm-svn: 69941
2009-04-24 08:11:27 +08:00
PushOnScopeChains(IMPDecl, TUScope);
Warn if method for a deprecated method is implemented. Warn if class for a deprecated class is implemented. Warn if category for a deprecated class is implemented. All under control of -Wdeprecated-implementations. // rdar://8973810. llvm-svn: 125545
2011-02-15 08:59:30 +08:00
// Warn on implementating deprecated class under
// -Wdeprecated-implementations flag.
Refactoring of code to issue warning on implemented deprecated class and methods in objective-c. llvm-svn: 125573
2011-02-16 01:49:58 +08:00
DiagnoseObjCImplementedDeprecations(*this,
dyn_cast<NamedDecl>(IDecl),
IMPDecl->getLocation(), 1);
- Introduce ASTContext::getObjCImplementation() and ASTContext::setObjCImplementation() which use a DenseMap to associate an interface/category with its implementation (if one exists). - Introduce ObjCInterfaceDecl::get/setImplementation() and ObjCCategoryDecl::get/setImplementation() that use the above methods. - Add a compiler error for when a category is reimplemented. llvm-svn: 76508
2009-07-21 08:05:53 +08:00
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return IMPDecl;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
ObjCIvarDecl **ivars, unsigned numIvars,
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
SourceLocation RBrace) {
assert(ImpDecl && "missing implementation decl");
Remove ScopedDecl, collapsing all of its functionality into Decl, so that every declaration lives inside a DeclContext. Moved several things that don't have names but were ScopedDecls (and, therefore, NamedDecls) to inherit from Decl rather than NamedDecl, including ObjCImplementationDecl and LinkageSpecDecl. Now, we don't store empty DeclarationNames for these things, nor do we try to insert them into DeclContext's lookup structure. The serialization tests are temporarily disabled. We'll re-enable them once we've sorted out the remaining ownership/serialiazation issues between DeclContexts and TranslationUnion, DeclGroups, etc. llvm-svn: 62562
2009-01-20 09:17:11 +08:00
ObjCInterfaceDecl* IDecl = ImpDecl->getClassInterface();
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (!IDecl)
return;
/// Check case of non-existing @interface decl.
/// (legacy objective-c @implementation decl without an @interface decl).
/// Add implementations's ivar to the synthesize class's ivar list.
Add pch reader/writer support for ObjCContainerDecl, ObjCInterfaceDecl, & ObjCIvarDecl. Next step: Add selector support to PCHWriter::AddDeclarationName(). llvm-svn: 69619
2009-04-21 04:09:33 +08:00
if (IDecl->isImplicitInterfaceDecl()) {
add plumbing to get ASTContext& down to allocation/deallocation points in ObjCList, but don't start using it yet. Renamed some methods to be more consistent. llvm-svn: 65168
2009-02-21 05:35:13 +08:00
IDecl->setLocEnd(RBrace);
Allow for declaration and use of ivars in a stand-alone implementation (toward radar 7547942). llvm-svn: 96479
2010-02-18 01:00:07 +08:00
// Add ivar's to class's DeclContext.
for (unsigned i = 0, e = numIvars; i != e; ++i) {
Use proper lexcial context for newly added ivars. llvm-svn: 96484
2010-02-18 02:10:54 +08:00
ivars[i]->setLexicalDeclContext(ImpDecl);
IDecl->makeDeclVisibleInContext(ivars[i], false);
Patch removes IVars list from ObjCInterfaceDecl and instead relies on their DeclContext for iteration, etc. llvm-svn: 96638
2010-02-19 08:31:17 +08:00
ImpDecl->addDecl(ivars[i]);
Allow for declaration and use of ivars in a stand-alone implementation (toward radar 7547942). llvm-svn: 96479
2010-02-18 01:00:07 +08:00
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
return;
}
// If implementation has empty ivar list, just return.
if (numIvars == 0)
return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
assert(ivars && "missing @implementation ivars");
Start supporting declaration of ivars in @implementation blocks. WIP. llvm-svn: 96696
2010-02-20 04:58:54 +08:00
if (LangOpts.ObjCNonFragileABI2) {
if (ImpDecl->getSuperClass())
Diag(ImpDecl->getLocation(), diag::warn_on_superclass_use);
for (unsigned i = 0; i < numIvars; i++) {
ObjCIvarDecl* ImplIvar = ivars[i];
if (const ObjCIvarDecl *ClsIvar =
IDecl->getIvarDecl(ImplIvar->getIdentifier())) {
Diag(ImplIvar->getLocation(), diag::err_duplicate_ivar_declaration);
Diag(ClsIvar->getLocation(), diag::note_previous_definition);
continue;
}
// Instance ivar to Implementation's DeclContext.
ImplIvar->setLexicalDeclContext(ImpDecl);
IDecl->makeDeclVisibleInContext(ImplIvar, false);
ImpDecl->addDecl(ImplIvar);
}
return;
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Check interface's Ivar list against those in the implementation.
// names and types must match.
//
unsigned j = 0;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCInterfaceDecl::ivar_iterator
unbreak the build. I'm still working on test failures. llvm-svn: 44938
2007-12-13 01:58:05 +08:00
IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end();
for (; numIvars > 0 && IVI != IVE; ++IVI) {
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
ObjCIvarDecl* ImplIvar = ivars[j++];
ObjCIvarDecl* ClsIvar = *IVI;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
assert (ImplIvar && "missing implementation ivar");
assert (ClsIvar && "missing class ivar");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix <rdar://problem/6497608> clang does not catch ivar type mismatches in @implementation. llvm-svn: 65948
2009-03-03 22:49:36 +08:00
// First, make sure the types match.
remove two uses of getCanonicalType I missed. llvm-svn: 54114
2008-07-27 08:05:05 +08:00
if (Context.getCanonicalType(ImplIvar->getType()) !=
Context.getCanonicalType(ClsIvar->getType())) {
Switch several more Sema Diag methods over. This simplifies the __builtin_prefetch code to only emit one diagnostic per builtin_prefetch. While this has nothing to do with the rest of the patch, the code seemed like overkill when I was updating it. llvm-svn: 59588
2008-11-19 13:08:23 +08:00
Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type)
Convert IdentifierInfo's to be printed the same as DeclarationNames with implicit quotes around them. This has a bunch of follow-on effects and requires tweaking to a whole lot of code. This causes a regression in two tests (xfailed) by causing it to emit things like: Line 10: duplicate interface declaration for category 'MyClass1' ('Category1') instead of: Line 10: duplicate interface declaration for category 'MyClass1(Category1)' I will fix this in a follow-up commit. As part of this, I had to start switching stuff to use ->getDeclName() instead of Decl::getName() for consistency. This is good, but I was planning to do this as an independent patch. There will be several follow-on patches to clean up some of the mess, but this patch is already too big. llvm-svn: 59917
2008-11-24 05:45:46 +08:00
<< ImplIvar->getIdentifier()
<< ImplIvar->getType() << ClsIvar->getType();
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(ClsIvar->getLocation(), diag::note_previous_definition);
Fix <rdar://problem/6497608> clang does not catch ivar type mismatches in @implementation. llvm-svn: 65948
2009-03-03 22:49:36 +08:00
} else if (ImplIvar->isBitField() && ClsIvar->isBitField()) {
Expr *ImplBitWidth = ImplIvar->getBitWidth();
Expr *ClsBitWidth = ClsIvar->getBitWidth();
Remove getIntegerConstantExprValue in favor of using EvaluateAsInt. llvm-svn: 70145
2009-04-27 03:19:15 +08:00
if (ImplBitWidth->EvaluateAsInt(Context).getZExtValue() !=
ClsBitWidth->EvaluateAsInt(Context).getZExtValue()) {
Fix <rdar://problem/6497608> clang does not catch ivar type mismatches in @implementation. llvm-svn: 65948
2009-03-03 22:49:36 +08:00
Diag(ImplBitWidth->getLocStart(), diag::err_conflicting_ivar_bitwidth)
<< ImplIvar->getIdentifier();
Diag(ClsBitWidth->getLocStart(), diag::note_previous_definition);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
}
Fix <rdar://problem/6497608> clang does not catch ivar type mismatches in @implementation. llvm-svn: 65948
2009-03-03 22:49:36 +08:00
// Make sure the names are identical.
if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) {
Switch several more Sema Diag methods over. This simplifies the __builtin_prefetch code to only emit one diagnostic per builtin_prefetch. While this has nothing to do with the rest of the patch, the code seemed like overkill when I was updating it. llvm-svn: 59588
2008-11-19 13:08:23 +08:00
Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name)
Convert IdentifierInfo's to be printed the same as DeclarationNames with implicit quotes around them. This has a bunch of follow-on effects and requires tweaking to a whole lot of code. This causes a regression in two tests (xfailed) by causing it to emit things like: Line 10: duplicate interface declaration for category 'MyClass1' ('Category1') instead of: Line 10: duplicate interface declaration for category 'MyClass1(Category1)' I will fix this in a follow-up commit. As part of this, I had to start switching stuff to use ->getDeclName() instead of Decl::getName() for consistency. This is good, but I was planning to do this as an independent patch. There will be several follow-on patches to clean up some of the mess, but this patch is already too big. llvm-svn: 59917
2008-11-24 05:45:46 +08:00
<< ImplIvar->getIdentifier() << ClsIvar->getIdentifier();
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(ClsIvar->getLocation(), diag::note_previous_definition);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
--numIvars;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
simplify some code, bump j. This fixes the remaining test failures. llvm-svn: 44941
2007-12-13 02:11:49 +08:00
if (numIvars > 0)
make it a bit more clear in what way the ivar is consistent. llvm-svn: 44945
2007-12-13 02:19:52 +08:00
Diag(ivars[j]->getLocation(), diag::err_inconsistant_ivar_count);
simplify some code, bump j. This fixes the remaining test failures. llvm-svn: 44941
2007-12-13 02:11:49 +08:00
else if (IVI != IVE)
make it a bit more clear in what way the ivar is consistent. llvm-svn: 44945
2007-12-13 02:19:52 +08:00
Diag((*IVI)->getLocation(), diag::err_inconsistant_ivar_count);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Add a diagnostics helper to remove some redundant code. llvm-svn: 46936
2008-02-11 05:38:56 +08:00
void Sema::WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
Patch implements gcc's -Wno-protocol option to suppress warning on unimplemented methods in protocols adopted by a class. (radar 7056600). llvm-svn: 100028
2010-04-01 02:23:33 +08:00
bool &IncompleteImpl, unsigned DiagID) {
No need to warn if 'unavailable' method/property is not implemented. // rdar://9651605 llvm-svn: 133819
2011-06-25 04:31:37 +08:00
// No point warning no definition of method which is 'unavailable'.
if (method->hasAttr<UnavailableAttr>())
return;
Add a diagnostics helper to remove some redundant code. llvm-svn: 46936
2008-02-11 05:38:56 +08:00
if (!IncompleteImpl) {
Diag(ImpLoc, diag::warn_incomplete_impl);
IncompleteImpl = true;
}
Improve diagnostics reporting of un-implemented methods in protocols when protocols are in system headers and thus ignored. //rdar: //8227199 llvm-svn: 117739
2010-10-30 07:20:05 +08:00
if (DiagID == diag::warn_unimplemented_protocol_method)
Diag(ImpLoc, DiagID) << method->getDeclName();
else
Diag(method->getLocation(), DiagID) << method->getDeclName();
Add a diagnostics helper to remove some redundant code. llvm-svn: 46936
2008-02-11 05:38:56 +08:00
}
Only warn for mismatched types in Objective-C methods when they are incompatible, not when they are simply different. Now we test whether the difference in types breaks the principle of substitutability, rather than whether they are different. A common idiom in Objective-C is to provide a definition of a method in a subclass that returns a more-specified version of an object than the superclass. This does not violate the principle of substitutability, because you can always use the object returned by the subclass anywhere that you could use the type returned by the superclass. It was, however, generating warnings with clang, leading people to believe that semantically correct code was incorrect and requiring less accurate type specification and explicit down-casts (neither of which is a good thing to encourage). This change ensures that any method definition has parameter and return types that make it accept anything that something conforming to the declaration may pass and return something that the caller will expect, but allows stricter definitions. llvm-svn: 117271
2010-10-26 01:23:52 +08:00
/// Determines if type B can be substituted for type A. Returns true if we can
/// guarantee that anything that the user will do to an object of type A can
/// also be done to an object of type B. This is trivially true if the two
/// types are the same, or if B is a subclass of A. It becomes more complex
/// in cases where protocols are involved.
///
/// Object types in Objective-C describe the minimum requirements for an
/// object, rather than providing a complete description of a type. For
/// example, if A is a subclass of B, then B* may refer to an instance of A.
/// The principle of substitutability means that we may use an instance of A
/// anywhere that we may use an instance of B - it will implement all of the
/// ivars of B and all of the methods of B.
///
/// This substitutability is important when type checking methods, because
/// the implementation may have stricter type definitions than the interface.
/// The interface specifies minimum requirements, but the implementation may
/// have more accurate ones. For example, a method may privately accept
/// instances of B, but only publish that it accepts instances of A. Any
/// object passed to it will be type checked against B, and so will implicitly
/// by a valid A*. Similarly, a method may return a subclass of the class that
/// it is declared as returning.
///
/// This is most important when considering subclassing. A method in a
/// subclass must accept any object as an argument that its superclass's
/// implementation accepts. It may, however, accept a more general type
/// without breaking substitutability (i.e. you can still use the subclass
/// anywhere that you can use the superclass, but not vice versa). The
/// converse requirement applies to return types: the return type for a
/// subclass method must be a valid object of the kind that the superclass
/// advertises, but it may be specified more accurately. This avoids the need
/// for explicit down-casting by callers.
///
/// Note: This is a stricter requirement than for assignment.
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
static bool isObjCTypeSubstitutable(ASTContext &Context,
const ObjCObjectPointerType *A,
const ObjCObjectPointerType *B,
bool rejectId) {
// Reject a protocol-unqualified id.
if (rejectId && B->isObjCIdType()) return false;
Only warn for mismatched types in Objective-C methods when they are incompatible, not when they are simply different. Now we test whether the difference in types breaks the principle of substitutability, rather than whether they are different. A common idiom in Objective-C is to provide a definition of a method in a subclass that returns a more-specified version of an object than the superclass. This does not violate the principle of substitutability, because you can always use the object returned by the subclass anywhere that you could use the type returned by the superclass. It was, however, generating warnings with clang, leading people to believe that semantically correct code was incorrect and requiring less accurate type specification and explicit down-casts (neither of which is a good thing to encourage). This change ensures that any method definition has parameter and return types that make it accept anything that something conforming to the declaration may pass and return something that the caller will expect, but allows stricter definitions. llvm-svn: 117271
2010-10-26 01:23:52 +08:00
// If B is a qualified id, then A must also be a qualified id and it must
// implement all of the protocols in B. It may not be a qualified class.
// For example, MyClass<A> can be assigned to id<A>, but MyClass<A> is a
// stricter definition so it is not substitutable for id<A>.
if (B->isObjCQualifiedIdType()) {
return A->isObjCQualifiedIdType() &&
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
Context.ObjCQualifiedIdTypesAreCompatible(QualType(A, 0),
QualType(B,0),
false);
Only warn for mismatched types in Objective-C methods when they are incompatible, not when they are simply different. Now we test whether the difference in types breaks the principle of substitutability, rather than whether they are different. A common idiom in Objective-C is to provide a definition of a method in a subclass that returns a more-specified version of an object than the superclass. This does not violate the principle of substitutability, because you can always use the object returned by the subclass anywhere that you could use the type returned by the superclass. It was, however, generating warnings with clang, leading people to believe that semantically correct code was incorrect and requiring less accurate type specification and explicit down-casts (neither of which is a good thing to encourage). This change ensures that any method definition has parameter and return types that make it accept anything that something conforming to the declaration may pass and return something that the caller will expect, but allows stricter definitions. llvm-svn: 117271
2010-10-26 01:23:52 +08:00
}
/*
// id is a special type that bypasses type checking completely. We want a
// warning when it is used in one place but not another.
if (C.isObjCIdType(A) || C.isObjCIdType(B)) return false;
// If B is a qualified id, then A must also be a qualified id (which it isn't
// if we've got this far)
if (B->isObjCQualifiedIdType()) return false;
*/
// Now we know that A and B are (potentially-qualified) class types. The
// normal rules for assignment apply.
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
return Context.canAssignObjCInterfaces(A, B);
Only warn for mismatched types in Objective-C methods when they are incompatible, not when they are simply different. Now we test whether the difference in types breaks the principle of substitutability, rather than whether they are different. A common idiom in Objective-C is to provide a definition of a method in a subclass that returns a more-specified version of an object than the superclass. This does not violate the principle of substitutability, because you can always use the object returned by the subclass anywhere that you could use the type returned by the superclass. It was, however, generating warnings with clang, leading people to believe that semantically correct code was incorrect and requiring less accurate type specification and explicit down-casts (neither of which is a good thing to encourage). This change ensures that any method definition has parameter and return types that make it accept anything that something conforming to the declaration may pass and return something that the caller will expect, but allows stricter definitions. llvm-svn: 117271
2010-10-26 01:23:52 +08:00
}
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
static SourceRange getTypeRange(TypeSourceInfo *TSI) {
return (TSI ? TSI->getTypeLoc().getSourceRange() : SourceRange());
}
static void CheckMethodOverrideReturn(Sema &S,
ObjCMethodDecl *MethodImpl,
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
ObjCMethodDecl *MethodDecl,
bool IsProtocolMethodDecl) {
if (IsProtocolMethodDecl &&
(MethodDecl->getObjCDeclQualifier() !=
MethodImpl->getObjCDeclQualifier())) {
S.Diag(MethodImpl->getLocation(),
diag::warn_conflicting_ret_type_modifiers)
<< MethodImpl->getDeclName()
<< getTypeRange(MethodImpl->getResultTypeSourceInfo());
S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration)
<< getTypeRange(MethodDecl->getResultTypeSourceInfo());
}
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
if (S.Context.hasSameUnqualifiedType(MethodImpl->getResultType(),
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
MethodDecl->getResultType()))
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
return;
unsigned DiagID = diag::warn_conflicting_ret_types;
// Mismatches between ObjC pointers go into a different warning
// category, and sometimes they're even completely whitelisted.
if (const ObjCObjectPointerType *ImplPtrTy =
MethodImpl->getResultType()->getAs<ObjCObjectPointerType>()) {
if (const ObjCObjectPointerType *IfacePtrTy =
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
MethodDecl->getResultType()->getAs<ObjCObjectPointerType>()) {
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
// Allow non-matching return types as long as they don't violate
// the principle of substitutability. Specifically, we permit
// return types that are subclasses of the declared return type,
// or that are more-qualified versions of the declared type.
if (isObjCTypeSubstitutable(S.Context, IfacePtrTy, ImplPtrTy, false))
return;
DiagID = diag::warn_non_covariant_ret_types;
}
}
S.Diag(MethodImpl->getLocation(), DiagID)
<< MethodImpl->getDeclName()
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
<< MethodDecl->getResultType()
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
<< MethodImpl->getResultType()
<< getTypeRange(MethodImpl->getResultTypeSourceInfo());
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
S.Diag(MethodDecl->getLocation(), diag::note_previous_definition)
<< getTypeRange(MethodDecl->getResultTypeSourceInfo());
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
}
static void CheckMethodOverrideParam(Sema &S,
ObjCMethodDecl *MethodImpl,
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
ObjCMethodDecl *MethodDecl,
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
ParmVarDecl *ImplVar,
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
ParmVarDecl *IfaceVar,
bool IsProtocolMethodDecl) {
if (IsProtocolMethodDecl &&
(ImplVar->getObjCDeclQualifier() !=
IfaceVar->getObjCDeclQualifier())) {
S.Diag(ImplVar->getLocation(),
diag::warn_conflicting_param_modifiers)
<< getTypeRange(ImplVar->getTypeSourceInfo())
<< MethodImpl->getDeclName();
S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration)
<< getTypeRange(IfaceVar->getTypeSourceInfo());
}
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
QualType ImplTy = ImplVar->getType();
QualType IfaceTy = IfaceVar->getType();
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy))
return;
unsigned DiagID = diag::warn_conflicting_param_types;
// Mismatches between ObjC pointers go into a different warning
// category, and sometimes they're even completely whitelisted.
if (const ObjCObjectPointerType *ImplPtrTy =
ImplTy->getAs<ObjCObjectPointerType>()) {
if (const ObjCObjectPointerType *IfacePtrTy =
IfaceTy->getAs<ObjCObjectPointerType>()) {
// Allow non-matching argument types as long as they don't
// violate the principle of substitutability. Specifically, the
// implementation must accept any objects that the superclass
// accepts, however it may also accept others.
if (isObjCTypeSubstitutable(S.Context, ImplPtrTy, IfacePtrTy, true))
return;
DiagID = diag::warn_non_contravariant_param_types;
}
}
S.Diag(ImplVar->getLocation(), DiagID)
<< getTypeRange(ImplVar->getTypeSourceInfo())
<< MethodImpl->getDeclName() << IfaceTy << ImplTy;
S.Diag(IfaceVar->getLocation(), diag::note_previous_definition)
<< getTypeRange(IfaceVar->getTypeSourceInfo());
}
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
/// In ARC, check whether the conventional meanings of the two methods
/// match. If they don't, it's a hard error.
static bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl,
ObjCMethodDecl *decl) {
ObjCMethodFamily implFamily = impl->getMethodFamily();
ObjCMethodFamily declFamily = decl->getMethodFamily();
if (implFamily == declFamily) return false;
// Since conventions are sorted by selector, the only possibility is
// that the types differ enough to cause one selector or the other
// to fall out of the family.
assert(implFamily == OMF_None || declFamily == OMF_None);
// No further diagnostics required on invalid declarations.
if (impl->isInvalidDecl() || decl->isInvalidDecl()) return true;
const ObjCMethodDecl *unmatched = impl;
ObjCMethodFamily family = declFamily;
unsigned errorID = diag::err_arc_lost_method_convention;
unsigned noteID = diag::note_arc_lost_method_convention;
if (declFamily == OMF_None) {
unmatched = decl;
family = implFamily;
errorID = diag::err_arc_gained_method_convention;
noteID = diag::note_arc_gained_method_convention;
}
// Indexes into a %select clause in the diagnostic.
enum FamilySelector {
F_alloc, F_copy, F_mutableCopy = F_copy, F_init, F_new
};
FamilySelector familySelector = FamilySelector();
switch (family) {
case OMF_None: llvm_unreachable("logic error, no method convention");
case OMF_retain:
case OMF_release:
case OMF_autorelease:
case OMF_dealloc:
case OMF_retainCount:
case OMF_self:
objc-arc: enforce performSelector rules in rejecting retaining selectors passed to it, and unknown selectors causing potential leak. // rdar://9659270 llvm-svn: 134449
2011-07-06 06:38:59 +08:00
case OMF_performSelector:
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
// Mismatches for these methods don't change ownership
// conventions, so we don't care.
return false;
case OMF_init: familySelector = F_init; break;
case OMF_alloc: familySelector = F_alloc; break;
case OMF_copy: familySelector = F_copy; break;
case OMF_mutableCopy: familySelector = F_mutableCopy; break;
case OMF_new: familySelector = F_new; break;
}
enum ReasonSelector { R_NonObjectReturn, R_UnrelatedReturn };
ReasonSelector reasonSelector;
// The only reason these methods don't fall within their families is
// due to unusual result types.
if (unmatched->getResultType()->isObjCObjectPointerType()) {
reasonSelector = R_UnrelatedReturn;
} else {
reasonSelector = R_NonObjectReturn;
}
S.Diag(impl->getLocation(), errorID) << familySelector << reasonSelector;
S.Diag(decl->getLocation(), noteID) << familySelector << reasonSelector;
return true;
}
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
(instance/class) Method type checking between class and its implementation. (instance/class) Method type checking between category and its implementation. And a test case for all. llvm-svn: 60598
2008-12-06 02:18:52 +08:00
void Sema::WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethodDecl,
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
ObjCMethodDecl *MethodDecl,
bool IsProtocolMethodDecl) {
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 (getLangOptions().ObjCAutoRefCount &&
checkMethodFamilyMismatch(*this, ImpMethodDecl, MethodDecl))
return;
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl,
IsProtocolMethodDecl);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
improve the 'conflicting types' diagnostics to include correct location info, now that it is plumbed through Sema. On a file from growl, we used to emit: t.mi:107059:1: warning: conflicting types for 'removePluginHandler:forPluginTypes:' - (void) removePluginHandler:(id <GrowlPluginHandler>)handler forPluginTypes:(NSSet *)extensions { ^ t.mi:105280:1: note: previous definition is here - (void) removePluginHandler:(id <NSObject>)handler forPluginTypes:(NSSet *)types; ^ now we produce: t.mi:107059:55: warning: conflicting parameter types in implementation of 'removePluginHandler:forPluginTypes:': 'id<NSObject>' vs 'id<GrowlPluginHandler>' - (void) removePluginHandler:(id <GrowlPluginHandler>)handler forPluginTypes:(NSSet *)extensions { ^ t.mi:105280:45: note: previous definition is here - (void) removePluginHandler:(id <NSObject>)handler forPluginTypes:(NSSet *)types; ^ We still don't have proper loc info for properties, hence the FIXME. rdar://6782494 llvm-svn: 68879
2009-04-12 03:58:42 +08:00
for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end();
Implement the newest status quo for method override checking. The idea now is that we need more information to decide the exact conditions for whether one ObjCObjectPointer is an acceptable return/parameter override for another, so we're going to disable that entire class of warning for now. The "forward developement" warning category, -Wmethod-signatures, can receive unrestricted feature work, and when we're happy with how it acts, we'll turn it on by default. This is a pretty conservative change, and nobody's totally content with it. llvm-svn: 117524
2010-10-28 10:34:38 +08:00
IM != EM; ++IM, ++IF)
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl, *IM, *IF,
IsProtocolMethodDecl);
Only warn for mismatched types in Objective-C methods when they are incompatible, not when they are simply different. Now we test whether the difference in types breaks the principle of substitutability, rather than whether they are different. A common idiom in Objective-C is to provide a definition of a method in a subclass that returns a more-specified version of an object than the superclass. This does not violate the principle of substitutability, because you can always use the object returned by the subclass anywhere that you could use the type returned by the superclass. It was, however, generating warnings with clang, leading people to believe that semantically correct code was incorrect and requiring less accurate type specification and explicit down-casts (neither of which is a good thing to encourage). This change ensures that any method definition has parameter and return types that make it accept anything that something conforming to the declaration may pass and return something that the caller will expect, but allows stricter definitions. llvm-svn: 117271
2010-10-26 01:23:52 +08:00
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
if (ImpMethodDecl->isVariadic() != MethodDecl->isVariadic()) {
Clang missing warning about conflicting declaration vs. definition for variable arguments list methods. (radar 8006060). llvm-svn: 104407
2010-05-22 07:28:58 +08:00
Diag(ImpMethodDecl->getLocation(), diag::warn_conflicting_variadic);
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
Clang missing warning about conflicting declaration vs. definition for variable arguments list methods. (radar 8006060). llvm-svn: 104407
2010-05-22 07:28:58 +08:00
}
(instance/class) Method type checking between class and its implementation. (instance/class) Method type checking between category and its implementation. And a test case for all. llvm-svn: 60598
2008-12-06 02:18:52 +08:00
}
Reflow some comments. llvm-svn: 71936
2009-05-16 15:39:55 +08:00
/// FIXME: Type hierarchies in Objective-C can be deep. We could most likely
/// improve the efficiency of selector lookups and type checking by associating
/// with each protocol / interface / category the flattened instance tables. If
/// we used an immutable set to keep the table then it wouldn't add significant
/// memory cost and it would be handy for lookups.
Add synthesized property methods to protocols and categories in Sema. - It is not clear that this is the right approach, but this is at least consistent with how interfaces are handled. - This means NeXT now emits the correct metadata for properties in protocols. - This currently introduces a spurious warning involving inherited properties in protocols or categories; however, it also fixes some situations where we were failing to emit a warning. I will scrub this code tomorrow and fix this issue as well as number of other missed warnings / error situations that appear to exist. llvm-svn: 55407
2008-08-27 13:40:03 +08:00
A bunch-o changes to fix <rdar://problem/5716046> incomplete implementation of ObjC class warning is incomplete As part of this fix, I made a low-level change to the text diagnostics machinery (to basically avoid printing duplicate source lines/carets when you have multiple diagnostics that refer to the same exact place). For now, this only happens with we don't have a source range (could be extended to support source ranges as well). llvm-svn: 46897
2008-02-09 06:06:17 +08:00
/// CheckProtocolMethodDefs - This routine checks unimplemented methods
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
/// Declared in protocol, and those referenced by it.
A bunch-o changes to fix <rdar://problem/5716046> incomplete implementation of ObjC class warning is incomplete As part of this fix, I made a low-level change to the text diagnostics machinery (to basically avoid printing duplicate source lines/carets when you have multiple diagnostics that refer to the same exact place). For now, this only happens with we don't have a source range (could be extended to support source ranges as well). llvm-svn: 46897
2008-02-09 06:06:17 +08:00
void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc,
ObjCProtocolDecl *PDecl,
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
bool& IncompleteImpl,
A bunch-o changes to fix <rdar://problem/5716046> incomplete implementation of ObjC class warning is incomplete As part of this fix, I made a low-level change to the text diagnostics machinery (to basically avoid printing duplicate source lines/carets when you have multiple diagnostics that refer to the same exact place). For now, this only happens with we don't have a source range (could be extended to support source ranges as well). llvm-svn: 46897
2008-02-09 06:06:17 +08:00
const llvm::DenseSet<Selector> &InsMap,
Prevent invalid warnings about incomplete implementations for methods which are inherited from base clases or protocols. llvm-svn: 55790
2008-09-05 04:01:15 +08:00
const llvm::DenseSet<Selector> &ClsMap,
Further improvement to point to category whose protocolls methods needs implementation. llvm-svn: 99730
2010-03-28 05:10:05 +08:00
ObjCContainerDecl *CDecl) {
ObjCInterfaceDecl *IDecl;
if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl))
IDecl = C->getClassInterface();
else
IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl);
assert (IDecl && "CheckProtocolMethodDefs - IDecl is null");
Prevent invalid warnings about incomplete implementations for methods which are inherited from base clases or protocols. llvm-svn: 55790
2008-09-05 04:01:15 +08:00
ObjCInterfaceDecl *Super = IDecl->getSuperClass();
(Next runtime only) check to see if class implements forwardInvocation method and objects of this class are derived from 'NSProxy'. Under such conditions, which means that every method possible is implemented in the class, we should not issue "Method definition not found" warnings. llvm-svn: 72267
2009-05-23 01:12:32 +08:00
ObjCInterfaceDecl *NSIDecl = 0;
if (getLangOptions().NeXTRuntime) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// check to see if class implements forwardInvocation method and objects
// of this class are derived from 'NSProxy' so that to forward requests
(Next runtime only) check to see if class implements forwardInvocation method and objects of this class are derived from 'NSProxy'. Under such conditions, which means that every method possible is implemented in the class, we should not issue "Method definition not found" warnings. llvm-svn: 72267
2009-05-23 01:12:32 +08:00
// from one object to another.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// Under such conditions, which means that every method possible is
// implemented in the class, we should not issue "Method definition not
(Next runtime only) check to see if class implements forwardInvocation method and objects of this class are derived from 'NSProxy'. Under such conditions, which means that every method possible is implemented in the class, we should not issue "Method definition not found" warnings. llvm-svn: 72267
2009-05-23 01:12:32 +08:00
// found" warnings.
// FIXME: Use a general GetUnarySelector method for this.
IdentifierInfo* II = &Context.Idents.get("forwardInvocation");
Selector fISelector = Context.Selectors.getSelector(1, &II);
if (InsMap.count(fISelector))
// Is IDecl derived from 'NSProxy'? If so, no instance methods
// need be implemented in the implementation.
NSIDecl = IDecl->lookupInheritedClass(&Context.Idents.get("NSProxy"));
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Prevent invalid warnings about incomplete implementations for methods which are inherited from base clases or protocols. llvm-svn: 55790
2008-09-05 04:01:15 +08:00
// If a method lookup fails locally we still need to look and see if
// the method was implemented by a base class or an inherited
// protocol. This lookup is slow, but occurs rarely in correct code
// and otherwise would terminate in a warning.
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// check unimplemented instance methods.
(Next runtime only) check to see if class implements forwardInvocation method and objects of this class are derived from 'NSProxy'. Under such conditions, which means that every method possible is implemented in the class, we should not issue "Method definition not found" warnings. llvm-svn: 72267
2009-05-23 01:12:32 +08:00
if (!NSIDecl)
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
E = PDecl->instmeth_end(); I != E; ++I) {
(Next runtime only) check to see if class implements forwardInvocation method and objects of this class are derived from 'NSProxy'. Under such conditions, which means that every method possible is implemented in the class, we should not issue "Method definition not found" warnings. llvm-svn: 72267
2009-05-23 01:12:32 +08:00
ObjCMethodDecl *method = *I;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
(Next runtime only) check to see if class implements forwardInvocation method and objects of this class are derived from 'NSProxy'. Under such conditions, which means that every method possible is implemented in the class, we should not issue "Method definition not found" warnings. llvm-svn: 72267
2009-05-23 01:12:32 +08:00
!method->isSynthesized() && !InsMap.count(method->getSelector()) &&
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
(!Super ||
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
!Super->lookupInstanceMethod(method->getSelector()))) {
(Next runtime only) check to see if class implements forwardInvocation method and objects of this class are derived from 'NSProxy'. Under such conditions, which means that every method possible is implemented in the class, we should not issue "Method definition not found" warnings. llvm-svn: 72267
2009-05-23 01:12:32 +08:00
// Ugly, but necessary. Method declared in protcol might have
// have been synthesized due to a property declared in the class which
// uses the protocol.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCMethodDecl *MethodInClass =
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
IDecl->lookupInstanceMethod(method->getSelector());
Improve diagnostics on incomplete implementation of objc classes; including which methods need be implemented and where they come from. WIP. llvm-svn: 99724
2010-03-28 03:02:17 +08:00
if (!MethodInClass || !MethodInClass->isSynthesized()) {
Patch implements gcc's -Wno-protocol option to suppress warning on unimplemented methods in protocols adopted by a class. (radar 7056600). llvm-svn: 100028
2010-04-01 02:23:33 +08:00
unsigned DIAG = diag::warn_unimplemented_protocol_method;
Fix diagnostic pragmas. Diagnostic pragmas are broken because we don't keep track of the diagnostic state changes and we only check the current/latest state. Problems manifest if a diagnostic is emitted for a source line that has different diagnostic state than the current state; this can affect a lot of places, like C++ inline methods, template instantiations, the lexer, etc. Fix the issue by having the Diagnostic object keep track of the source location of the pragmas so that it is able to know what is the diagnostic state at any given source location. Fixes rdar://8365684. llvm-svn: 121873
2010-12-16 02:44:22 +08:00
if (Diags.getDiagnosticLevel(DIAG, ImpLoc)
!= Diagnostic::Ignored) {
Patch implements gcc's -Wno-protocol option to suppress warning on unimplemented methods in protocols adopted by a class. (radar 7056600). llvm-svn: 100028
2010-04-01 02:23:33 +08:00
WarnUndefinedMethod(ImpLoc, method, IncompleteImpl, DIAG);
Improve diagnostics reporting of un-implemented methods in protocols when protocols are in system headers and thus ignored. //rdar: //8227199 llvm-svn: 117739
2010-10-30 07:20:05 +08:00
Diag(method->getLocation(), diag::note_method_declared_at);
Patch implements gcc's -Wno-protocol option to suppress warning on unimplemented methods in protocols adopted by a class. (radar 7056600). llvm-svn: 100028
2010-04-01 02:23:33 +08:00
Diag(CDecl->getLocation(), diag::note_required_for_protocol_at)
<< PDecl->getDeclName();
}
Improve diagnostics on incomplete implementation of objc classes; including which methods need be implemented and where they come from. WIP. llvm-svn: 99724
2010-03-28 03:02:17 +08:00
}
(Next runtime only) check to see if class implements forwardInvocation method and objects of this class are derived from 'NSProxy'. Under such conditions, which means that every method possible is implemented in the class, we should not issue "Method definition not found" warnings. llvm-svn: 72267
2009-05-23 01:12:32 +08:00
}
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// check unimplemented class methods
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (ObjCProtocolDecl::classmeth_iterator
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
I = PDecl->classmeth_begin(), E = PDecl->classmeth_end();
Propagate the ASTContext to various AST traversal and lookup functions. No functionality change (really). llvm-svn: 68726
2009-04-10 05:40:53 +08:00
I != E; ++I) {
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
ObjCMethodDecl *method = *I;
Prevent invalid warnings about incomplete implementations for methods which are inherited from base clases or protocols. llvm-svn: 55790
2008-09-05 04:01:15 +08:00
if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
!ClsMap.count(method->getSelector()) &&
Improve diagnostics on incomplete implementation of objc classes; including which methods need be implemented and where they come from. WIP. llvm-svn: 99724
2010-03-28 03:02:17 +08:00
(!Super || !Super->lookupClassMethod(method->getSelector()))) {
Patch implements gcc's -Wno-protocol option to suppress warning on unimplemented methods in protocols adopted by a class. (radar 7056600). llvm-svn: 100028
2010-04-01 02:23:33 +08:00
unsigned DIAG = diag::warn_unimplemented_protocol_method;
Fix diagnostic pragmas. Diagnostic pragmas are broken because we don't keep track of the diagnostic state changes and we only check the current/latest state. Problems manifest if a diagnostic is emitted for a source line that has different diagnostic state than the current state; this can affect a lot of places, like C++ inline methods, template instantiations, the lexer, etc. Fix the issue by having the Diagnostic object keep track of the source location of the pragmas so that it is able to know what is the diagnostic state at any given source location. Fixes rdar://8365684. llvm-svn: 121873
2010-12-16 02:44:22 +08:00
if (Diags.getDiagnosticLevel(DIAG, ImpLoc) != Diagnostic::Ignored) {
Patch implements gcc's -Wno-protocol option to suppress warning on unimplemented methods in protocols adopted by a class. (radar 7056600). llvm-svn: 100028
2010-04-01 02:23:33 +08:00
WarnUndefinedMethod(ImpLoc, method, IncompleteImpl, DIAG);
Improve diagnostics reporting of un-implemented methods in protocols when protocols are in system headers and thus ignored. //rdar: //8227199 llvm-svn: 117739
2010-10-30 07:20:05 +08:00
Diag(method->getLocation(), diag::note_method_declared_at);
Patch implements gcc's -Wno-protocol option to suppress warning on unimplemented methods in protocols adopted by a class. (radar 7056600). llvm-svn: 100028
2010-04-01 02:23:33 +08:00
Diag(IDecl->getLocation(), diag::note_required_for_protocol_at) <<
PDecl->getDeclName();
}
Improve diagnostics on incomplete implementation of objc classes; including which methods need be implemented and where they come from. WIP. llvm-svn: 99724
2010-03-28 03:02:17 +08:00
}
- Remove getInstanceMethods/getClassMethods API on ObjcInterfaceDecl, ObjcProtocolDecl, and ObjcCategoryDecl. These methods are replaced by the respective iterators on each class. - Add getInstanceMethodForSelector to ObjcInterfaceDecl, ObjcProtocolDecl, and ObjcCatgoryDecl. This hook will do a "shallow" lookup. This is a convenience method that reducing some of the iterator usage. - Various changes to convert all clients to the above API's... llvm-svn: 45046
2007-12-15 07:37:57 +08:00
}
move two more lists of protocols over to use ObjCList<ObjCProtocolDecl>, simplifying code along the way and fixing a problem and memory leak or two. llvm-svn: 53876
2008-07-22 05:32:27 +08:00
// Check on this protocols's referenced protocols, recursively.
for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(),
E = PDecl->protocol_end(); PI != E; ++PI)
Prevent invalid warnings about incomplete implementations for methods which are inherited from base clases or protocols. llvm-svn: 55790
2008-09-05 04:01:15 +08:00
CheckProtocolMethodDefs(ImpLoc, *PI, IncompleteImpl, InsMap, ClsMap, IDecl);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Fix a typo. llvm-svn: 135328
2011-07-16 08:08:33 +08:00
/// MatchAllMethodDeclarations - Check methods declared in interface
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
/// or protocol against those declared in their implementations.
///
void Sema::MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
const llvm::DenseSet<Selector> &ClsMap,
llvm::DenseSet<Selector> &InsMapSeen,
llvm::DenseSet<Selector> &ClsMapSeen,
ObjCImplDecl* IMPDecl,
ObjCContainerDecl* CDecl,
bool &IncompleteImpl,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
bool ImmediateClass) {
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
// Check and see if instance methods in class interface have been
// implemented in the implementation class. If so, their types match.
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
for (ObjCInterfaceDecl::instmeth_iterator I = CDecl->instmeth_begin(),
E = CDecl->instmeth_end(); I != E; ++I) {
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
if (InsMapSeen.count((*I)->getSelector()))
continue;
InsMapSeen.insert((*I)->getSelector());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (!(*I)->isSynthesized() &&
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
!InsMap.count((*I)->getSelector())) {
if (ImmediateClass)
Patch implements gcc's -Wno-protocol option to suppress warning on unimplemented methods in protocols adopted by a class. (radar 7056600). llvm-svn: 100028
2010-04-01 02:23:33 +08:00
WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl,
diag::note_undef_method_impl);
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
continue;
Canonicalize else. llvm-svn: 78102
2009-08-05 05:02:39 +08:00
} else {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCMethodDecl *ImpMethodDecl =
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
IMPDecl->getInstanceMethod((*I)->getSelector());
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
ObjCMethodDecl *MethodDecl =
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
CDecl->getInstanceMethod((*I)->getSelector());
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
assert(MethodDecl &&
"MethodDecl is null in ImplMethodsVsClassMethods");
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
// ImpMethodDecl may be null as in a @dynamic property.
if (ImpMethodDecl)
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
WarnConflictingTypedMethods(ImpMethodDecl, MethodDecl,
isa<ObjCProtocolDecl>(CDecl));
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
// Check and see if class methods in class interface have been
// implemented in the implementation class. If so, their types match.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (ObjCInterfaceDecl::classmeth_iterator
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
I = CDecl->classmeth_begin(), E = CDecl->classmeth_end(); I != E; ++I) {
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
if (ClsMapSeen.count((*I)->getSelector()))
continue;
ClsMapSeen.insert((*I)->getSelector());
if (!ClsMap.count((*I)->getSelector())) {
if (ImmediateClass)
Patch implements gcc's -Wno-protocol option to suppress warning on unimplemented methods in protocols adopted by a class. (radar 7056600). llvm-svn: 100028
2010-04-01 02:23:33 +08:00
WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl,
diag::note_undef_method_impl);
Canonicalize else. llvm-svn: 78102
2009-08-05 05:02:39 +08:00
} else {
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
ObjCMethodDecl *ImpMethodDecl =
IMPDecl->getClassMethod((*I)->getSelector());
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
ObjCMethodDecl *MethodDecl =
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
CDecl->getClassMethod((*I)->getSelector());
Warn when type modifiers on objc method declarations in protocols do not match with method implementation. // rdar://7076235 llvm-svn: 126162
2011-02-22 07:49:15 +08:00
WarnConflictingTypedMethods(ImpMethodDecl, MethodDecl,
isa<ObjCProtocolDecl>(CDecl));
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
}
}
Method implemented in class's implementation may implement one declared in class's extension and not one declared in class's superclass. This supresses a bogus warning on method type mismatch. Fixes //rdar: // 8530080 llvm-svn: 116118
2010-10-09 06:59:25 +08:00
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
Method implemented in class's implementation may implement one declared in class's extension and not one declared in class's superclass. This supresses a bogus warning on method type mismatch. Fixes //rdar: // 8530080 llvm-svn: 116118
2010-10-09 06:59:25 +08:00
// Also methods in class extensions need be looked at next.
for (const ObjCCategoryDecl *ClsExtDecl = I->getFirstClassExtension();
ClsExtDecl; ClsExtDecl = ClsExtDecl->getNextClassExtension())
MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
IMPDecl,
const_cast<ObjCCategoryDecl *>(ClsExtDecl),
IncompleteImpl, false);
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
// Check for any implementation of a methods declared in protocol.
Split ObjCInterfaceDecl::ReferencedProtocols into two lists: ReferencedProtocols and AllReferencedProtocols. ReferencedProtocols (and thus protocol_begin(), protocol_end()) now only contains the list of protocols that were directly referenced in an @interface declaration. 'all_referenced_protocol_[begin,end]()' now returns the set of protocols that were referenced in both the @interface and class extensions. The latter is needed for semantic analysis/codegen, while the former is needed to maintain the lexical information of the original source. Fixes <rdar://problem/8380046>. llvm-svn: 112691
2010-09-01 09:21:15 +08:00
for (ObjCInterfaceDecl::all_protocol_iterator
PI = I->all_referenced_protocol_begin(),
E = I->all_referenced_protocol_end(); PI != E; ++PI)
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
IMPDecl,
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
(*PI), IncompleteImpl, false);
if (I->getSuperClass())
MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
IMPDecl,
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
I->getSuperClass(), IncompleteImpl, false);
}
}
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::ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCContainerDecl* CDecl,
"This patch uses the new ObjCImplDecl class to merge Sema::ImplMethodsVsClassMethods and Sema::ImplCategoryMethodsVsIntfMethods methods. And now, when clang check a class implementation to find unimplemented methods, it also checks all methods from the class extensions (unnamed categories). There is also a test case to check this warning. This patch contains also a minor update for ObjCImplDecl . getNameAsCString and getNameAsString now returns an empty string instead of crashing for unnamed categories." Patch by Jean-Daniel Dupas! llvm-svn: 65744
2009-03-01 08:56:52 +08:00
bool IncompleteImpl) {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
llvm::DenseSet<Selector> InsMap;
// Check and see if instance methods in class interface have been
// implemented in the implementation class.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (ObjCImplementationDecl::instmeth_iterator
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
I = IMPDecl->instmeth_begin(), E = IMPDecl->instmeth_end(); I!=E; ++I)
unbreak the build. I'm still working on test failures. llvm-svn: 44938
2007-12-13 01:58:05 +08:00
InsMap.insert((*I)->getSelector());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Diagnose properties which have no implementations; either unimplemented setter/getter or no implementation directive. llvm-svn: 69098
2009-04-15 07:15:21 +08:00
// Check and see if properties declared in the interface have either 1)
// an implementation or 2) there is a @synthesize/@dynamic implementation
// of the property in the @implementation.
Add -fobjc-default-synthesized-properties flag to allow us to explicitly control whether or not Objective-C properties are default synthesized. Currently this feature only works when using the -fobjc-non-fragile-abi2 flag (so there is no functionality change), but we can now turn off this feature without turning off all the features coupled with -fobjc-non-fragile-abi2. llvm-svn: 122519
2010-12-24 05:35:43 +08:00
if (isa<ObjCInterfaceDecl>(CDecl) &&
!(LangOpts.ObjCDefaultSynthProperties && LangOpts.ObjCNonFragileABI2))
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
DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, InsMap);
Patch to implement required warnings for unimplemented properties imported frfom protocol. Fixes radar 7544809. llvm-svn: 93965
2010-01-20 09:51:55 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
llvm::DenseSet<Selector> ClsMap;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (ObjCImplementationDecl::classmeth_iterator
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
I = IMPDecl->classmeth_begin(),
E = IMPDecl->classmeth_end(); I != E; ++I)
unbreak the build. I'm still working on test failures. llvm-svn: 44938
2007-12-13 01:58:05 +08:00
ClsMap.insert((*I)->getSelector());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
// Check for type conflict of methods declared in a class/protocol and
// its implementation; if any.
llvm::DenseSet<Selector> InsMapSeen, ClsMapSeen;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
IMPDecl, CDecl,
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
IncompleteImpl, true);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Check the protocol list for unimplemented methods in the @implementation
// class.
Check for method type conflict between declaration in class/protocol and implementation which could be an imm. implementation or down in the inheritance hierarchy. llvm-svn: 70568
2009-05-02 04:07:12 +08:00
// Check and see if class methods in class interface have been
// implemented in the implementation class.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
"This patch uses the new ObjCImplDecl class to merge Sema::ImplMethodsVsClassMethods and Sema::ImplCategoryMethodsVsIntfMethods methods. And now, when clang check a class implementation to find unimplemented methods, it also checks all methods from the class extensions (unnamed categories). There is also a test case to check this warning. This patch contains also a minor update for ObjCImplDecl . getNameAsCString and getNameAsString now returns an empty string instead of crashing for unnamed categories." Patch by Jean-Daniel Dupas! llvm-svn: 65744
2009-03-01 08:56:52 +08:00
if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
Split ObjCInterfaceDecl::ReferencedProtocols into two lists: ReferencedProtocols and AllReferencedProtocols. ReferencedProtocols (and thus protocol_begin(), protocol_end()) now only contains the list of protocols that were directly referenced in an @interface declaration. 'all_referenced_protocol_[begin,end]()' now returns the set of protocols that were referenced in both the @interface and class extensions. The latter is needed for semantic analysis/codegen, while the former is needed to maintain the lexical information of the original source. Fixes <rdar://problem/8380046>. llvm-svn: 112691
2010-09-01 09:21:15 +08:00
for (ObjCInterfaceDecl::all_protocol_iterator
PI = I->all_referenced_protocol_begin(),
E = I->all_referenced_protocol_end(); PI != E; ++PI)
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl,
"This patch uses the new ObjCImplDecl class to merge Sema::ImplMethodsVsClassMethods and Sema::ImplCategoryMethodsVsIntfMethods methods. And now, when clang check a class implementation to find unimplemented methods, it also checks all methods from the class extensions (unnamed categories). There is also a test case to check this warning. This patch contains also a minor update for ObjCImplDecl . getNameAsCString and getNameAsString now returns an empty string instead of crashing for unnamed categories." Patch by Jean-Daniel Dupas! llvm-svn: 65744
2009-03-01 08:56:52 +08:00
InsMap, ClsMap, I);
// Check class extensions (unnamed categories)
Patch to provide separate ASTs for multiple ObjC class extension declarations (implements radar 7928731). llvm-svn: 106597
2010-06-23 07:20:40 +08:00
for (const ObjCCategoryDecl *Categories = I->getFirstClassExtension();
Categories; Categories = Categories->getNextClassExtension())
ImplMethodsVsClassMethods(S, IMPDecl,
const_cast<ObjCCategoryDecl*>(Categories),
IncompleteImpl);
"This patch uses the new ObjCImplDecl class to merge Sema::ImplMethodsVsClassMethods and Sema::ImplCategoryMethodsVsIntfMethods methods. And now, when clang check a class implementation to find unimplemented methods, it also checks all methods from the class extensions (unnamed categories). There is also a test case to check this warning. This patch contains also a minor update for ObjCImplDecl . getNameAsCString and getNameAsString now returns an empty string instead of crashing for unnamed categories." Patch by Jean-Daniel Dupas! llvm-svn: 65744
2009-03-01 08:56:52 +08:00
} else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
tweaked my last patch to 1) preserve the protocol in extension class's protocol list so its AST is complete. 2) Because of this no need to issue warning on unimplemeted methods coming from the extended class protocols because warning is issued when class definition is seen. llvm-svn: 83326
2009-10-06 05:32:49 +08:00
// For extended class, unimplemented methods in its protocols will
// be reported in the primary class.
Class continuation now has its own property ast for those declared in it. This is to allow duplicate property diagnostics for properties declared in class extensions multiple times (radar 7629420) and for future use. llvm-svn: 96276
2010-02-16 05:55:26 +08:00
if (!C->IsClassExtension()) {
tweaked my last patch to 1) preserve the protocol in extension class's protocol list so its AST is complete. 2) Because of this no need to issue warning on unimplemeted methods coming from the extended class protocols because warning is issued when class definition is seen. llvm-svn: 83326
2009-10-06 05:32:49 +08:00
for (ObjCCategoryDecl::protocol_iterator PI = C->protocol_begin(),
E = C->protocol_end(); PI != E; ++PI)
CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl,
Further improvement to point to category whose protocolls methods needs implementation. llvm-svn: 99730
2010-03-28 05:10:05 +08:00
InsMap, ClsMap, CDecl);
Settled rule on warning on unimplemented property in category implementation when some implementations are missing in the primary class implementation. (fixes radar 6505200). llvm-svn: 94014
2010-01-21 03:36:21 +08:00
// Report unimplemented properties in the category as well.
// When reporting on missing setter/getters, do not report when
// setter/getter is implemented in category's primary class
// implementation.
if (ObjCInterfaceDecl *ID = C->getClassInterface())
if (ObjCImplDecl *IMP = ID->getImplementation()) {
for (ObjCImplementationDecl::instmeth_iterator
I = IMP->instmeth_begin(), E = IMP->instmeth_end(); I!=E; ++I)
InsMap.insert((*I)->getSelector());
}
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
DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, InsMap);
Settled rule on warning on unimplemented property in category implementation when some implementations are missing in the primary class implementation. (fixes radar 6505200). llvm-svn: 94014
2010-01-21 03:36:21 +08:00
}
"This patch uses the new ObjCImplDecl class to merge Sema::ImplMethodsVsClassMethods and Sema::ImplCategoryMethodsVsIntfMethods methods. And now, when clang check a class implementation to find unimplemented methods, it also checks all methods from the class extensions (unnamed categories). There is also a test case to check this warning. This patch contains also a minor update for ObjCImplDecl . getNameAsCString and getNameAsString now returns an empty string instead of crashing for unnamed categories." Patch by Jean-Daniel Dupas! llvm-svn: 65744
2009-03-01 08:56:52 +08:00
} else
assert(false && "invalid ObjCContainerDecl type.");
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// ActOnForwardClassDeclaration -
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
code cleanup llvm-svn: 64651
2009-02-17 03:25:52 +08:00
IdentifierInfo **IdentList,
Pass source locations of identifiers referenced by @class through Action::ActOnForwardClassDeclaration(). llvm-svn: 89162
2009-11-18 07:12:20 +08:00
SourceLocation *IdentLocs,
code cleanup llvm-svn: 64651
2009-02-17 03:25:52 +08:00
unsigned NumElts) {
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
llvm::SmallVector<ObjCInterfaceDecl*, 32> Interfaces;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
for (unsigned i = 0; i != NumElts; ++i) {
// Check for another declaration kind with the same name.
Refactor the LookupResult API to simplify most common operations. Require users to pass a LookupResult reference to lookup routines. Call out uses which assume a single result. llvm-svn: 83674
2009-10-10 05:13:30 +08:00
NamedDecl *PrevDecl
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
= LookupSingleName(TUScope, IdentList[i], IdentLocs[i],
Audit uses of Sema::LookupSingleName for those lookups that are intended for redeclarations, fixing those that need it. Fixes PR6831. This uncovered an issue where the C++ type-specifier-seq parsing logic would try to perform name lookup on an identifier after it already had a type-specifier, which could also lead to spurious ambiguity errors (as in PR6831, but with a different test case). llvm-svn: 101419
2010-04-16 07:40:53 +08:00
LookupOrdinaryName, ForRedeclaration);
Move Sema::isTemplateParameterDecl to Decl::isTemplateParameter, where it belongs llvm-svn: 60708
2008-12-09 02:40:42 +08:00
if (PrevDecl && PrevDecl->isTemplateParameter()) {
Representation of template type parameters and non-type template parameters, with some semantic analysis: - Template parameters are introduced into template parameter scope - Complain about template parameter shadowing (except in Microsoft mode) Note that we leak template parameter declarations like crazy, a problem we'll remedy once we actually create proper declarations for templates. Next up: dependent types and value-dependent/type-dependent expressions. llvm-svn: 60597
2008-12-06 02:15:24 +08:00
// Maybe we will complain about the shadowed template parameter.
DiagnoseTemplateParameterShadow(AtClassLoc, PrevDecl);
// Just pretend that we didn't see the previous declaration.
PrevDecl = 0;
}
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Second half of "fix" for <rdar://problem/5986085> clang on xcode: error: redefinition of 'XCElementToggler' as different kind of symbol llvm-svn: 52024
2008-06-06 06:57:10 +08:00
// GCC apparently allows the following idiom:
//
// typedef NSObject < XCElementTogglerP > XCElementToggler;
// @class XCElementToggler;
//
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// FIXME: Make an extension?
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(PrevDecl);
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 (!TDD || !TDD->getUnderlyingType()->isObjCObjectType()) {
stop calling II::getName() unnecesarily in sema llvm-svn: 59609
2008-11-19 16:23:25 +08:00
Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(PrevDecl->getLocation(), diag::note_previous_definition);
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
} else {
Canonicalize else. llvm-svn: 78102
2009-08-05 05:02:39 +08:00
// a forward class declaration matching a typedef name of a class refers
// to the underlying class.
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 ObjCObjectType *OI =
TDD->getUnderlyingType()->getAs<ObjCObjectType>())
PrevDecl = OI->getInterface();
a forward class declaration matching a typedef name of a class refers to the underlying class. This is radar 6859726. Steve, please read the radar for my rational. llvm-svn: 71181
2009-05-08 05:49:26 +08:00
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
if (!IDecl) { // Not already seen? Make a forward decl.
IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassLoc,
IdentList[i], IdentLocs[i], true);
// Push the ObjCInterfaceDecl on the scope chain but do *not* add it to
// the current DeclContext. This prevents clients that walk DeclContext
// from seeing the imaginary ObjCInterfaceDecl until it is actually
// declared later (if at all). We also take care to explicitly make
// sure this declaration is visible for name lookup.
PushOnScopeChains(IDecl, TUScope, false);
CurContext->makeDeclVisibleInContext(IDecl, true);
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Interfaces.push_back(IDecl);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add SourceLocations to ObjCClassDecl for the class identifiers referenced by @class. llvm-svn: 89170
2009-11-18 08:28:11 +08:00
assert(Interfaces.size() == NumElts);
Addressed the issue in <rdar://problem/6479085>, where we failed to rewrite @class declarations that showed up within linkage specifications because those @class declarations never made it any place where the rewriter could find them. Moved all of the ObjC*Decl nodes over to ScopedDecls, so that they can live in the appropriate top-level or transparent DeclContext near the top level, e.g., TranslationUnitDecl or LinkageSpecDecl. Objective-C declarations now show up in a traversal of the declarations in a DeclContext (they didn't before!). This way, the rewriter finds all Objective-C declarations within linkage specifications. llvm-svn: 61966
2009-01-09 08:49:46 +08:00
ObjCClassDecl *CDecl = ObjCClassDecl::Create(Context, CurContext, AtClassLoc,
Add SourceLocations to ObjCClassDecl for the class identifiers referenced by @class. llvm-svn: 89170
2009-11-18 08:28:11 +08:00
Interfaces.data(), IdentLocs,
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
Interfaces.size());
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
CurContext->addDecl(CDecl);
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
CheckObjCDeclScope(CDecl);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return CDecl;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Weaken the type-matching rules for methods that return aggregates when complaining about mismatches in the global method pool. llvm-svn: 133123
2011-06-16 09:15:19 +08:00
static bool tryMatchRecordTypes(ASTContext &Context,
Sema::MethodMatchStrategy strategy,
const Type *left, const Type *right);
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 bool matchTypes(ASTContext &Context, Sema::MethodMatchStrategy strategy,
QualType leftQT, QualType rightQT) {
const Type *left =
Context.getCanonicalType(leftQT).getUnqualifiedType().getTypePtr();
const Type *right =
Context.getCanonicalType(rightQT).getUnqualifiedType().getTypePtr();
if (left == right) return true;
// If we're doing a strict match, the types have to match exactly.
if (strategy == Sema::MMS_strict) return false;
if (left->isIncompleteType() || right->isIncompleteType()) return false;
// Otherwise, use this absurdly complicated algorithm to try to
// validate the basic, low-level compatibility of the two types.
// As a minimum, require the sizes and alignments to match.
if (Context.getTypeInfo(left) != Context.getTypeInfo(right))
return false;
// Consider all the kinds of non-dependent canonical types:
// - functions and arrays aren't possible as return and parameter types
// - vector types of equal size can be arbitrarily mixed
if (isa<VectorType>(left)) return isa<VectorType>(right);
if (isa<VectorType>(right)) return false;
// - references should only match references of identical type
Weaken the type-matching rules for methods that return aggregates when complaining about mismatches in the global method pool. llvm-svn: 133123
2011-06-16 09:15:19 +08:00
// - structs, unions, and Objective-C objects must match more-or-less
// exactly
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
// - everything else should be a scalar
if (!left->isScalarType() || !right->isScalarType())
Weaken the type-matching rules for methods that return aggregates when complaining about mismatches in the global method pool. llvm-svn: 133123
2011-06-16 09:15:19 +08:00
return tryMatchRecordTypes(Context, strategy, left, right);
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
// Make scalars agree in kind, except count bools as chars.
Type::ScalarTypeKind leftSK = left->getScalarTypeKind();
Type::ScalarTypeKind rightSK = right->getScalarTypeKind();
if (leftSK == Type::STK_Bool) leftSK = Type::STK_Integral;
if (rightSK == Type::STK_Bool) rightSK = Type::STK_Integral;
// Note that data member pointers and function member pointers don't
// intermix because of the size differences.
return (leftSK == rightSK);
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Weaken the type-matching rules for methods that return aggregates when complaining about mismatches in the global method pool. llvm-svn: 133123
2011-06-16 09:15:19 +08:00
static bool tryMatchRecordTypes(ASTContext &Context,
Sema::MethodMatchStrategy strategy,
const Type *lt, const Type *rt) {
assert(lt && rt && lt != rt);
if (!isa<RecordType>(lt) || !isa<RecordType>(rt)) return false;
RecordDecl *left = cast<RecordType>(lt)->getDecl();
RecordDecl *right = cast<RecordType>(rt)->getDecl();
// Require union-hood to match.
if (left->isUnion() != right->isUnion()) return false;
// Require an exact match if either is non-POD.
if ((isa<CXXRecordDecl>(left) && !cast<CXXRecordDecl>(left)->isPOD()) ||
(isa<CXXRecordDecl>(right) && !cast<CXXRecordDecl>(right)->isPOD()))
return false;
// Require size and alignment to match.
if (Context.getTypeInfo(lt) != Context.getTypeInfo(rt)) return false;
// Require fields to match.
RecordDecl::field_iterator li = left->field_begin(), le = left->field_end();
RecordDecl::field_iterator ri = right->field_begin(), re = right->field_end();
for (; li != le && ri != re; ++li, ++ri) {
if (!matchTypes(Context, strategy, li->getType(), ri->getType()))
return false;
}
return (li == le && ri == re);
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
/// MatchTwoMethodDeclarations - Checks that two methods have matching type and
/// returns true, or false, accordingly.
/// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
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
bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *left,
const ObjCMethodDecl *right,
MethodMatchStrategy strategy) {
if (!matchTypes(Context, strategy,
left->getResultType(), right->getResultType()))
return false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
if (getLangOptions().ObjCAutoRefCount &&
(left->hasAttr<NSReturnsRetainedAttr>()
!= right->hasAttr<NSReturnsRetainedAttr>() ||
left->hasAttr<NSConsumesSelfAttr>()
!= right->hasAttr<NSConsumesSelfAttr>()))
return false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
ObjCMethodDecl::param_iterator
li = left->param_begin(), le = left->param_end(), ri = right->param_begin();
for (; li != le; ++li, ++ri) {
assert(ri != right->param_end() && "Param mismatch");
ParmVarDecl *lparm = *li, *rparm = *ri;
if (!matchTypes(Context, strategy, lparm->getType(), rparm->getType()))
return false;
if (getLangOptions().ObjCAutoRefCount &&
lparm->hasAttr<NSConsumedAttr>() != rparm->hasAttr<NSConsumedAttr>())
return false;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
return true;
}
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
/// \brief Read the contents of the method pool for a given selector from
/// external storage.
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
///
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
/// This routine should only be called once, when the method pool has no entry
/// for this selector.
Sema::GlobalMethodPool::iterator Sema::ReadMethodPool(Selector Sel) {
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
assert(ExternalSource && "We need an external AST source");
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
assert(MethodPool.find(Sel) == MethodPool.end() &&
"Selector data already loaded into the method pool");
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
// Read the method list from the external source.
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
GlobalMethods Methods = ExternalSource->ReadMethodPool(Sel);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
return MethodPool.insert(std::make_pair(Sel, Methods)).first;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
}
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
void Sema::AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl,
bool instance) {
GlobalMethodPool::iterator Pos = MethodPool.find(Method->getSelector());
if (Pos == MethodPool.end()) {
if (ExternalSource)
Pos = ReadMethodPool(Method->getSelector());
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
else
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
Pos = MethodPool.insert(std::make_pair(Method->getSelector(),
GlobalMethods())).first;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
}
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
Method->setDefined(impl);
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
ObjCMethodList &Entry = instance ? Pos->second.first : Pos->second.second;
simplify Sema::AddInstanceMethodToGlobalPool, no functionality change. llvm-svn: 66016
2009-03-04 13:16:45 +08:00
if (Entry.Method == 0) {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Haven't seen a method with this selector name yet - add it.
simplify Sema::AddInstanceMethodToGlobalPool, no functionality change. llvm-svn: 66016
2009-03-04 13:16:45 +08:00
Entry.Method = Method;
Entry.Next = 0;
return;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
simplify Sema::AddInstanceMethodToGlobalPool, no functionality change. llvm-svn: 66016
2009-03-04 13:16:45 +08:00
// We've seen a method with this name, see if we have already seen this type
// signature.
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
for (ObjCMethodList *List = &Entry; List; List = List->Next) {
bool match = MatchTwoMethodDeclarations(Method, List->Method);
if (match) {
Warn when message is sent to receiver of unknown type and there is a possibility that at runtime method is resolved to a deprecated or unavailable method. Addreses // rdar://8769853 llvm-svn: 122294
2010-12-21 08:44:01 +08:00
ObjCMethodDecl *PrevObjCMethod = List->Method;
PrevObjCMethod->setDefined(impl);
// If a method is deprecated, push it in the global pool.
// This is used for better diagnostics.
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
if (Method->isDeprecated()) {
if (!PrevObjCMethod->isDeprecated())
Warn when message is sent to receiver of unknown type and there is a possibility that at runtime method is resolved to a deprecated or unavailable method. Addreses // rdar://8769853 llvm-svn: 122294
2010-12-21 08:44:01 +08:00
List->Method = Method;
}
// If new method is unavailable, push it into global pool
// unless previous one is deprecated.
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
if (Method->isUnavailable()) {
if (PrevObjCMethod->getAvailability() < AR_Deprecated)
Warn when message is sent to receiver of unknown type and there is a possibility that at runtime method is resolved to a deprecated or unavailable method. Addreses // rdar://8769853 llvm-svn: 122294
2010-12-21 08:44:01 +08:00
List->Method = Method;
}
simplify Sema::AddInstanceMethodToGlobalPool, no functionality change. llvm-svn: 66016
2009-03-04 13:16:45 +08:00
return;
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +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
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
simplify Sema::AddInstanceMethodToGlobalPool, no functionality change. llvm-svn: 66016
2009-03-04 13:16:45 +08:00
// We have a new signature for an existing method - add it.
// This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
Allocate 'ObjCMethodList' objects (owned by Sema) using Sema's BumpPtrAllocator. Previously they were not getting freed. Fixes <rdar://problem/7635663>. llvm-svn: 95834
2010-02-11 08:53:01 +08:00
ObjCMethodList *Mem = BumpAlloc.Allocate<ObjCMethodList>();
Entry.Next = new (Mem) ObjCMethodList(Method, Entry.Next);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +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
/// Determines if this is an "acceptable" loose mismatch in the global
/// method pool. This exists mostly as a hack to get around certain
/// global mismatches which we can't afford to make warnings / errors.
/// Really, what we want is a way to take a method out of the global
/// method pool.
static bool isAcceptableMethodMismatch(ObjCMethodDecl *chosen,
ObjCMethodDecl *other) {
if (!chosen->isInstanceMethod())
return false;
Selector sel = chosen->getSelector();
if (!sel.isUnarySelector() || sel.getNameForSlot(0) != "length")
return false;
// Don't complain about mismatches for -length if the method we
// chose has an integral result type.
return (chosen->getResultType()->isIntegerType());
}
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
ObjCMethodDecl *Sema::LookupMethodInGlobalPool(Selector Sel, SourceRange R,
Implements gcc's -Wstrict-selector-match. (radar 8127244). llvm-svn: 110622
2010-08-10 07:27:58 +08:00
bool receiverIdOrClass,
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
bool warn, bool instance) {
GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
if (Pos == MethodPool.end()) {
if (ExternalSource)
Pos = ReadMethodPool(Sel);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
else
return 0;
}
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
if (warn && MethList.Method && MethList.Next) {
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
bool issueDiagnostic = false, issueError = false;
// We support a warning which complains about *any* difference in
// method signature.
bool strictSelectorMatch =
(receiverIdOrClass && warn &&
(Diags.getDiagnosticLevel(diag::warn_strict_multiple_method_decl,
R.getBegin()) !=
Diagnostic::Ignored));
Implements gcc's -Wstrict-selector-match. (radar 8127244). llvm-svn: 110622
2010-08-10 07:27:58 +08:00
if (strictSelectorMatch)
for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) {
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 (!MatchTwoMethodDeclarations(MethList.Method, Next->Method,
MMS_strict)) {
issueDiagnostic = true;
break;
}
Implements gcc's -Wstrict-selector-match. (radar 8127244). llvm-svn: 110622
2010-08-10 07:27:58 +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
// If we didn't see any strict differences, we won't see any loose
// differences. In ARC, however, we also need to check for loose
// mismatches, because most of them are errors.
if (!strictSelectorMatch ||
(issueDiagnostic && getLangOptions().ObjCAutoRefCount))
Implements gcc's -Wstrict-selector-match. (radar 8127244). llvm-svn: 110622
2010-08-10 07:27:58 +08:00
for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) {
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
// This checks if the methods differ in type mismatch.
if (!MatchTwoMethodDeclarations(MethList.Method, Next->Method,
MMS_loose) &&
!isAcceptableMethodMismatch(MethList.Method, Next->Method)) {
issueDiagnostic = true;
if (getLangOptions().ObjCAutoRefCount)
issueError = true;
break;
}
Implements gcc's -Wstrict-selector-match. (radar 8127244). llvm-svn: 110622
2010-08-10 07:27:58 +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
if (issueDiagnostic) {
if (issueError)
Diag(R.getBegin(), diag::err_arc_multiple_method_decl) << Sel << R;
else if (strictSelectorMatch)
Implements gcc's -Wstrict-selector-match. (radar 8127244). llvm-svn: 110622
2010-08-10 07:27:58 +08:00
Diag(R.getBegin(), diag::warn_strict_multiple_method_decl) << Sel << R;
else
Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R;
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(MethList.Method->getLocStart(),
issueError ? diag::note_possibility : diag::note_using)
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
<< MethList.Method->getSourceRange();
for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next)
Diag(Next->Method->getLocStart(), diag::note_also_found)
<< Next->Method->getSourceRange();
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
}
return MethList.Method;
}
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
ObjCMethodDecl *Sema::LookupImplementedMethodInGlobalPool(Selector Sel) {
Simplify global method pool implementation in Sema. No functionality change. llvm-svn: 110078
2010-08-03 07:18:59 +08:00
GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
if (Pos == MethodPool.end())
return 0;
GlobalMethods &Methods = Pos->second;
if (Methods.first.Method && Methods.first.Method->isDefined())
return Methods.first.Method;
if (Methods.second.Method && Methods.second.Method->isDefined())
return Methods.second.Method;
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
return 0;
}
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
/// CompareMethodParamsInBaseAndSuper - This routine compares methods with
/// identical selector names in current and its super classes and issues
/// a warning if any of their argument types are incompatible.
Compare matching selectors in current and super class(s) and warn on any parameter type mismatch if potentially unsafe. llvm-svn: 78029
2009-08-04 09:07:16 +08:00
void Sema::CompareMethodParamsInBaseAndSuper(Decl *ClassDecl,
ObjCMethodDecl *Method,
bool IsInstance) {
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(ClassDecl);
if (ID == 0) return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
while (ObjCInterfaceDecl *SD = ID->getSuperClass()) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCMethodDecl *SuperMethodDecl =
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
SD->lookupMethod(Method->getSelector(), IsInstance);
if (SuperMethodDecl == 0) {
Compare matching selectors in current and super class(s) and warn on any parameter type mismatch if potentially unsafe. llvm-svn: 78029
2009-08-04 09:07:16 +08:00
ID = SD;
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
continue;
Compare matching selectors in current and super class(s) and warn on any parameter type mismatch if potentially unsafe. llvm-svn: 78029
2009-08-04 09:07:16 +08:00
}
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
ObjCMethodDecl::param_iterator ParamI = Method->param_begin(),
E = Method->param_end();
ObjCMethodDecl::param_iterator PrevI = SuperMethodDecl->param_begin();
for (; ParamI != E; ++ParamI, ++PrevI) {
// Number of parameters are the same and is guaranteed by selector match.
assert(PrevI != SuperMethodDecl->param_end() && "Param mismatch");
QualType T1 = Context.getCanonicalType((*ParamI)->getType());
QualType T2 = Context.getCanonicalType((*PrevI)->getType());
fix a bunch of comment typos found by codespell. Patch by Luis Felipe Strano Moraes! llvm-svn: 129559
2011-04-15 13:22:18 +08:00
// If type of argument of method in this class does not match its
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
// respective argument type in the super class method, issue warning;
if (!Context.typesAreCompatible(T1, T2)) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Diag((*ParamI)->getLocation(), diag::ext_typecheck_base_super)
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
<< T1 << T2;
Diag(SuperMethodDecl->getLocation(), diag::note_previous_declaration);
return;
}
}
ID = SD;
}
Compare matching selectors in current and super class(s) and warn on any parameter type mismatch if potentially unsafe. llvm-svn: 78029
2009-08-04 09:07:16 +08:00
}
More Sema check for ivars in class continuation. llvm-svn: 97002
2010-02-24 07:41:11 +08:00
/// DiagnoseDuplicateIvars -
/// Check for duplicate ivars in the entire class at the start of
/// @implementation. This becomes necesssary because class extension can
/// add ivars to a class in random order which will not be known until
/// class's @implementation is seen.
void Sema::DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID,
ObjCInterfaceDecl *SID) {
for (ObjCInterfaceDecl::ivar_iterator IVI = ID->ivar_begin(),
IVE = ID->ivar_end(); IVI != IVE; ++IVI) {
ObjCIvarDecl* Ivar = (*IVI);
if (Ivar->isInvalidDecl())
continue;
if (IdentifierInfo *II = Ivar->getIdentifier()) {
ObjCIvarDecl* prevIvar = SID->lookupInstanceVariable(II);
if (prevIvar) {
Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
Diag(prevIvar->getLocation(), diag::note_previous_declaration);
Ivar->setInvalidDecl();
}
}
}
}
Improve how we find private method decls. This involved: - Changed Sema::ObjcActOnStartOfMethodDef() to register the methods with the global pools. - Changed Sema::ActOnInstanceMessage() to look in global pools (should be much less error prone). - Added a test case to message.m (for lookup that was broken). Misc changes while I was investigating this... - Changed Sema::ActOnAtEnd() to call AddFactoryMethodToGlobalPool (this looked like a cut/paste error). - Added a comment and tweaked another where I was using the first person. llvm-svn: 45142
2007-12-18 09:30:32 +08:00
// Note: For class/category implemenations, allMethods/allProperties is
// always null.
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::ActOnAtEnd(Scope *S, SourceRange AtEnd,
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *ClassDecl,
Decl **allMethods, unsigned allNum,
Decl **allProperties, unsigned pNum,
Push DeclGroup much farther throughout the compiler. Now the various productions (except the already broken ObjC cases like @class X,Y;) in the parser that can produce more than one Decl return a DeclGroup instead of a Decl, etc. This allows elimination of the Decl::NextDeclarator field, and exposes various clients that should look at all decls in a group, but which were only looking at one (such as the dumper, printer, etc). These have been fixed. Still TODO: 1) there are some FIXME's in the code about potentially using DeclGroup for better location info. 2) ParseObjCAtDirectives should return a DeclGroup due to @class etc. 3) I'm not sure what is going on with StmtIterator.cpp, or if it can be radically simplified now. 4) I put a truly horrible hack in ParseTemplate.cpp. I plan to bring up #3/4 on the mailing list, but don't plan to tackle #1/2 in the short term. llvm-svn: 68002
2009-03-30 00:50:03 +08:00
DeclGroupPtrTy *allTUVars, unsigned tuvNum) {
Improve how we find private method decls. This involved: - Changed Sema::ObjcActOnStartOfMethodDef() to register the methods with the global pools. - Changed Sema::ActOnInstanceMessage() to look in global pools (should be much less error prone). - Added a test case to message.m (for lookup that was broken). Misc changes while I was investigating this... - Changed Sema::ActOnAtEnd() to call AddFactoryMethodToGlobalPool (this looked like a cut/paste error). - Added a comment and tweaked another where I was using the first person. llvm-svn: 45142
2007-12-18 09:30:32 +08:00
// FIXME: If we don't have a ClassDecl, we have an error. We should consider
// always passing in a decl. If the decl has an error, isInvalidDecl()
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// should be true.
if (!ClassDecl)
return;
Handle case of missing '@end' in implementation context gracefully, on par with gcc, by: Issuing a warning, doing final sematinc check of its definitions and generating its meta-data. llvm-svn: 88934
2009-11-17 02:57:01 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
bool isInterfaceDeclKind =
add the last two Create methods for decls, woo! llvm-svn: 48432
2008-03-17 05:17:37 +08:00
isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
|| isa<ObjCProtocolDecl>(ClassDecl);
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
Move property API's up to ObjCContainerDecl (removing a lot of duplicate code). Add isa/cast/dyncast support for ObjCContainerDecl. Renamed classprop_iterator/begin/end to prop_iterator/begin/end (the class prefix was confusing). More simplifications to Sema::ActOnAtEnd()... Added/changed some FIXME's as a result of the above work. llvm-svn: 61988
2009-01-09 23:36:25 +08:00
Change ObjCContainerDecl to contain the entire range for the '@end' piece of the declaration. The '@' and the 'end' are separate tokens, and require two SourceLocations to accurately track. This change was motivated because ObjCContainerDecl::getSourceRange() would previously not return the entire range of the declaration (the 'end' would be left off). llvm-svn: 92891
2010-01-07 09:20:12 +08:00
if (!isInterfaceDeclKind && AtEnd.isInvalid()) {
// FIXME: This is wrong. We shouldn't be pretending that there is
// an '@end' in the declaration.
SourceLocation L = ClassDecl->getLocation();
AtEnd.setBegin(L);
AtEnd.setEnd(L);
Fixes an instance method meta-data generation bug in ObjC NeXt runtime where method pointer registered in metadata belongs to an unrelated method. Ast part of this fix, I turned at @end missing warning (for class implementations) into an error as we can never be sure that meta-data being generated is correct. // rdar://9072317 llvm-svn: 130019
2011-04-23 06:02:28 +08:00
Diag(L, diag::err_missing_atend);
Handle case of missing '@end' in implementation context gracefully, on par with gcc, by: Issuing a warning, doing final sematinc check of its definitions and generating its meta-data. llvm-svn: 88934
2009-11-17 02:57:01 +08:00
}
This is a large/messy diff that unifies the ObjC AST's with DeclContext. - ObjCContainerDecl's (ObjCInterfaceDecl/ObjCCategoryDecl/ObjCProtocolDecl), ObjCCategoryImpl, & ObjCImplementation are all DeclContexts. - ObjCMethodDecl is now a ScopedDecl (so it can play nicely with DeclContext). - ObjCContainerDecl now does iteration/lookup using DeclContext infrastructure (no more linear search:-) - Removed ASTContext argument to DeclContext::lookup(). It wasn't being used and complicated it's use from an ObjC AST perspective. - Added Sema::ProcessPropertyDecl() and removed Sema::diagnosePropertySetterGetterMismatch(). - Simplified Sema::ActOnAtEnd() considerably. Still more work to do. - Fixed an incorrect casting assumption in Sema::getCurFunctionOrMethodDecl(), now that ObjCMethodDecl is a ScopedDecl. - Removed addPropertyMethods from ObjCInterfaceDecl/ObjCCategoryDecl/ObjCProtocolDecl. This passes all the tests on my machine. Since many of the changes are central to the way ObjC finds it's methods, I expect some fallout (and there are still a handful of FIXME's). Nevertheless, this should be a step in the right direction. llvm-svn: 61929
2009-01-09 01:28:14 +08:00
// FIXME: Remove these and use the ObjCContainerDecl/DeclContext.
llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
for (unsigned i = 0; i < allNum; i++ ) {
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
ObjCMethodDecl *Method =
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
cast_or_null<ObjCMethodDecl>(allMethods[i]);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (!Method) continue; // Already issued a diagnostic.
Provide a new kind of iterator, the specific_decl_iterator, that filters the decls seen by decl_iterator with two criteria: the dynamic type of the declaration and a run-time predicate described by a member function. This simplifies EnumDecl, RecordDecl, and ObjCContainerDecl considerably. It has no measurable performance impact. llvm-svn: 61994
2009-01-10 01:18:27 +08:00
if (Method->isInstanceMethod()) {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
/// Check for instance method of the same name with incompatible types
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()];
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
: false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if ((isInterfaceDeclKind && PrevMethod && !match)
Silence a couple more operator precedence warnings; this shouldn't change the semantics. Please correct this if the precedence was actually supposed to be something different. llvm-svn: 61099
2008-12-17 04:15:50 +08:00
|| (checkIdenticalMethods && match)) {
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(Method->getLocation(), diag::err_duplicate_method_decl)
Rename Selector::getName() to Selector::getAsString(), and add a new NamedDecl::getAsString() method. Change uses of Selector::getName() to just pass in a Selector where possible (e.g. to diagnostics) instead of going through an std::string. This also adds new formatters for objcinstance and objcclass as described in the dox. llvm-svn: 59933
2008-11-24 11:33:13 +08:00
<< Method->getDeclName();
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
Fix a major inconsistency in the representation of Objective-C classes, categories, protocols, and class extensions, where the methods and properties of these entities would be inserted into the DeclContext in an ordering that doesn't necessarily reflect source order. The culprits were Sema::ActOnMethodDeclaration(), which did not perform the insertion of the just-created method declaration into the DeclContext for these Objective-C entities, and Sema::ActOnAtEnd(), which inserted all method declarations at the *end* of the DeclContext. With this fix in hand, clean up the code-completion actions for property setters/getters that worked around this brokenness in the AST. Fixes <rdar://problem/8062781>, where this problem manifested as poor token-annotation information, but this would have struck again in many other places. llvm-svn: 122347
2010-12-22 01:34:17 +08:00
Method->setInvalidDecl();
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
} else {
InsMap[Method->getSelector()] = Method;
/// The following allows us to typecheck messages to "id".
AddInstanceMethodToGlobalPool(Method);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// verify that the instance method conforms to the same definition of
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
// parent methods if it shadows one.
Compare matching selectors in current and super class(s) and warn on any parameter type mismatch if potentially unsafe. llvm-svn: 78029
2009-08-04 09:07:16 +08:00
CompareMethodParamsInBaseAndSuper(ClassDecl, Method, true);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Canonicalize else. llvm-svn: 78102
2009-08-05 05:02:39 +08:00
} else {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
/// Check for class method of the same name with incompatible types
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()];
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
: false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if ((isInterfaceDeclKind && PrevMethod && !match)
Silence a couple more operator precedence warnings; this shouldn't change the semantics. Please correct this if the precedence was actually supposed to be something different. llvm-svn: 61099
2008-12-17 04:15:50 +08:00
|| (checkIdenticalMethods && match)) {
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(Method->getLocation(), diag::err_duplicate_method_decl)
Rename Selector::getName() to Selector::getAsString(), and add a new NamedDecl::getAsString() method. Change uses of Selector::getName() to just pass in a Selector where possible (e.g. to diagnostics) instead of going through an std::string. This also adds new formatters for objcinstance and objcclass as described in the dox. llvm-svn: 59933
2008-11-24 11:33:13 +08:00
<< Method->getDeclName();
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
Fix a major inconsistency in the representation of Objective-C classes, categories, protocols, and class extensions, where the methods and properties of these entities would be inserted into the DeclContext in an ordering that doesn't necessarily reflect source order. The culprits were Sema::ActOnMethodDeclaration(), which did not perform the insertion of the just-created method declaration into the DeclContext for these Objective-C entities, and Sema::ActOnAtEnd(), which inserted all method declarations at the *end* of the DeclContext. With this fix in hand, clean up the code-completion actions for property setters/getters that worked around this brokenness in the AST. Fixes <rdar://problem/8062781>, where this problem manifested as poor token-annotation information, but this would have struck again in many other places. llvm-svn: 122347
2010-12-22 01:34:17 +08:00
Method->setInvalidDecl();
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
} else {
ClsMap[Method->getSelector()] = Method;
Improve how we find private method decls. This involved: - Changed Sema::ObjcActOnStartOfMethodDef() to register the methods with the global pools. - Changed Sema::ActOnInstanceMessage() to look in global pools (should be much less error prone). - Added a test case to message.m (for lookup that was broken). Misc changes while I was investigating this... - Changed Sema::ActOnAtEnd() to call AddFactoryMethodToGlobalPool (this looked like a cut/paste error). - Added a comment and tweaked another where I was using the first person. llvm-svn: 45142
2007-12-18 09:30:32 +08:00
/// The following allows us to typecheck messages to "Class".
AddFactoryMethodToGlobalPool(Method);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// verify that the class method conforms to the same definition of
Some code refactoring. Be more generous in issuance of warning on method type mismatches per Chris's comment. llvm-svn: 78075
2009-08-05 01:01:09 +08:00
// parent methods if it shadows one.
Compare matching selectors in current and super class(s) and warn on any parameter type mismatch if potentially unsafe. llvm-svn: 78029
2009-08-04 09:07:16 +08:00
CompareMethodParamsInBaseAndSuper(ClassDecl, Method, false);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
}
}
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// Compares properties declared in this class to those of its
More ObjC2 property semantics work. Work in progress. llvm-svn: 50508
2008-05-01 08:03:38 +08:00
// super class.
This patch is about merging ObjC2's properties declared in class protocols into class's property list and performing semantics on them for while doing so. llvm-svn: 50587
2008-05-03 03:17:30 +08:00
ComparePropertiesInBaseAndSuper(I);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
CompareProperties(I, I);
Move property API's up to ObjCContainerDecl (removing a lot of duplicate code). Add isa/cast/dyncast support for ObjCContainerDecl. Renamed classprop_iterator/begin/end to prop_iterator/begin/end (the class prefix was confusing). More simplifications to Sema::ActOnAtEnd()... Added/changed some FIXME's as a result of the above work. llvm-svn: 61988
2009-01-09 23:36:25 +08:00
} else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
Changed a 'FIXME' into new comment. Added a test case testing declaration of properties in categories. llvm-svn: 60625
2008-12-07 03:59:02 +08:00
// Categories are used to extend the class by declaring new methods.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// By the same token, they are also used to add new properties. No
Changed a 'FIXME' into new comment. Added a test case testing declaration of properties in categories. llvm-svn: 60625
2008-12-07 03:59:02 +08:00
// need to compare the added property to those in the class.
Add synthesized property methods to protocols and categories in Sema. - It is not clear that this is the right approach, but this is at least consistent with how interfaces are handled. - This means NeXT now emits the correct metadata for properties in protocols. - This currently introduces a spurious warning involving inherited properties in protocols or categories; however, it also fixes some situations where we were failing to emit a warning. I will scrub this code tomorrow and fix this issue as well as number of other missed warnings / error situations that appear to exist. llvm-svn: 55407
2008-08-27 13:40:03 +08:00
Mostly renaming some methods and updating comments to reflect what these methods are actually doing. One method template for future work. No change in functionality. llvm-svn: 93742
2010-01-19 02:41:16 +08:00
// Compare protocol properties with those in category
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
CompareProperties(C, C);
Any property declared in a class extension might have user declared setter or getter in current class extension or one of the other class extensions. Mark them as synthesized as property will be synthesized when property with same name is seen in the @implementation. This prevents bogus warning about unimplemented methods to be issued for these methods. Fixes // rdar://8747333 llvm-svn: 121597
2010-12-11 07:36:33 +08:00
if (C->IsClassExtension()) {
ObjCInterfaceDecl *CCPrimary = C->getClassInterface();
DiagnoseClassExtensionDupMethods(C, CCPrimary);
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Move property API's up to ObjCContainerDecl (removing a lot of duplicate code). Add isa/cast/dyncast support for ObjCContainerDecl. Renamed classprop_iterator/begin/end to prop_iterator/begin/end (the class prefix was confusing). More simplifications to Sema::ActOnAtEnd()... Added/changed some FIXME's as a result of the above work. llvm-svn: 61988
2009-01-09 23:36:25 +08:00
if (ObjCContainerDecl *CDecl = dyn_cast<ObjCContainerDecl>(ClassDecl)) {
Class continuation now has its own property ast for those declared in it. This is to allow duplicate property diagnostics for properties declared in class extensions multiple times (radar 7629420) and for future use. llvm-svn: 96276
2010-02-16 05:55:26 +08:00
if (CDecl->getIdentifier())
// ProcessPropertyDecl is responsible for diagnosing conflicts with any
// user-defined setter/getter. It also synthesizes setter/getter methods
// and adds them to the DeclContext and global method pools.
for (ObjCContainerDecl::prop_iterator I = CDecl->prop_begin(),
E = CDecl->prop_end();
I != E; ++I)
ProcessPropertyDecl(*I, CDecl);
Change ObjCContainerDecl to contain the entire range for the '@end' piece of the declaration. The '@' and the 'end' are separate tokens, and require two SourceLocations to accurately track. This change was motivated because ObjCContainerDecl::getSourceRange() would previously not return the entire range of the declaration (the 'end' would be left off). llvm-svn: 92891
2010-01-07 09:20:12 +08:00
CDecl->setAtEndRange(AtEnd);
Move property API's up to ObjCContainerDecl (removing a lot of duplicate code). Add isa/cast/dyncast support for ObjCContainerDecl. Renamed classprop_iterator/begin/end to prop_iterator/begin/end (the class prefix was confusing). More simplifications to Sema::ActOnAtEnd()... Added/changed some FIXME's as a result of the above work. llvm-svn: 61988
2009-01-09 23:36:25 +08:00
}
if (ObjCImplementationDecl *IC=dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
Change ObjCContainerDecl to contain the entire range for the '@end' piece of the declaration. The '@' and the 'end' are separate tokens, and require two SourceLocations to accurately track. This change was motivated because ObjCContainerDecl::getSourceRange() would previously not return the entire range of the declaration (the 'end' would be left off). llvm-svn: 92891
2010-01-07 09:20:12 +08:00
IC->setAtEndRange(AtEnd);
writable atomic property's setter/getter must be in 'lock' step of either both synthesized or bith user defined. Implements radar 6557233. llvm-svn: 86887
2009-11-12 06:40:11 +08:00
if (ObjCInterfaceDecl* IDecl = IC->getClassInterface()) {
Enhance my implementation of //rdar ://8747333 in r121597 to allow for declaration of property setter/getter in forward class extensions and also skip over propeties which are @dynamic. llvm-svn: 121617
2010-12-12 02:39:37 +08:00
// Any property declared in a class extension might have user
// declared setter or getter in current class extension or one
// of the other class extensions. Mark them as synthesized as
// property will be synthesized when property with same name is
// seen in the @implementation.
for (const ObjCCategoryDecl *ClsExtDecl =
IDecl->getFirstClassExtension();
ClsExtDecl; ClsExtDecl = ClsExtDecl->getNextClassExtension()) {
for (ObjCContainerDecl::prop_iterator I = ClsExtDecl->prop_begin(),
E = ClsExtDecl->prop_end(); I != E; ++I) {
ObjCPropertyDecl *Property = (*I);
// Skip over properties declared @dynamic
if (const ObjCPropertyImplDecl *PIDecl
= IC->FindPropertyImplDecl(Property->getIdentifier()))
if (PIDecl->getPropertyImplementation()
== ObjCPropertyImplDecl::Dynamic)
continue;
for (const ObjCCategoryDecl *CExtDecl =
IDecl->getFirstClassExtension();
CExtDecl; CExtDecl = CExtDecl->getNextClassExtension()) {
if (ObjCMethodDecl *GetterMethod =
CExtDecl->getInstanceMethod(Property->getGetterName()))
GetterMethod->setSynthesized(true);
if (!Property->isReadOnly())
if (ObjCMethodDecl *SetterMethod =
CExtDecl->getInstanceMethod(Property->getSetterName()))
SetterMethod->setSynthesized(true);
}
}
}
Add -fobjc-default-synthesized-properties flag to allow us to explicitly control whether or not Objective-C properties are default synthesized. Currently this feature only works when using the -fobjc-non-fragile-abi2 flag (so there is no functionality change), but we can now turn off this feature without turning off all the features coupled with -fobjc-non-fragile-abi2. llvm-svn: 122519
2010-12-24 05:35:43 +08:00
if (LangOpts.ObjCDefaultSynthProperties &&
LangOpts.ObjCNonFragileABI2)
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
DefaultSynthesizeProperties(S, IC, IDecl);
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
ImplMethodsVsClassMethods(S, IC, IDecl);
writable atomic property's setter/getter must be in 'lock' step of either both synthesized or bith user defined. Implements radar 6557233. llvm-svn: 86887
2009-11-12 06:40:11 +08:00
AtomicPropertySetterGetterRules(IC, IDecl);
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
DiagnoseOwningPropertyGetterSynthesis(IC);
objective-c ivar refactoring patch. Iterations over ivars for a varienty of puposes is now consolidated into two small routines; DeepCollectObjCIvars and ShallowCollectObjCIvars. llvm-svn: 111679
2010-08-21 05:21:08 +08:00
More Sema check for ivars in class continuation. llvm-svn: 97002
2010-02-24 07:41:11 +08:00
if (LangOpts.ObjCNonFragileABI2)
while (IDecl->getSuperClass()) {
DiagnoseDuplicateIvars(IDecl, IDecl->getSuperClass());
IDecl = IDecl->getSuperClass();
}
writable atomic property's setter/getter must be in 'lock' step of either both synthesized or bith user defined. Implements radar 6557233. llvm-svn: 86887
2009-11-12 06:40:11 +08:00
}
More of Sema to implement initialization of ivar of c++ object types. llvm-svn: 102500
2010-04-29 00:11:27 +08:00
SetIvarInitializers(IC);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
} else if (ObjCCategoryImplDecl* CatImplClass =
Move property API's up to ObjCContainerDecl (removing a lot of duplicate code). Add isa/cast/dyncast support for ObjCContainerDecl. Renamed classprop_iterator/begin/end to prop_iterator/begin/end (the class prefix was confusing). More simplifications to Sema::ActOnAtEnd()... Added/changed some FIXME's as a result of the above work. llvm-svn: 61988
2009-01-09 23:36:25 +08:00
dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
Change ObjCContainerDecl to contain the entire range for the '@end' piece of the declaration. The '@' and the 'end' are separate tokens, and require two SourceLocations to accurately track. This change was motivated because ObjCContainerDecl::getSourceRange() would previously not return the entire range of the declaration (the 'end' would be left off). llvm-svn: 92891
2010-01-07 09:20:12 +08:00
CatImplClass->setAtEndRange(AtEnd);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
// Find category interface decl and then check that all methods declared
Add synthesized property methods to protocols and categories in Sema. - It is not clear that this is the right approach, but this is at least consistent with how interfaces are handled. - This means NeXT now emits the correct metadata for properties in protocols. - This currently introduces a spurious warning involving inherited properties in protocols or categories; however, it also fixes some situations where we were failing to emit a warning. I will scrub this code tomorrow and fix this issue as well as number of other missed warnings / error situations that appear to exist. llvm-svn: 55407
2008-08-27 13:40:03 +08:00
// in this interface are implemented in the category @implementation.
propagate attributes onto property decls. llvm-svn: 64643
2009-02-17 02:32:47 +08:00
if (ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface()) {
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
for (ObjCCategoryDecl *Categories = IDecl->getCategoryList();
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Categories; Categories = Categories->getNextClassCategory()) {
if (Categories->getIdentifier() == CatImplClass->getIdentifier()) {
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
ImplMethodsVsClassMethods(S, CatImplClass, Categories);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
break;
}
}
}
}
Push DeclGroup much farther throughout the compiler. Now the various productions (except the already broken ObjC cases like @class X,Y;) in the parser that can produce more than one Decl return a DeclGroup instead of a Decl, etc. This allows elimination of the Decl::NextDeclarator field, and exposes various clients that should look at all decls in a group, but which were only looking at one (such as the dumper, printer, etc). These have been fixed. Still TODO: 1) there are some FIXME's in the code about potentially using DeclGroup for better location info. 2) ParseObjCAtDirectives should return a DeclGroup due to @class etc. 3) I'm not sure what is going on with StmtIterator.cpp, or if it can be radically simplified now. 4) I put a truly horrible hack in ParseTemplate.cpp. I plan to bring up #3/4 on the mailing list, but don't plan to tackle #1/2 in the short term. llvm-svn: 68002
2009-03-30 00:50:03 +08:00
if (isInterfaceDeclKind) {
// Reject invalid vardecls.
for (unsigned i = 0; i != tuvNum; i++) {
DeclGroupRef DG = allTUVars[i].getAsVal<DeclGroupRef>();
for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
if (VarDecl *VDecl = dyn_cast<VarDecl>(*I)) {
Audit __private_extern__ handling. - Exposed quite a few Sema issues and a CodeGen crash. - See FIXMEs in test case, and in SemaDecl.cpp (PR3983). I'm skeptical that __private_extern__ should actually be a storage class value. I think that __private_extern__ basically amounts to extern A __attribute__((visibility("hidden"))) and would be better off handled (a) as that, or (b) with an extra bit in the VarDecl. llvm-svn: 69020
2009-04-14 10:25:56 +08:00
if (!VDecl->hasExternalStorage())
Change diagnostic as a result of researching <rdar://problem/6779809> missing interface name in "error: cannot declare variable inside a class, protocol or category ''. Since ObjC 2.0 class "extensions" have a null name, the diagnostic above is actually "correct". Nevertheless, it is confusing. Decided to remove the name entirely (from my perspective, it didn't add any value). Also simplified the text of the diagnostic a bit. llvm-svn: 68967
2009-04-14 01:58:46 +08:00
Diag(VDecl->getLocation(), diag::err_objc_var_decl_inclass);
Issue error if variables are defined inside an objc class, category or protocol. llvm-svn: 67450
2009-03-22 02:06:45 +08:00
}
Push DeclGroup much farther throughout the compiler. Now the various productions (except the already broken ObjC cases like @class X,Y;) in the parser that can produce more than one Decl return a DeclGroup instead of a Decl, etc. This allows elimination of the Decl::NextDeclarator field, and exposes various clients that should look at all decls in a group, but which were only looking at one (such as the dumper, printer, etc). These have been fixed. Still TODO: 1) there are some FIXME's in the code about potentially using DeclGroup for better location info. 2) ParseObjCAtDirectives should return a DeclGroup due to @class etc. 3) I'm not sure what is going on with StmtIterator.cpp, or if it can be radically simplified now. 4) I put a truly horrible hack in ParseTemplate.cpp. I plan to bring up #3/4 on the mailing list, but don't plan to tackle #1/2 in the short term. llvm-svn: 68002
2009-03-30 00:50:03 +08:00
}
objc: Implemented variables declared in class interface whose sema decl is at the translation unit. llvm-svn: 67249
2009-03-19 06:33:24 +08:00
}
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
/// CvtQTToAstBitMask - utility routine to produce an AST bitmask for
/// objective-c's type qualifier from the parser version of the same info.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
static Decl::ObjCDeclQualifier
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) {
Improve the documentation for the two ObjCDeclQualifiers so that I stop considering whether I can compress them. :) llvm-svn: 130633
2011-05-01 11:04:29 +08:00
return (Decl::ObjCDeclQualifier) (unsigned) PQTVal;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Allow the 'ibaction' attribute to be attached to method declarations (and not issue a warning). llvm-svn: 101699
2010-04-18 12:59:38 +08:00
static inline
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
bool containsInvalidMethodImplAttribute(const AttrVec &A) {
Allow the 'ibaction' attribute to be attached to method declarations (and not issue a warning). llvm-svn: 101699
2010-04-18 12:59:38 +08:00
// The 'ibaction' attribute is allowed on method definitions because of
// how the IBAction macro is used on both method declarations and definitions.
// If the method definitions contains any other attributes, return true.
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
for (AttrVec::const_iterator i = A.begin(), e = A.end(); i != e; ++i)
if ((*i)->getKind() != attr::IBAction)
return true;
return false;
Allow the 'ibaction' attribute to be attached to method declarations (and not issue a warning). llvm-svn: 101699
2010-04-18 12:59:38 +08:00
}
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
/// \brief Check whether the declared result type of the given Objective-C
/// method declaration is compatible with the method's class.
///
static bool
CheckRelatedResultTypeCompatibility(Sema &S, ObjCMethodDecl *Method,
ObjCInterfaceDecl *CurrentClass) {
QualType ResultType = Method->getResultType();
SourceRange ResultTypeRange;
if (const TypeSourceInfo *ResultTypeInfo = Method->getResultTypeSourceInfo())
ResultTypeRange = ResultTypeInfo->getTypeLoc().getSourceRange();
// If an Objective-C method inherits its related result type, then its
// declared result type must be compatible with its own class type. The
// declared result type is compatible if:
if (const ObjCObjectPointerType *ResultObjectType
= ResultType->getAs<ObjCObjectPointerType>()) {
// - it is id or qualified id, or
if (ResultObjectType->isObjCIdType() ||
ResultObjectType->isObjCQualifiedIdType())
return false;
if (CurrentClass) {
if (ObjCInterfaceDecl *ResultClass
= ResultObjectType->getInterfaceDecl()) {
// - it is the same as the method's class type, or
if (CurrentClass == ResultClass)
return false;
// - it is a superclass of the method's class type
if (ResultClass->isSuperClassOf(CurrentClass))
return false;
}
}
}
return true;
}
/// \brief Determine if any method in the global method pool has an inferred
/// result type.
static bool
anyMethodInfersRelatedResultType(Sema &S, Selector Sel, bool IsInstance) {
Sema::GlobalMethodPool::iterator Pos = S.MethodPool.find(Sel);
if (Pos == S.MethodPool.end()) {
if (S.ExternalSource)
Pos = S.ReadMethodPool(Sel);
else
return 0;
}
ObjCMethodList &List = IsInstance ? Pos->second.first : Pos->second.second;
for (ObjCMethodList *M = &List; M; M = M->Next) {
if (M->Method && M->Method->hasRelatedResultType())
return true;
}
return false;
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *Sema::ActOnMethodDeclaration(
Fix scoping of method declarations and issue warning when same parameter name used multiple times. // rdar://8877730 llvm-svn: 125229
2011-02-10 06:20:01 +08:00
Scope *S,
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
SourceLocation MethodLoc, SourceLocation EndLoc,
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
tok::TokenKind MethodType, Decl *ClassDecl,
Abstract out passing around types and kill off ActionBase. llvm-svn: 111901
2010-08-24 13:47:05 +08:00
ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
SourceLocation SelectorStartLoc,
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Selector Sel,
// optional arguments. The number of types/arguments is obtained
// from the Sel.getNumArgs().
change the interface to ActOnMethodDeclaration to pass down argument information in a little struct instead of individually. While we're at it, add per-argument loc info and attribute info. llvm-svn: 68871
2009-04-12 02:57:04 +08:00
ObjCArgInfo *ArgInfo,
Patch to implement gcc's cstyle arguments in objc methods. wip. llvm-svn: 100734
2010-04-08 08:30:06 +08:00
DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, // c-style args
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind,
Place duplicate argument declaration in in method prototypes under the -Wduplicate-method-arg and turn it off by default. llvm-svn: 127552
2011-03-13 02:54:30 +08:00
bool isVariadic, bool MethodDefinition) {
Fix http://llvm.org/bugs/show_bug.cgi?id=2106. llvm-svn: 47768
2008-03-01 05:48:07 +08:00
// Make sure we can establish a context for the method.
if (!ClassDecl) {
Diag(MethodLoc, diag::error_missing_method_context);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return 0;
Fix http://llvm.org/bugs/show_bug.cgi?id=2106. llvm-svn: 47768
2008-03-01 05:48:07 +08:00
}
Introduce ContextDecl, patch by Argiris Kirtzidis! -Added ContextDecl (no TranslationUnitDecl) -ScopedDecl class has a ContextDecl member -FieldDecl class has a ContextDecl member, so that a Field or a ObjCIvar can be traced back to their RecordDecl/ObjCInterfaceDecl easily -FunctionDecl, ObjCMethodDecl, TagDecl, ObjCInterfaceDecl inherit from ContextDecl. With TagDecl as ContextDecl, enum constants have a EnumDecl as their context. -Moved Decl class to a "DeclBase.h" along with ContextDecl class -CurContext is handled by Sema llvm-svn: 49208
2008-04-04 14:12:32 +08:00
QualType resultDeclType;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Keep track of type source information in the return type of an Objective-C method declaration, e.g., for - (Foo *)myMethod; we now have TypeSourceInfo for the Foo*. llvm-svn: 97942
2010-03-08 22:59:44 +08:00
TypeSourceInfo *ResultTInfo = 0;
Fix <rdar://problem/6500554> missing objc error message. llvm-svn: 65198
2009-02-21 06:59:16 +08:00
if (ReturnType) {
Keep track of type source information in the return type of an Objective-C method declaration, e.g., for - (Foo *)myMethod; we now have TypeSourceInfo for the Foo*. llvm-svn: 97942
2010-03-08 22:59:44 +08:00
resultDeclType = GetTypeFromParser(ReturnType, &ResultTInfo);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix <rdar://problem/6500554> missing objc error message. llvm-svn: 65198
2009-02-21 06:59:16 +08:00
// Methods cannot return interface types. All ObjC objects are
// passed by reference.
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 (resultDeclType->isObjCObjectType()) {
Improve the 'cannot pass objc interface by value' diagnostic: 1) improve localizability by not passing english strings in. 2) improve location for arguments. 3) print the objc type being passed. Before: method-bad-param.m:15:1: error: Objective-C type cannot be passed by value -(void) my_method:(foo) my_param ^ after: method-bad-param.m:15:25: error: Objective-C interface type 'foo' cannot be passed by value -(void) my_method:(foo) my_param ^ llvm-svn: 68872
2009-04-12 03:08:56 +08:00
Diag(MethodLoc, diag::err_object_cannot_be_passed_returned_by_value)
<< 0 << resultDeclType;
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return 0;
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
}
objc - Diagnose missing method return type specifier under a warning flag. // rdar://9615045 llvm-svn: 135681
2011-07-22 01:00:47 +08:00
} else { // get the type for "id".
Introduce ContextDecl, patch by Argiris Kirtzidis! -Added ContextDecl (no TranslationUnitDecl) -ScopedDecl class has a ContextDecl member -FieldDecl class has a ContextDecl member, so that a Field or a ObjCIvar can be traced back to their RecordDecl/ObjCInterfaceDecl easily -FunctionDecl, ObjCMethodDecl, TagDecl, ObjCInterfaceDecl inherit from ContextDecl. With TagDecl as ContextDecl, enum constants have a EnumDecl as their context. -Moved Decl class to a "DeclBase.h" along with ContextDecl class -CurContext is handled by Sema llvm-svn: 49208
2008-04-04 14:12:32 +08:00
resultDeclType = Context.getObjCIdType();
objc - Diagnose missing method return type specifier under a warning flag. // rdar://9615045 llvm-svn: 135681
2011-07-22 01:00:47 +08:00
Diag(MethodLoc, diag::warn_missing_method_return_type);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCMethodDecl* ObjCMethod =
Introduce ContextDecl, patch by Argiris Kirtzidis! -Added ContextDecl (no TranslationUnitDecl) -ScopedDecl class has a ContextDecl member -FieldDecl class has a ContextDecl member, so that a Field or a ObjCIvar can be traced back to their RecordDecl/ObjCInterfaceDecl easily -FunctionDecl, ObjCMethodDecl, TagDecl, ObjCInterfaceDecl inherit from ContextDecl. With TagDecl as ContextDecl, enum constants have a EnumDecl as their context. -Moved Decl class to a "DeclBase.h" along with ContextDecl class -CurContext is handled by Sema llvm-svn: 49208
2008-04-04 14:12:32 +08:00
ObjCMethodDecl::Create(Context, MethodLoc, EndLoc, Sel, resultDeclType,
Keep track of type source information in the return type of an Objective-C method declaration, e.g., for - (Foo *)myMethod; we now have TypeSourceInfo for the Foo*. llvm-svn: 97942
2010-03-08 22:59:44 +08:00
ResultTInfo,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
cast<DeclContext>(ClassDecl),
Introduce ContextDecl, patch by Argiris Kirtzidis! -Added ContextDecl (no TranslationUnitDecl) -ScopedDecl class has a ContextDecl member -FieldDecl class has a ContextDecl member, so that a Field or a ObjCIvar can be traced back to their RecordDecl/ObjCInterfaceDecl easily -FunctionDecl, ObjCMethodDecl, TagDecl, ObjCInterfaceDecl inherit from ContextDecl. With TagDecl as ContextDecl, enum constants have a EnumDecl as their context. -Moved Decl class to a "DeclBase.h" along with ContextDecl class -CurContext is handled by Sema llvm-svn: 49208
2008-04-04 14:12:32 +08:00
MethodType == tok::minus, isVariadic,
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
false, false,
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
MethodDeclKind == tok::objc_optional
? ObjCMethodDecl::Optional
: ObjCMethodDecl::Required,
false);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
llvm::SmallVector<ParmVarDecl*, 16> Params;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Set proper location info on objc method arguments. llvm-svn: 68877
2009-04-12 03:42:43 +08:00
for (unsigned i = 0, e = Sel.getNumArgs(); i != e; ++i) {
Remove OriginalTypeParmDecl; the original type is the one specified in the DeclaratorInfo, if one is present. Preserve source information through template instantiation. This is made more complicated by the possibility that ParmVarDecls don't have DIs, which is possibly worth fixing in the future. Also preserve source information for function parameters in ObjC method declarations. llvm-svn: 84971
2009-10-24 05:48:59 +08:00
QualType ArgType;
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
TypeSourceInfo *DI;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
change the interface to ActOnMethodDeclaration to pass down argument information in a little struct instead of individually. While we're at it, add per-argument loc info and attribute info. llvm-svn: 68871
2009-04-12 02:57:04 +08:00
if (ArgInfo[i].Type == 0) {
Remove OriginalTypeParmDecl; the original type is the one specified in the DeclaratorInfo, if one is present. Preserve source information through template instantiation. This is made more complicated by the possibility that ParmVarDecls don't have DIs, which is possibly worth fixing in the future. Also preserve source information for function parameters in ObjC method declarations. llvm-svn: 84971
2009-10-24 05:48:59 +08:00
ArgType = Context.getObjCIdType();
DI = 0;
change the interface to ActOnMethodDeclaration to pass down argument information in a little struct instead of individually. While we're at it, add per-argument loc info and attribute info. llvm-svn: 68871
2009-04-12 02:57:04 +08:00
} else {
Remove OriginalTypeParmDecl; the original type is the one specified in the DeclaratorInfo, if one is present. Preserve source information through template instantiation. This is made more complicated by the possibility that ParmVarDecls don't have DIs, which is possibly worth fixing in the future. Also preserve source information for function parameters in ObjC method declarations. llvm-svn: 84971
2009-10-24 05:48:59 +08:00
ArgType = GetTypeFromParser(ArgInfo[i].Type, &DI);
Sema::ActOnMethodDeclaration(): Make sure we perform the default function/array conversion for parameter types. This fixes <rdar://problem/6424064> checker on xcode: (possible bad AST) can the type of a method parameter really have "isFunctionType() == true"? and http://llvm.org/bugs/show_bug.cgi?id=2997. llvm-svn: 60781
2008-12-10 03:36:17 +08:00
// Perform the default array/function conversions (C99 6.7.5.3p[7,8]).
Centralize the getCanonicalType() calls in the Itanium C++ mangling code so that they only occur in a single place. No functionality change. llvm-svn: 134961
2011-07-12 12:42:08 +08:00
ArgType = Context.getAdjustedParameterType(ArgType);
change the interface to ActOnMethodDeclaration to pass down argument information in a little struct instead of individually. While we're at it, add per-argument loc info and attribute info. llvm-svn: 68871
2009-04-12 02:57:04 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix scoping of method declarations and issue warning when same parameter name used multiple times. // rdar://8877730 llvm-svn: 125229
2011-02-10 06:20:01 +08:00
LookupResult R(*this, ArgInfo[i].Name, ArgInfo[i].NameLoc,
LookupOrdinaryName, ForRedeclaration);
LookupName(R, S);
if (R.isSingleResult()) {
NamedDecl *PrevDecl = R.getFoundDecl();
if (S->isDeclScope(PrevDecl)) {
Place duplicate argument declaration in in method prototypes under the -Wduplicate-method-arg and turn it off by default. llvm-svn: 127552
2011-03-13 02:54:30 +08:00
Diag(ArgInfo[i].NameLoc,
(MethodDefinition ? diag::warn_method_param_redefinition
: diag::warn_method_param_declaration))
Fix scoping of method declarations and issue warning when same parameter name used multiple times. // rdar://8877730 llvm-svn: 125229
2011-02-10 06:20:01 +08:00
<< ArgInfo[i].Name;
Diag(PrevDecl->getLocation(),
diag::note_previous_declaration);
}
}
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
SourceLocation StartLoc = DI
? DI->getTypeLoc().getBeginLoc()
: ArgInfo[i].NameLoc;
Diagnose C++ abstract parameters for Objective-C methods. llvm-svn: 130045
2011-04-23 10:46:06 +08:00
ParmVarDecl* Param = CheckParameter(ObjCMethod, StartLoc,
ArgInfo[i].NameLoc, ArgInfo[i].Name,
ArgType, DI, SC_None, SC_None);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Revise the representation of parameter scope data so that the scope depth overlaps with the ObjCDeclQualifier, dropping memory usage back to previous levels. llvm-svn: 130671
2011-05-02 08:30:12 +08:00
Param->setObjCMethodScopeInfo(i);
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
Param->setObjCDeclQualifier(
change the interface to ActOnMethodDeclaration to pass down argument information in a little struct instead of individually. While we're at it, add per-argument loc info and attribute info. llvm-svn: 68871
2009-04-12 02:57:04 +08:00
CvtQTToAstBitMask(ArgInfo[i].DeclSpec.getObjCDeclQualifier()));
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
simplify code to use adjustParameterType, apply objc arg attributes to their arguments. llvm-svn: 68876
2009-04-12 03:34:56 +08:00
// Apply the attributes to the parameter.
Support dependent extended vector types and template instantiation thereof. Patch by Anders Johnsen! llvm-svn: 73641
2009-06-18 05:51:59 +08:00
ProcessDeclAttributeList(TUScope, Param, ArgInfo[i].ArgAttrs);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix scoping of method declarations and issue warning when same parameter name used multiple times. // rdar://8877730 llvm-svn: 125229
2011-02-10 06:20:01 +08:00
S->AddDecl(Param);
IdResolver.AddDecl(Param);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
Params.push_back(Param);
}
Fix scoping of method declarations and issue warning when same parameter name used multiple times. // rdar://8877730 llvm-svn: 125229
2011-02-10 06:20:01 +08:00
Patch to implement gcc's cstyle arguments in objc methods. wip. llvm-svn: 100734
2010-04-08 08:30:06 +08:00
for (unsigned i = 0, e = CNumArgs; i != e; ++i) {
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
ParmVarDecl *Param = cast<ParmVarDecl>(CParamInfo[i].Param);
Patch to implement gcc's cstyle arguments in objc methods. wip. llvm-svn: 100734
2010-04-08 08:30:06 +08:00
QualType ArgType = Param->getType();
if (ArgType.isNull())
ArgType = Context.getObjCIdType();
else
// Perform the default array/function conversions (C99 6.7.5.3p[7,8]).
Centralize the getCanonicalType() calls in the Itanium C++ mangling code so that they only occur in a single place. No functionality change. llvm-svn: 134961
2011-07-12 12:42:08 +08:00
ArgType = Context.getAdjustedParameterType(ArgType);
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 (ArgType->isObjCObjectType()) {
Patch to implement gcc's cstyle arguments in objc methods. wip. llvm-svn: 100734
2010-04-08 08:30:06 +08:00
Diag(Param->getLocation(),
diag::err_object_cannot_be_passed_returned_by_value)
<< 1 << ArgType;
Param->setInvalidDecl();
}
Param->setDeclContext(ObjCMethod);
Fix scoping of method declarations and issue warning when same parameter name used multiple times. // rdar://8877730 llvm-svn: 125229
2011-02-10 06:20:01 +08:00
Patch to implement gcc's cstyle arguments in objc methods. wip. llvm-svn: 100734
2010-04-08 08:30:06 +08:00
Params.push_back(Param);
}
Fixes a regression caused by implementing cstyle methods for objc. llvm-svn: 100865
2010-04-09 23:40:42 +08:00
ObjCMethod->setMethodParams(Context, Params.data(), Params.size(),
Sel.getNumArgs());
Substituted all instances of the string "Objc" for "ObjC". This fixes some naming inconsistencies in the names of classes pertaining to Objective-C support in clang. llvm-svn: 45715
2008-01-08 03:49:32 +08:00
ObjCMethod->setObjCDeclQualifier(
CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier()));
const ObjCMethodDecl *PrevMethod = 0;
Sema support for format and noreturn attributes on Objective-C methods. llvm-svn: 56640
2008-09-26 12:12:28 +08:00
if (AttrList)
Support dependent extended vector types and template instantiation thereof. Patch by Anders Johnsen! llvm-svn: 73641
2009-06-18 05:51:59 +08:00
ProcessDeclAttributeList(TUScope, ObjCMethod, AttrList);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Change our basic strategy for avoiding deprecation warnings when the decl use appears in a deprecated context. In the new strategy, we emit the warnings as usual unless we're currently parsing a declaration, where "declaration" is restricted to mean a decl group or a few special cases in Objective C. If we *are* parsing a declaration, we queue up the deprecation warnings until the declaration has been completely parsed, and then emit them only if the decl is not deprecated. We also standardize the bookkeeping for deprecation so as to avoid special cases. llvm-svn: 85998
2009-11-04 10:18:39 +08:00
const ObjCMethodDecl *InterfaceMD = 0;
Fix a major inconsistency in the representation of Objective-C classes, categories, protocols, and class extensions, where the methods and properties of these entities would be inserted into the DeclContext in an ordering that doesn't necessarily reflect source order. The culprits were Sema::ActOnMethodDeclaration(), which did not perform the insertion of the just-created method declaration into the DeclContext for these Objective-C entities, and Sema::ActOnAtEnd(), which inserted all method declarations at the *end* of the DeclContext. With this fix in hand, clean up the code-completion actions for property setters/getters that worked around this brokenness in the AST. Fixes <rdar://problem/8062781>, where this problem manifested as poor token-annotation information, but this would have struck again in many other places. llvm-svn: 122347
2010-12-22 01:34:17 +08:00
// Add the method now.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (ObjCImplementationDecl *ImpDecl =
Give ObjCMethodDecl a Create method. llvm-svn: 48405
2008-03-16 08:49:28 +08:00
dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (MethodType == tok::minus) {
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
PrevMethod = ImpDecl->getInstanceMethod(Sel);
ImpDecl->addInstanceMethod(ObjCMethod);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
} else {
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
PrevMethod = ImpDecl->getClassMethod(Sel);
ImpDecl->addClassMethod(ObjCMethod);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Change our basic strategy for avoiding deprecation warnings when the decl use appears in a deprecated context. In the new strategy, we emit the warnings as usual unless we're currently parsing a declaration, where "declaration" is restricted to mean a decl group or a few special cases in Objective C. If we *are* parsing a declaration, we queue up the deprecation warnings until the declaration has been completely parsed, and then emit them only if the decl is not deprecated. We also standardize the bookkeeping for deprecation so as to avoid special cases. llvm-svn: 85998
2009-11-04 10:18:39 +08:00
InterfaceMD = ImpDecl->getClassInterface()->getMethod(Sel,
MethodType == tok::minus);
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
if (ObjCMethod->hasAttrs() &&
containsInvalidMethodImplAttribute(ObjCMethod->getAttrs()))
Method attributes may only be specified on method declarations. llvm-svn: 71597
2009-05-13 05:36:23 +08:00
Diag(EndLoc, diag::warn_attribute_method_def);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
} else if (ObjCCategoryImplDecl *CatImpDecl =
Canonicalize else. llvm-svn: 78102
2009-08-05 05:02:39 +08:00
dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
if (MethodType == tok::minus) {
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
PrevMethod = CatImpDecl->getInstanceMethod(Sel);
CatImpDecl->addInstanceMethod(ObjCMethod);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
} else {
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
PrevMethod = CatImpDecl->getClassMethod(Sel);
CatImpDecl->addClassMethod(ObjCMethod);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
if (ObjCCategoryDecl *Cat = CatImpDecl->getCategoryDecl())
InterfaceMD = Cat->getMethod(Sel, MethodType == tok::minus);
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
if (ObjCMethod->hasAttrs() &&
containsInvalidMethodImplAttribute(ObjCMethod->getAttrs()))
Method attributes may only be specified on method declarations. llvm-svn: 71597
2009-05-13 05:36:23 +08:00
Diag(EndLoc, diag::warn_attribute_method_def);
Fix a major inconsistency in the representation of Objective-C classes, categories, protocols, and class extensions, where the methods and properties of these entities would be inserted into the DeclContext in an ordering that doesn't necessarily reflect source order. The culprits were Sema::ActOnMethodDeclaration(), which did not perform the insertion of the just-created method declaration into the DeclContext for these Objective-C entities, and Sema::ActOnAtEnd(), which inserted all method declarations at the *end* of the DeclContext. With this fix in hand, clean up the code-completion actions for property setters/getters that worked around this brokenness in the AST. Fixes <rdar://problem/8062781>, where this problem manifested as poor token-annotation information, but this would have struck again in many other places. llvm-svn: 122347
2010-12-22 01:34:17 +08:00
} else {
cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod);
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
if (PrevMethod) {
// You can never have two method definitions with the same name.
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(ObjCMethod->getLocation(), diag::err_duplicate_method_decl)
Rename Selector::getName() to Selector::getAsString(), and add a new NamedDecl::getAsString() method. Change uses of Selector::getName() to just pass in a Selector where possible (e.g. to diagnostics) instead of going through an std::string. This also adds new formatters for objcinstance and objcclass as described in the dox. llvm-svn: 59933
2008-11-24 11:33:13 +08:00
<< ObjCMethod->getDeclName();
Make all the 'redefinition' diagnostics more consistent, and make the "previously defined here" diagnostics all notes. llvm-svn: 59920
2008-11-24 07:12:31 +08:00
Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
}
Change our basic strategy for avoiding deprecation warnings when the decl use appears in a deprecated context. In the new strategy, we emit the warnings as usual unless we're currently parsing a declaration, where "declaration" is restricted to mean a decl group or a few special cases in Objective C. If we *are* parsing a declaration, we queue up the deprecation warnings until the declaration has been completely parsed, and then emit them only if the decl is not deprecated. We also standardize the bookkeeping for deprecation so as to avoid special cases. llvm-svn: 85998
2009-11-04 10:18:39 +08:00
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
// If this Objective-C method does not have a related result type, but we
// are allowed to infer related result types, try to do so based on the
// method family.
ObjCInterfaceDecl *CurrentClass = dyn_cast<ObjCInterfaceDecl>(ClassDecl);
if (!CurrentClass) {
if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl))
CurrentClass = Cat->getClassInterface();
else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(ClassDecl))
CurrentClass = Impl->getClassInterface();
else if (ObjCCategoryImplDecl *CatImpl
= dyn_cast<ObjCCategoryImplDecl>(ClassDecl))
CurrentClass = CatImpl->getClassInterface();
}
Support a new InheritableAttr subclass, InheritableParamAttr, which is used for attributes that are okay to inherit when written on a parameter. Dependent on LLVM r126827. llvm-svn: 126828
2011-03-02 12:00:57 +08:00
// Merge information down from the interface declaration if we have one.
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
if (InterfaceMD) {
// Inherit the related result type, if we can.
if (InterfaceMD->hasRelatedResultType() &&
!CheckRelatedResultTypeCompatibility(*this, ObjCMethod, CurrentClass))
ObjCMethod->SetRelatedResultType();
Support a new InheritableAttr subclass, InheritableParamAttr, which is used for attributes that are okay to inherit when written on a parameter. Dependent on LLVM r126827. llvm-svn: 126828
2011-03-02 12:00:57 +08:00
mergeObjCMethodDecls(ObjCMethod, InterfaceMD);
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +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
bool ARCError = false;
if (getLangOptions().ObjCAutoRefCount)
ARCError = CheckARCMethodDecl(*this, ObjCMethod);
if (!ObjCMethod->hasRelatedResultType() && !ARCError &&
Introduce a -cc1-level option to turn off related result type inference, to be used (only) by the Objective-C rewriter. llvm-svn: 133025
2011-06-15 07:20:43 +08:00
getLangOptions().ObjCInferRelatedResultType) {
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
bool InferRelatedResultType = false;
switch (ObjCMethod->getMethodFamily()) {
case OMF_None:
case OMF_copy:
case OMF_dealloc:
case OMF_mutableCopy:
case OMF_release:
case OMF_retainCount:
objc-arc: enforce performSelector rules in rejecting retaining selectors passed to it, and unknown selectors causing potential leak. // rdar://9659270 llvm-svn: 134449
2011-07-06 06:38:59 +08:00
case OMF_performSelector:
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
break;
case OMF_alloc:
case OMF_new:
InferRelatedResultType = ObjCMethod->isClassMethod();
break;
case OMF_init:
case OMF_autorelease:
case OMF_retain:
case OMF_self:
InferRelatedResultType = ObjCMethod->isInstanceMethod();
break;
}
if (InferRelatedResultType &&
!CheckRelatedResultTypeCompatibility(*this, ObjCMethod, CurrentClass))
ObjCMethod->SetRelatedResultType();
if (!InterfaceMD &&
anyMethodInfersRelatedResultType(*this, ObjCMethod->getSelector(),
ObjCMethod->isInstanceMethod()))
CheckObjCMethodOverrides(ObjCMethod, cast<DeclContext>(ClassDecl));
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return ObjCMethod;
split objc pieces of SemaDecl.cpp out into SemaDeclObjC.cpp llvm-svn: 44925
2007-12-12 15:09:47 +08:00
}
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
bool Sema::CheckObjCDeclScope(Decl *D) {
Rename DeclContext::getLookupContext to getRedeclContext and change its semantics slightly. No functionality change in the absence of inline namespaces. Also, change a few places where inline namespaces actually make a difference to be prepared for them. llvm-svn: 112563
2010-08-31 08:36:30 +08:00
if (isa<TranslationUnitDecl>(CurContext->getRedeclContext()))
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
return false;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
Diag(D->getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope);
D->setInvalidDecl();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make it an error if an Objective-C declaration is not in the global scope. llvm-svn: 58705
2008-11-05 00:57:32 +08:00
return true;
}
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
/// Called whenever @defs(ClassName) is encountered in the source. Inserts the
/// instance variables of ClassName into Decls.
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
void Sema::ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
IdentifierInfo *ClassName,
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
llvm::SmallVectorImpl<Decl*> &Decls) {
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
// Check that ClassName is a valid class
Feed proper source-location information into Sema::LookupSingleResult, in case it ends up doing something that might trigger diagnostics (template instantiation, ambiguity reporting, access reporting). Noticed while working on PR6831. llvm-svn: 101412
2010-04-16 06:33:43 +08:00
ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName, DeclStart);
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
if (!Class) {
Diag(DeclStart, diag::err_undef_interface) << ClassName;
return;
}
Patch to diagnose use of objc's @defs in nonfragile abi. llvm-svn: 69710
2009-04-22 04:28:41 +08:00
if (LangOpts.ObjCNonFragileABI) {
Diag(DeclStart, diag::err_atdef_nonfragile_interface);
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
// Collect the instance variables
objective-c ivar refactoring patch. Iterations over ivars for a varienty of puposes is now consolidated into two small routines; DeepCollectObjCIvars and ShallowCollectObjCIvars. llvm-svn: 111679
2010-08-21 05:21:08 +08:00
llvm::SmallVector<ObjCIvarDecl*, 32> Ivars;
Context.DeepCollectObjCIvars(Class, true, Ivars);
More refactoring/cleanup of objc ivars. llvm-svn: 72871
2009-06-05 01:08:55 +08:00
// For each ivar, create a fresh ObjCAtDefsFieldDecl.
objective-c ivar refactoring patch. Iterations over ivars for a varienty of puposes is now consolidated into two small routines; DeepCollectObjCIvars and ShallowCollectObjCIvars. llvm-svn: 111679
2010-08-21 05:21:08 +08:00
for (unsigned i = 0; i < Ivars.size(); i++) {
FieldDecl* ID = cast<FieldDecl>(Ivars[i]);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
RecordDecl *Record = dyn_cast<RecordDecl>(TagD);
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
Decl *FD = ObjCAtDefsFieldDecl::Create(Context, Record,
/*FIXME: StartL=*/ID->getLocation(),
ID->getLocation(),
More refactoring/cleanup of objc ivars. llvm-svn: 72871
2009-06-05 01:08:55 +08:00
ID->getIdentifier(), ID->getType(),
ID->getBitWidth());
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decls.push_back(FD);
More refactoring/cleanup of objc ivars. llvm-svn: 72871
2009-06-05 01:08:55 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
// Introduce all of these fields into the appropriate scope.
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
for (llvm::SmallVectorImpl<Decl*>::iterator D = Decls.begin();
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
D != Decls.end(); ++D) {
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
FieldDecl *FD = cast<FieldDecl>(*D);
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
if (getLangOptions().CPlusPlus)
PushOnScopeChains(cast<FieldDecl>(FD), S);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
else if (RecordDecl *Record = dyn_cast<RecordDecl>(TagD))
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
Record->addDecl(FD);
Move the other Sema::ActOnLinkageSpec to SemaDeclCXX. Move Sema::ActOnDefs to SemaDeclObjC llvm-svn: 61126
2008-12-17 15:13:27 +08:00
}
}
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
/// \brief Build a type-check a new Objective-C exception variable declaration.
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
VarDecl *Sema::BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType T,
SourceLocation StartLoc,
SourceLocation IdLoc,
IdentifierInfo *Id,
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
bool Invalid) {
// ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
// duration shall not be qualified by an address-space qualifier."
// Since all parameters have automatic store duration, they can not have
// an address space.
if (T.getAddressSpace() != 0) {
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
Diag(IdLoc, diag::err_arg_with_address_space);
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
Invalid = true;
}
// An @catch parameter must be an unqualified object pointer type;
// FIXME: Recover from "NSObject foo" by inserting the * in "NSObject *foo"?
if (Invalid) {
// Don't do any further checking.
Implement template instantiation for Objective-C @catch statements. This is the last of the Objective-C statements. llvm-svn: 102356
2010-04-27 01:57:08 +08:00
} else if (T->isDependentType()) {
// Okay: we don't know what this type will instantiate to.
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
} else if (!T->isObjCObjectPointerType()) {
Invalid = true;
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
Diag(IdLoc ,diag::err_catch_param_not_objc_type);
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
} else if (T->isObjCQualifiedIdType()) {
Invalid = true;
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
Diag(IdLoc, diag::err_illegal_qualifiers_on_catch_parm);
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
}
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
VarDecl *New = VarDecl::Create(Context, CurContext, StartLoc, IdLoc, Id,
T, TInfo, SC_None, SC_None);
Diagnose unused exception parameters under a different warning group (-Wunused-exception-parameter) than normal variables, since it's more common to name and then ignore an exception parameter. This warning is neither enabled by default nor by -Wall. Fixes <rdar://problem/7931045>. llvm-svn: 102931
2010-05-04 02:51:14 +08:00
New->setExceptionVariable(true);
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
if (Invalid)
New->setInvalidDecl();
return New;
}
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
Decl *Sema::ActOnObjCExceptionDecl(Scope *S, Declarator &D) {
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
const DeclSpec &DS = D.getDeclSpec();
// We allow the "register" storage class on exception variables because
// GCC did, but we drop it completely. Any other storage class is an error.
if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
Diag(DS.getStorageClassSpecLoc(), diag::warn_register_objc_catch_parm)
<< FixItHint::CreateRemoval(SourceRange(DS.getStorageClassSpecLoc()));
} else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
Diag(DS.getStorageClassSpecLoc(), diag::err_storage_spec_on_catch_parm)
<< DS.getStorageClassSpec();
}
if (D.getDeclSpec().isThreadSpecified())
Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
D.getMutableDeclSpec().ClearStorageClassSpecs();
DiagnoseFunctionSpecifiers(D);
// Check that there are no default arguments inside the type of this
// exception object (C++ only).
if (getLangOptions().CPlusPlus)
CheckExtraCXXDefaultArguments(D);
Centralize the check for a tag definition in a Declarator::PrototypeContext inside GetTypeForDeclarator. No functionality change. llvm-svn: 133985
2011-06-28 11:01:15 +08:00
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
Alter the interface of GetTypeForDeclarator to return a TypeSourceInfo*. This is never null, but the associated type might be. llvm-svn: 105503
2010-06-05 07:28:52 +08:00
QualType ExceptionType = TInfo->getType();
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
VarDecl *New = BuildObjCExceptionDecl(TInfo, ExceptionType,
D.getSourceRange().getBegin(),
D.getIdentifierLoc(),
D.getIdentifier(),
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
D.isInvalidType());
// Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
if (D.getCXXScopeSpec().isSet()) {
Diag(D.getIdentifierLoc(), diag::err_qualified_objc_catch_parm)
<< D.getCXXScopeSpec().getRange();
New->setInvalidDecl();
}
// Add the parameter declaration into this scope.
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
S->AddDecl(New);
Refactor Objective-C @catch parameter checking by detangling it from function-parameter checking and splitting it into the normal ActOn*/Build* pair in Sema. We now use VarDecl to represent the @catch parameter rather than the ill-fitting ParmVarDecl. llvm-svn: 102347
2010-04-27 01:32:49 +08:00
if (D.getIdentifier())
IdResolver.AddDecl(New);
ProcessDeclAttributes(S, New, D);
if (New->hasAttr<BlocksAttr>())
Diag(New->getLocation(), diag::err_block_on_nonlocal);
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
return New;
Rework Parser-Sema interface for Objective-C @catch exception object arguments. Rather than having the parser call ActOnParamDeclarator (which is a bit of a hack), call a new ActOnObjCExceptionDecl action. We'll be moving more functionality into this handler to perform earlier checking of @catch. llvm-svn: 102222
2010-04-24 07:01:43 +08:00
}
Move CollectIvarsToConstructOrDestruct to Sema from AST, consider ivar array of objects (per Doug's comment). llvm-svn: 102446
2010-04-28 01:18:58 +08:00
/// CollectIvarsToConstructOrDestruct - Collect those ivars which require
More of Sema to implement initialization of ivar of c++ object types. llvm-svn: 102500
2010-04-29 00:11:27 +08:00
/// initialization.
objective-c ivar refactoring patch. Iterations over ivars for a varienty of puposes is now consolidated into two small routines; DeepCollectObjCIvars and ShallowCollectObjCIvars. llvm-svn: 111679
2010-08-21 05:21:08 +08:00
void Sema::CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
More of Sema to implement initialization of ivar of c++ object types. llvm-svn: 102500
2010-04-29 00:11:27 +08:00
llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
objective-c ivar refactoring patch. Iterations over ivars for a varienty of puposes is now consolidated into two small routines; DeepCollectObjCIvars and ShallowCollectObjCIvars. llvm-svn: 111679
2010-08-21 05:21:08 +08:00
for (ObjCIvarDecl *Iv = OI->all_declared_ivar_begin(); Iv;
Iv= Iv->getNextIvar()) {
Move CollectIvarsToConstructOrDestruct to Sema from AST, consider ivar array of objects (per Doug's comment). llvm-svn: 102446
2010-04-28 01:18:58 +08:00
QualType QT = Context.getBaseElementType(Iv->getType());
Various small fixes for construction/destruction of Objective-C++ instance variables: - Use isRecordType() rather than isa<RecordType>(), so that we see through typedefs in ivar types. - Mark the destructor as referenced - Perform C++ access control on the destructor llvm-svn: 104206
2010-05-20 10:24:22 +08:00
if (QT->isRecordType())
objective-c ivar refactoring patch. Iterations over ivars for a varienty of puposes is now consolidated into two small routines; DeepCollectObjCIvars and ShallowCollectObjCIvars. llvm-svn: 111679
2010-08-21 05:21:08 +08:00
Ivars.push_back(Iv);
Move CollectIvarsToConstructOrDestruct to Sema from AST, consider ivar array of objects (per Doug's comment). llvm-svn: 102446
2010-04-28 01:18:58 +08:00
}
}
More of Sema to implement initialization of ivar of c++ object types. llvm-svn: 102500
2010-04-29 00:11:27 +08:00
void ObjCImplementationDecl::setIvarInitializers(ASTContext &C,
Renamed CXXBaseOrMemberInitializer to CXXCtorInitializer. This is both shorter, more accurate, and makes it make sense for it to hold a delegating constructor call. llvm-svn: 123084
2011-01-09 04:30:50 +08:00
CXXCtorInitializer ** initializers,
More of Sema to implement initialization of ivar of c++ object types. llvm-svn: 102500
2010-04-29 00:11:27 +08:00
unsigned numInitializers) {
if (numInitializers > 0) {
NumIvarInitializers = numInitializers;
Renamed CXXBaseOrMemberInitializer to CXXCtorInitializer. This is both shorter, more accurate, and makes it make sense for it to hold a delegating constructor call. llvm-svn: 123084
2011-01-09 04:30:50 +08:00
CXXCtorInitializer **ivarInitializers =
new (C) CXXCtorInitializer*[NumIvarInitializers];
More of Sema to implement initialization of ivar of c++ object types. llvm-svn: 102500
2010-04-29 00:11:27 +08:00
memcpy(ivarInitializers, initializers,
Renamed CXXBaseOrMemberInitializer to CXXCtorInitializer. This is both shorter, more accurate, and makes it make sense for it to hold a delegating constructor call. llvm-svn: 123084
2011-01-09 04:30:50 +08:00
numInitializers * sizeof(CXXCtorInitializer*));
More of Sema to implement initialization of ivar of c++ object types. llvm-svn: 102500
2010-04-29 00:11:27 +08:00
IvarInitializers = ivarInitializers;
}
}
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
void Sema::DiagnoseUseOfUnimplementedSelectors() {
-Wselector should warn on implemented selectors only when selector metadata is generated, which is triggered by at least on class implementation. This is to match gcc's behavior. // rdar://8851684. llvm-svn: 124909
2011-02-05 07:19:27 +08:00
// Warning will be issued only when selector table is
// generated (which means there is at lease one implementation
// in the TU). This is to match gcc's behavior.
if (ReferencedSelectors.empty() ||
!Context.AnyObjCImplementation())
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
return;
for (llvm::DenseMap<Selector, SourceLocation>::iterator S =
ReferencedSelectors.begin(),
E = ReferencedSelectors.end(); S != E; ++S) {
Selector Sel = (*S).first;
if (!LookupImplementedMethodInGlobalPool(Sel))
Diag((*S).second, diag::warn_unimplemented_selector) << Sel;
}
return;
}