blob: 59f93af465a7bff0e957359548edc5bf2d97daa9 [file] [log] [blame]
Chris Lattner4d391482007-12-12 07:09:47 +00001//===--- SemaDeclObjC.cpp - Semantic Analysis for ObjC Declarations -------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner4d391482007-12-12 07:09:47 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for Objective C declarations.
11//
12//===----------------------------------------------------------------------===//
13
John McCall2d887082010-08-25 22:03:47 +000014#include "clang/Sema/SemaInternal.h"
Douglas Gregore737f502010-08-12 20:07:10 +000015#include "clang/Sema/Lookup.h"
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000016#include "clang/Sema/ExternalSemaSource.h"
John McCall5f1e0942010-08-24 08:50:51 +000017#include "clang/Sema/Scope.h"
John McCall781472f2010-08-25 08:40:02 +000018#include "clang/Sema/ScopeInfo.h"
John McCallf85e1932011-06-15 23:02:42 +000019#include "clang/AST/ASTConsumer.h"
Steve Naroffca331292009-03-03 14:49:36 +000020#include "clang/AST/Expr.h"
John McCallf85e1932011-06-15 23:02:42 +000021#include "clang/AST/ExprObjC.h"
Chris Lattner4d391482007-12-12 07:09:47 +000022#include "clang/AST/ASTContext.h"
23#include "clang/AST/DeclObjC.h"
Argyrios Kyrtzidis1a434152011-11-12 21:07:52 +000024#include "clang/AST/ASTMutationListener.h"
John McCallf85e1932011-06-15 23:02:42 +000025#include "clang/Basic/SourceManager.h"
John McCall19510852010-08-20 18:27:03 +000026#include "clang/Sema/DeclSpec.h"
Patrick Beardb2f68202012-04-06 18:12:22 +000027#include "clang/Lex/Preprocessor.h"
John McCall50df6ae2010-08-25 07:03:20 +000028#include "llvm/ADT/DenseSet.h"
29
Chris Lattner4d391482007-12-12 07:09:47 +000030using namespace clang;
31
John McCallf85e1932011-06-15 23:02:42 +000032/// Check whether the given method, which must be in the 'init'
33/// family, is a valid member of that family.
34///
35/// \param receiverTypeIfCall - if null, check this as if declaring it;
36/// if non-null, check this as if making a call to it with the given
37/// receiver type
38///
39/// \return true to indicate that there was an error and appropriate
40/// actions were taken
41bool Sema::checkInitMethod(ObjCMethodDecl *method,
42 QualType receiverTypeIfCall) {
43 if (method->isInvalidDecl()) return true;
44
45 // This castAs is safe: methods that don't return an object
46 // pointer won't be inferred as inits and will reject an explicit
47 // objc_method_family(init).
48
49 // We ignore protocols here. Should we? What about Class?
50
51 const ObjCObjectType *result = method->getResultType()
52 ->castAs<ObjCObjectPointerType>()->getObjectType();
53
54 if (result->isObjCId()) {
55 return false;
56 } else if (result->isObjCClass()) {
57 // fall through: always an error
58 } else {
59 ObjCInterfaceDecl *resultClass = result->getInterface();
60 assert(resultClass && "unexpected object type!");
61
62 // It's okay for the result type to still be a forward declaration
63 // if we're checking an interface declaration.
Douglas Gregor7723fec2011-12-15 20:29:51 +000064 if (!resultClass->hasDefinition()) {
John McCallf85e1932011-06-15 23:02:42 +000065 if (receiverTypeIfCall.isNull() &&
66 !isa<ObjCImplementationDecl>(method->getDeclContext()))
67 return false;
68
69 // Otherwise, we try to compare class types.
70 } else {
71 // If this method was declared in a protocol, we can't check
72 // anything unless we have a receiver type that's an interface.
73 const ObjCInterfaceDecl *receiverClass = 0;
74 if (isa<ObjCProtocolDecl>(method->getDeclContext())) {
75 if (receiverTypeIfCall.isNull())
76 return false;
77
78 receiverClass = receiverTypeIfCall->castAs<ObjCObjectPointerType>()
79 ->getInterfaceDecl();
80
81 // This can be null for calls to e.g. id<Foo>.
82 if (!receiverClass) return false;
83 } else {
84 receiverClass = method->getClassInterface();
85 assert(receiverClass && "method not associated with a class!");
86 }
87
88 // If either class is a subclass of the other, it's fine.
89 if (receiverClass->isSuperClassOf(resultClass) ||
90 resultClass->isSuperClassOf(receiverClass))
91 return false;
92 }
93 }
94
95 SourceLocation loc = method->getLocation();
96
97 // If we're in a system header, and this is not a call, just make
98 // the method unusable.
99 if (receiverTypeIfCall.isNull() && getSourceManager().isInSystemHeader(loc)) {
100 method->addAttr(new (Context) UnavailableAttr(loc, Context,
101 "init method returns a type unrelated to its receiver type"));
102 return true;
103 }
104
105 // Otherwise, it's an error.
106 Diag(loc, diag::err_arc_init_method_unrelated_result_type);
107 method->setInvalidDecl();
108 return true;
109}
110
Fariborz Jahanian3240fe32011-09-27 22:35:36 +0000111void Sema::CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
Douglas Gregor926df6c2011-06-11 01:09:30 +0000112 const ObjCMethodDecl *Overridden,
113 bool IsImplementation) {
114 if (Overridden->hasRelatedResultType() &&
115 !NewMethod->hasRelatedResultType()) {
116 // This can only happen when the method follows a naming convention that
117 // implies a related result type, and the original (overridden) method has
118 // a suitable return type, but the new (overriding) method does not have
119 // a suitable return type.
120 QualType ResultType = NewMethod->getResultType();
121 SourceRange ResultTypeRange;
122 if (const TypeSourceInfo *ResultTypeInfo
John McCallf85e1932011-06-15 23:02:42 +0000123 = NewMethod->getResultTypeSourceInfo())
Douglas Gregor926df6c2011-06-11 01:09:30 +0000124 ResultTypeRange = ResultTypeInfo->getTypeLoc().getSourceRange();
125
126 // Figure out which class this method is part of, if any.
127 ObjCInterfaceDecl *CurrentClass
128 = dyn_cast<ObjCInterfaceDecl>(NewMethod->getDeclContext());
129 if (!CurrentClass) {
130 DeclContext *DC = NewMethod->getDeclContext();
131 if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(DC))
132 CurrentClass = Cat->getClassInterface();
133 else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(DC))
134 CurrentClass = Impl->getClassInterface();
135 else if (ObjCCategoryImplDecl *CatImpl
136 = dyn_cast<ObjCCategoryImplDecl>(DC))
137 CurrentClass = CatImpl->getClassInterface();
138 }
139
140 if (CurrentClass) {
141 Diag(NewMethod->getLocation(),
142 diag::warn_related_result_type_compatibility_class)
143 << Context.getObjCInterfaceType(CurrentClass)
144 << ResultType
145 << ResultTypeRange;
146 } else {
147 Diag(NewMethod->getLocation(),
148 diag::warn_related_result_type_compatibility_protocol)
149 << ResultType
150 << ResultTypeRange;
151 }
152
Douglas Gregore97179c2011-09-08 01:46:34 +0000153 if (ObjCMethodFamily Family = Overridden->getMethodFamily())
154 Diag(Overridden->getLocation(),
155 diag::note_related_result_type_overridden_family)
156 << Family;
157 else
158 Diag(Overridden->getLocation(),
159 diag::note_related_result_type_overridden);
Douglas Gregor926df6c2011-06-11 01:09:30 +0000160 }
David Blaikie4e4d0842012-03-11 07:00:24 +0000161 if (getLangOpts().ObjCAutoRefCount) {
Fariborz Jahanian3240fe32011-09-27 22:35:36 +0000162 if ((NewMethod->hasAttr<NSReturnsRetainedAttr>() !=
163 Overridden->hasAttr<NSReturnsRetainedAttr>())) {
164 Diag(NewMethod->getLocation(),
165 diag::err_nsreturns_retained_attribute_mismatch) << 1;
166 Diag(Overridden->getLocation(), diag::note_previous_decl)
167 << "method";
168 }
169 if ((NewMethod->hasAttr<NSReturnsNotRetainedAttr>() !=
170 Overridden->hasAttr<NSReturnsNotRetainedAttr>())) {
171 Diag(NewMethod->getLocation(),
172 diag::err_nsreturns_retained_attribute_mismatch) << 0;
173 Diag(Overridden->getLocation(), diag::note_previous_decl)
174 << "method";
175 }
Douglas Gregor0a4a23a2012-05-17 23:13:29 +0000176 ObjCMethodDecl::param_const_iterator oi = Overridden->param_begin(),
177 oe = Overridden->param_end();
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +0000178 for (ObjCMethodDecl::param_iterator
179 ni = NewMethod->param_begin(), ne = NewMethod->param_end();
Douglas Gregor0a4a23a2012-05-17 23:13:29 +0000180 ni != ne && oi != oe; ++ni, ++oi) {
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +0000181 const ParmVarDecl *oldDecl = (*oi);
Fariborz Jahanian3240fe32011-09-27 22:35:36 +0000182 ParmVarDecl *newDecl = (*ni);
183 if (newDecl->hasAttr<NSConsumedAttr>() !=
184 oldDecl->hasAttr<NSConsumedAttr>()) {
185 Diag(newDecl->getLocation(),
186 diag::err_nsconsumed_attribute_mismatch);
187 Diag(oldDecl->getLocation(), diag::note_previous_decl)
188 << "parameter";
189 }
190 }
191 }
Douglas Gregor926df6c2011-06-11 01:09:30 +0000192}
193
John McCallf85e1932011-06-15 23:02:42 +0000194/// \brief Check a method declaration for compatibility with the Objective-C
195/// ARC conventions.
196static bool CheckARCMethodDecl(Sema &S, ObjCMethodDecl *method) {
197 ObjCMethodFamily family = method->getMethodFamily();
198 switch (family) {
199 case OMF_None:
Nico Weber80cb6e62011-08-28 22:35:17 +0000200 case OMF_finalize:
John McCallf85e1932011-06-15 23:02:42 +0000201 case OMF_retain:
202 case OMF_release:
203 case OMF_autorelease:
204 case OMF_retainCount:
205 case OMF_self:
John McCall6c2c2502011-07-22 02:45:48 +0000206 case OMF_performSelector:
John McCallf85e1932011-06-15 23:02:42 +0000207 return false;
208
Fariborz Jahanian1b0a13e2012-07-30 20:52:48 +0000209 case OMF_dealloc:
210 if (!S.Context.hasSameType(method->getResultType(), S.Context.VoidTy)) {
211 SourceRange ResultTypeRange;
212 if (const TypeSourceInfo *ResultTypeInfo
213 = method->getResultTypeSourceInfo())
214 ResultTypeRange = ResultTypeInfo->getTypeLoc().getSourceRange();
215 if (ResultTypeRange.isInvalid())
216 S.Diag(method->getLocation(), diag::error_dealloc_bad_result_type)
217 << method->getResultType()
218 << FixItHint::CreateInsertion(method->getSelectorLoc(0), "(void)");
219 else
220 S.Diag(method->getLocation(), diag::error_dealloc_bad_result_type)
221 << method->getResultType()
222 << FixItHint::CreateReplacement(ResultTypeRange, "void");
223 return true;
224 }
225 return false;
226
John McCallf85e1932011-06-15 23:02:42 +0000227 case OMF_init:
228 // If the method doesn't obey the init rules, don't bother annotating it.
229 if (S.checkInitMethod(method, QualType()))
230 return true;
231
232 method->addAttr(new (S.Context) NSConsumesSelfAttr(SourceLocation(),
233 S.Context));
234
235 // Don't add a second copy of this attribute, but otherwise don't
236 // let it be suppressed.
237 if (method->hasAttr<NSReturnsRetainedAttr>())
238 return false;
239 break;
240
241 case OMF_alloc:
242 case OMF_copy:
243 case OMF_mutableCopy:
244 case OMF_new:
245 if (method->hasAttr<NSReturnsRetainedAttr>() ||
246 method->hasAttr<NSReturnsNotRetainedAttr>() ||
247 method->hasAttr<NSReturnsAutoreleasedAttr>())
248 return false;
249 break;
250 }
251
252 method->addAttr(new (S.Context) NSReturnsRetainedAttr(SourceLocation(),
253 S.Context));
254 return false;
255}
256
Fariborz Jahanian5ac96d52011-02-15 17:49:58 +0000257static void DiagnoseObjCImplementedDeprecations(Sema &S,
258 NamedDecl *ND,
259 SourceLocation ImplLoc,
260 int select) {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000261 if (ND && ND->isDeprecated()) {
Fariborz Jahanian98d810e2011-02-16 00:30:31 +0000262 S.Diag(ImplLoc, diag::warn_deprecated_def) << select;
Fariborz Jahanian5ac96d52011-02-15 17:49:58 +0000263 if (select == 0)
Ted Kremenek3306ec12012-02-27 22:55:11 +0000264 S.Diag(ND->getLocation(), diag::note_method_declared_at)
265 << ND->getDeclName();
Fariborz Jahanian5ac96d52011-02-15 17:49:58 +0000266 else
267 S.Diag(ND->getLocation(), diag::note_previous_decl) << "class";
268 }
269}
270
Fariborz Jahanian140ab232011-08-31 17:37:55 +0000271/// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
272/// pool.
273void Sema::AddAnyMethodToGlobalPool(Decl *D) {
274 ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D);
275
276 // If we don't have a valid method decl, simply return.
277 if (!MDecl)
278 return;
279 if (MDecl->isInstanceMethod())
280 AddInstanceMethodToGlobalPool(MDecl, true);
281 else
282 AddFactoryMethodToGlobalPool(MDecl, true);
283}
284
Fariborz Jahaniana1a32f72012-09-13 18:53:14 +0000285/// HasExplicitOwnershipAttr - returns true when pointer to ObjC pointer
286/// has explicit ownership attribute; false otherwise.
287static bool
288HasExplicitOwnershipAttr(Sema &S, ParmVarDecl *Param) {
289 QualType T = Param->getType();
290
Fariborz Jahaniana1a32f72012-09-13 18:53:14 +0000291 if (const PointerType *PT = T->getAs<PointerType>()) {
292 T = PT->getPointeeType();
293 } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
294 T = RT->getPointeeType();
295 } else {
296 return true;
297 }
298
299 // If we have a lifetime qualifier, but it's local, we must have
300 // inferred it. So, it is implicit.
301 return !T.getLocalQualifiers().hasObjCLifetime();
302}
303
Fariborz Jahanian8c6cb462012-08-08 23:41:08 +0000304/// ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible
305/// and user declared, in the method definition's AST.
306void Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, Decl *D) {
307 assert((getCurMethodDecl() == 0) && "Methodparsing confused");
John McCalld226f652010-08-21 09:40:31 +0000308 ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D);
Fariborz Jahanian6c89eaf2012-07-02 23:37:09 +0000309
Steve Naroff394f3f42008-07-25 17:57:26 +0000310 // If we don't have a valid method decl, simply return.
311 if (!MDecl)
312 return;
Steve Naroffa56f6162007-12-18 01:30:32 +0000313
Chris Lattner4d391482007-12-12 07:09:47 +0000314 // Allow all of Sema to see that we are entering a method definition.
Douglas Gregor44b43212008-12-11 16:49:14 +0000315 PushDeclContext(FnBodyScope, MDecl);
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +0000316 PushFunctionScope();
317
Chris Lattner4d391482007-12-12 07:09:47 +0000318 // Create Decl objects for each parameter, entrring them in the scope for
319 // binding to their use.
Chris Lattner4d391482007-12-12 07:09:47 +0000320
321 // Insert the invisible arguments, self and _cmd!
Fariborz Jahanianfef30b52008-12-09 20:23:04 +0000322 MDecl->createImplicitParams(Context, MDecl->getClassInterface());
Mike Stump1eb44332009-09-09 15:08:12 +0000323
Daniel Dunbar451318c2008-08-26 06:07:48 +0000324 PushOnScopeChains(MDecl->getSelfDecl(), FnBodyScope);
325 PushOnScopeChains(MDecl->getCmdDecl(), FnBodyScope);
Chris Lattner04421082008-04-08 04:40:51 +0000326
Chris Lattner8123a952008-04-10 02:22:51 +0000327 // Introduce all of the other parameters into this scope.
Chris Lattner89951a82009-02-20 18:43:26 +0000328 for (ObjCMethodDecl::param_iterator PI = MDecl->param_begin(),
Fariborz Jahanian23c01042010-09-17 22:07:07 +0000329 E = MDecl->param_end(); PI != E; ++PI) {
330 ParmVarDecl *Param = (*PI);
331 if (!Param->isInvalidDecl() &&
332 RequireCompleteType(Param->getLocation(), Param->getType(),
333 diag::err_typecheck_decl_incomplete_type))
334 Param->setInvalidDecl();
Fariborz Jahaniana1a32f72012-09-13 18:53:14 +0000335 if (!Param->isInvalidDecl() &&
336 getLangOpts().ObjCAutoRefCount &&
337 !HasExplicitOwnershipAttr(*this, Param))
338 Diag(Param->getLocation(), diag::warn_arc_strong_pointer_objc_pointer) <<
339 Param->getType();
Fariborz Jahanian918546c2012-08-30 23:56:02 +0000340
Chris Lattner89951a82009-02-20 18:43:26 +0000341 if ((*PI)->getIdentifier())
342 PushOnScopeChains(*PI, FnBodyScope);
Fariborz Jahanian23c01042010-09-17 22:07:07 +0000343 }
John McCallf85e1932011-06-15 23:02:42 +0000344
345 // In ARC, disallow definition of retain/release/autorelease/retainCount
David Blaikie4e4d0842012-03-11 07:00:24 +0000346 if (getLangOpts().ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +0000347 switch (MDecl->getMethodFamily()) {
348 case OMF_retain:
349 case OMF_retainCount:
350 case OMF_release:
351 case OMF_autorelease:
352 Diag(MDecl->getLocation(), diag::err_arc_illegal_method_def)
353 << MDecl->getSelector();
354 break;
355
356 case OMF_None:
357 case OMF_dealloc:
Nico Weber80cb6e62011-08-28 22:35:17 +0000358 case OMF_finalize:
John McCallf85e1932011-06-15 23:02:42 +0000359 case OMF_alloc:
360 case OMF_init:
361 case OMF_mutableCopy:
362 case OMF_copy:
363 case OMF_new:
364 case OMF_self:
Fariborz Jahanian9670e172011-07-05 22:38:59 +0000365 case OMF_performSelector:
John McCallf85e1932011-06-15 23:02:42 +0000366 break;
367 }
368 }
369
Nico Weber9a1ecf02011-08-22 17:25:57 +0000370 // Warn on deprecated methods under -Wdeprecated-implementations,
371 // and prepare for warning on missing super calls.
372 if (ObjCInterfaceDecl *IC = MDecl->getClassInterface()) {
Fariborz Jahanian84101132012-09-07 23:46:23 +0000373 ObjCMethodDecl *IMD =
374 IC->lookupMethod(MDecl->getSelector(), MDecl->isInstanceMethod());
375
Fariborz Jahanian5fa66762012-11-17 20:53:53 +0000376 if (IMD) {
377 ObjCImplDecl *ImplDeclOfMethodDef =
378 dyn_cast<ObjCImplDecl>(MDecl->getDeclContext());
379 ObjCContainerDecl *ContDeclOfMethodDecl =
380 dyn_cast<ObjCContainerDecl>(IMD->getDeclContext());
381 ObjCImplDecl *ImplDeclOfMethodDecl = 0;
382 if (ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(ContDeclOfMethodDecl))
383 ImplDeclOfMethodDecl = OID->getImplementation();
384 else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ContDeclOfMethodDecl))
385 ImplDeclOfMethodDecl = CD->getImplementation();
386 // No need to issue deprecated warning if deprecated mehod in class/category
387 // is being implemented in its own implementation (no overriding is involved).
388 if (!ImplDeclOfMethodDecl || ImplDeclOfMethodDecl != ImplDeclOfMethodDef)
389 DiagnoseObjCImplementedDeprecations(*this,
Fariborz Jahanian5ac96d52011-02-15 17:49:58 +0000390 dyn_cast<NamedDecl>(IMD),
391 MDecl->getLocation(), 0);
Fariborz Jahanian5fa66762012-11-17 20:53:53 +0000392 }
Nico Weber9a1ecf02011-08-22 17:25:57 +0000393
Nico Weber80cb6e62011-08-28 22:35:17 +0000394 // If this is "dealloc" or "finalize", set some bit here.
Nico Weber9a1ecf02011-08-22 17:25:57 +0000395 // Then in ActOnSuperMessage() (SemaExprObjC), set it back to false.
396 // Finally, in ActOnFinishFunctionBody() (SemaDecl), warn if flag is set.
397 // Only do this if the current class actually has a superclass.
Nico Weber80cb6e62011-08-28 22:35:17 +0000398 if (IC->getSuperClass()) {
Jordan Rose535a5d02012-10-19 16:05:26 +0000399 ObjCMethodFamily Family = MDecl->getMethodFamily();
400 if (Family == OMF_dealloc) {
401 if (!(getLangOpts().ObjCAutoRefCount ||
402 getLangOpts().getGC() == LangOptions::GCOnly))
403 getCurFunction()->ObjCShouldCallSuper = true;
404
405 } else if (Family == OMF_finalize) {
406 if (Context.getLangOpts().getGC() != LangOptions::NonGC)
407 getCurFunction()->ObjCShouldCallSuper = true;
408
409 } else {
410 const ObjCMethodDecl *SuperMethod =
411 IC->getSuperClass()->lookupMethod(MDecl->getSelector(),
412 MDecl->isInstanceMethod());
413 getCurFunction()->ObjCShouldCallSuper =
414 (SuperMethod && SuperMethod->hasAttr<ObjCRequiresSuperAttr>());
Fariborz Jahanian6f938602012-09-10 18:04:25 +0000415 }
Nico Weber80cb6e62011-08-28 22:35:17 +0000416 }
Nico Weber9a1ecf02011-08-22 17:25:57 +0000417 }
Chris Lattner4d391482007-12-12 07:09:47 +0000418}
419
Kaelyn Uhrain2f4d88f2012-01-13 01:32:50 +0000420namespace {
421
422// Callback to only accept typo corrections that are Objective-C classes.
423// If an ObjCInterfaceDecl* is given to the constructor, then the validation
424// function will reject corrections to that class.
425class ObjCInterfaceValidatorCCC : public CorrectionCandidateCallback {
426 public:
427 ObjCInterfaceValidatorCCC() : CurrentIDecl(0) {}
428 explicit ObjCInterfaceValidatorCCC(ObjCInterfaceDecl *IDecl)
429 : CurrentIDecl(IDecl) {}
430
431 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
432 ObjCInterfaceDecl *ID = candidate.getCorrectionDeclAs<ObjCInterfaceDecl>();
433 return ID && !declaresSameEntity(ID, CurrentIDecl);
434 }
435
436 private:
437 ObjCInterfaceDecl *CurrentIDecl;
438};
439
440}
441
John McCalld226f652010-08-21 09:40:31 +0000442Decl *Sema::
Chris Lattner7caeabd2008-07-21 22:17:28 +0000443ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
444 IdentifierInfo *ClassName, SourceLocation ClassLoc,
445 IdentifierInfo *SuperName, SourceLocation SuperLoc,
John McCalld226f652010-08-21 09:40:31 +0000446 Decl * const *ProtoRefs, unsigned NumProtoRefs,
Douglas Gregor18df52b2010-01-16 15:02:53 +0000447 const SourceLocation *ProtoLocs,
Chris Lattner7caeabd2008-07-21 22:17:28 +0000448 SourceLocation EndProtoLoc, AttributeList *AttrList) {
Chris Lattner4d391482007-12-12 07:09:47 +0000449 assert(ClassName && "Missing class identifier");
Mike Stump1eb44332009-09-09 15:08:12 +0000450
Chris Lattner4d391482007-12-12 07:09:47 +0000451 // Check for another declaration kind with the same name.
Douglas Gregorc83c6872010-04-15 22:33:43 +0000452 NamedDecl *PrevDecl = LookupSingleName(TUScope, ClassName, ClassLoc,
Douglas Gregorc0b39642010-04-15 23:40:53 +0000453 LookupOrdinaryName, ForRedeclaration);
Douglas Gregor72c3f312008-12-05 18:15:24 +0000454
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000455 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000456 Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
Chris Lattner5f4a6822008-11-23 23:12:31 +0000457 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattner4d391482007-12-12 07:09:47 +0000458 }
Mike Stump1eb44332009-09-09 15:08:12 +0000459
Douglas Gregor7723fec2011-12-15 20:29:51 +0000460 // Create a declaration to describe this @interface.
Douglas Gregor0af55012011-12-16 03:12:41 +0000461 ObjCInterfaceDecl* PrevIDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
Douglas Gregor7723fec2011-12-15 20:29:51 +0000462 ObjCInterfaceDecl *IDecl
463 = ObjCInterfaceDecl::Create(Context, CurContext, AtInterfaceLoc, ClassName,
Douglas Gregor0af55012011-12-16 03:12:41 +0000464 PrevIDecl, ClassLoc);
Douglas Gregor7723fec2011-12-15 20:29:51 +0000465
Douglas Gregor7723fec2011-12-15 20:29:51 +0000466 if (PrevIDecl) {
467 // Class already seen. Was it a definition?
468 if (ObjCInterfaceDecl *Def = PrevIDecl->getDefinition()) {
469 Diag(AtInterfaceLoc, diag::err_duplicate_class_def)
470 << PrevIDecl->getDeclName();
Douglas Gregor2e5c15b2011-12-15 05:27:12 +0000471 Diag(Def->getLocation(), diag::note_previous_definition);
Douglas Gregor7723fec2011-12-15 20:29:51 +0000472 IDecl->setInvalidDecl();
Chris Lattner4d391482007-12-12 07:09:47 +0000473 }
Chris Lattner4d391482007-12-12 07:09:47 +0000474 }
Douglas Gregor7723fec2011-12-15 20:29:51 +0000475
476 if (AttrList)
477 ProcessDeclAttributeList(TUScope, IDecl, AttrList);
478 PushOnScopeChains(IDecl, TUScope);
Mike Stump1eb44332009-09-09 15:08:12 +0000479
Douglas Gregor7723fec2011-12-15 20:29:51 +0000480 // Start the definition of this class. If we're in a redefinition case, there
481 // may already be a definition, so we'll end up adding to it.
Douglas Gregor2e5c15b2011-12-15 05:27:12 +0000482 if (!IDecl->hasDefinition())
483 IDecl->startDefinition();
484
Chris Lattner4d391482007-12-12 07:09:47 +0000485 if (SuperName) {
Chris Lattner4d391482007-12-12 07:09:47 +0000486 // Check if a different kind of symbol declared in this scope.
Douglas Gregorc83c6872010-04-15 22:33:43 +0000487 PrevDecl = LookupSingleName(TUScope, SuperName, SuperLoc,
488 LookupOrdinaryName);
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000489
490 if (!PrevDecl) {
Kaelyn Uhrain2f4d88f2012-01-13 01:32:50 +0000491 // Try to correct for a typo in the superclass name without correcting
492 // to the class we're defining.
493 ObjCInterfaceValidatorCCC Validator(IDecl);
494 if (TypoCorrection Corrected = CorrectTypo(
Douglas Gregord8bba9c2011-06-28 16:20:02 +0000495 DeclarationNameInfo(SuperName, SuperLoc), LookupOrdinaryName, TUScope,
Kaelyn Uhrain16e46dd2012-01-31 23:49:25 +0000496 NULL, Validator)) {
Kaelyn Uhrain2f4d88f2012-01-13 01:32:50 +0000497 PrevDecl = Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>();
498 Diag(SuperLoc, diag::err_undef_superclass_suggest)
499 << SuperName << ClassName << PrevDecl->getDeclName();
500 Diag(PrevDecl->getLocation(), diag::note_previous_decl)
501 << PrevDecl->getDeclName();
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000502 }
503 }
504
Douglas Gregor60ef3082011-12-15 00:29:59 +0000505 if (declaresSameEntity(PrevDecl, IDecl)) {
Fariborz Jahanianfdee0892009-07-09 22:08:26 +0000506 Diag(SuperLoc, diag::err_recursive_superclass)
507 << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
Douglas Gregor05c272f2011-12-15 22:34:59 +0000508 IDecl->setEndOfDefinitionLoc(ClassLoc);
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000509 } else {
Mike Stump1eb44332009-09-09 15:08:12 +0000510 ObjCInterfaceDecl *SuperClassDecl =
Fariborz Jahanianfdee0892009-07-09 22:08:26 +0000511 dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
Chris Lattner3c73c412008-11-19 08:23:25 +0000512
Fariborz Jahanianfdee0892009-07-09 22:08:26 +0000513 // Diagnose classes that inherit from deprecated classes.
514 if (SuperClassDecl)
515 (void)DiagnoseUseOfDecl(SuperClassDecl, SuperLoc);
Mike Stump1eb44332009-09-09 15:08:12 +0000516
Fariborz Jahanianfdee0892009-07-09 22:08:26 +0000517 if (PrevDecl && SuperClassDecl == 0) {
518 // The previous declaration was not a class decl. Check if we have a
519 // typedef. If we do, get the underlying class type.
Richard Smith162e1c12011-04-15 14:24:37 +0000520 if (const TypedefNameDecl *TDecl =
521 dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
Fariborz Jahanianfdee0892009-07-09 22:08:26 +0000522 QualType T = TDecl->getUnderlyingType();
John McCallc12c5bb2010-05-15 11:32:37 +0000523 if (T->isObjCObjectType()) {
Douglas Gregordeacbdc2010-08-11 12:19:30 +0000524 if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface())
525 SuperClassDecl = dyn_cast<ObjCInterfaceDecl>(IDecl);
Fariborz Jahanianfdee0892009-07-09 22:08:26 +0000526 }
527 }
Mike Stump1eb44332009-09-09 15:08:12 +0000528
Fariborz Jahanianfdee0892009-07-09 22:08:26 +0000529 // This handles the following case:
530 //
531 // typedef int SuperClass;
532 // @interface MyClass : SuperClass {} @end
533 //
534 if (!SuperClassDecl) {
535 Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName;
536 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Steve Naroff818cb9e2009-02-04 17:14:05 +0000537 }
538 }
Mike Stump1eb44332009-09-09 15:08:12 +0000539
Richard Smith162e1c12011-04-15 14:24:37 +0000540 if (!dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
Fariborz Jahanianfdee0892009-07-09 22:08:26 +0000541 if (!SuperClassDecl)
542 Diag(SuperLoc, diag::err_undef_superclass)
543 << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
Douglas Gregorb3029962011-11-14 22:10:01 +0000544 else if (RequireCompleteType(SuperLoc,
Douglas Gregord10099e2012-05-04 16:32:21 +0000545 Context.getObjCInterfaceType(SuperClassDecl),
546 diag::err_forward_superclass,
547 SuperClassDecl->getDeclName(),
548 ClassName,
549 SourceRange(AtInterfaceLoc, ClassLoc))) {
Fariborz Jahaniana8139732011-06-23 23:16:19 +0000550 SuperClassDecl = 0;
551 }
Steve Naroff818cb9e2009-02-04 17:14:05 +0000552 }
Fariborz Jahanianfdee0892009-07-09 22:08:26 +0000553 IDecl->setSuperClass(SuperClassDecl);
554 IDecl->setSuperClassLoc(SuperLoc);
Douglas Gregor05c272f2011-12-15 22:34:59 +0000555 IDecl->setEndOfDefinitionLoc(SuperLoc);
Steve Naroff818cb9e2009-02-04 17:14:05 +0000556 }
Chris Lattner4d391482007-12-12 07:09:47 +0000557 } else { // we have a root class.
Douglas Gregor05c272f2011-12-15 22:34:59 +0000558 IDecl->setEndOfDefinitionLoc(ClassLoc);
Chris Lattner4d391482007-12-12 07:09:47 +0000559 }
Mike Stump1eb44332009-09-09 15:08:12 +0000560
Sebastian Redl0b17c612010-08-13 00:28:03 +0000561 // Check then save referenced protocols.
Chris Lattner06036d32008-07-26 04:13:19 +0000562 if (NumProtoRefs) {
Roman Divacky31ba6132012-09-06 15:59:27 +0000563 IDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
Douglas Gregor18df52b2010-01-16 15:02:53 +0000564 ProtoLocs, Context);
Douglas Gregor05c272f2011-12-15 22:34:59 +0000565 IDecl->setEndOfDefinitionLoc(EndProtoLoc);
Chris Lattner4d391482007-12-12 07:09:47 +0000566 }
Mike Stump1eb44332009-09-09 15:08:12 +0000567
Anders Carlsson15281452008-11-04 16:57:32 +0000568 CheckObjCDeclScope(IDecl);
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +0000569 return ActOnObjCContainerStartDefinition(IDecl);
Chris Lattner4d391482007-12-12 07:09:47 +0000570}
571
Richard Smithde01b7a2012-08-08 23:32:13 +0000572/// ActOnCompatibilityAlias - this action is called after complete parsing of
James Dennett1dfbd922012-06-14 21:40:34 +0000573/// a \@compatibility_alias declaration. It sets up the alias relationships.
Richard Smithde01b7a2012-08-08 23:32:13 +0000574Decl *Sema::ActOnCompatibilityAlias(SourceLocation AtLoc,
575 IdentifierInfo *AliasName,
576 SourceLocation AliasLocation,
577 IdentifierInfo *ClassName,
578 SourceLocation ClassLocation) {
Chris Lattner4d391482007-12-12 07:09:47 +0000579 // Look for previous declaration of alias name
Douglas Gregorc83c6872010-04-15 22:33:43 +0000580 NamedDecl *ADecl = LookupSingleName(TUScope, AliasName, AliasLocation,
Douglas Gregorc0b39642010-04-15 23:40:53 +0000581 LookupOrdinaryName, ForRedeclaration);
Chris Lattner4d391482007-12-12 07:09:47 +0000582 if (ADecl) {
Chris Lattner8b265bd2008-11-23 23:20:13 +0000583 if (isa<ObjCCompatibleAliasDecl>(ADecl))
Chris Lattner4d391482007-12-12 07:09:47 +0000584 Diag(AliasLocation, diag::warn_previous_alias_decl);
Chris Lattner8b265bd2008-11-23 23:20:13 +0000585 else
Chris Lattner3c73c412008-11-19 08:23:25 +0000586 Diag(AliasLocation, diag::err_conflicting_aliasing_type) << AliasName;
Chris Lattner8b265bd2008-11-23 23:20:13 +0000587 Diag(ADecl->getLocation(), diag::note_previous_declaration);
John McCalld226f652010-08-21 09:40:31 +0000588 return 0;
Chris Lattner4d391482007-12-12 07:09:47 +0000589 }
590 // Check for class declaration
Douglas Gregorc83c6872010-04-15 22:33:43 +0000591 NamedDecl *CDeclU = LookupSingleName(TUScope, ClassName, ClassLocation,
Douglas Gregorc0b39642010-04-15 23:40:53 +0000592 LookupOrdinaryName, ForRedeclaration);
Richard Smith162e1c12011-04-15 14:24:37 +0000593 if (const TypedefNameDecl *TDecl =
594 dyn_cast_or_null<TypedefNameDecl>(CDeclU)) {
Fariborz Jahanian305c6582009-01-08 01:10:55 +0000595 QualType T = TDecl->getUnderlyingType();
John McCallc12c5bb2010-05-15 11:32:37 +0000596 if (T->isObjCObjectType()) {
597 if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface()) {
Fariborz Jahanian305c6582009-01-08 01:10:55 +0000598 ClassName = IDecl->getIdentifier();
Douglas Gregorc83c6872010-04-15 22:33:43 +0000599 CDeclU = LookupSingleName(TUScope, ClassName, ClassLocation,
Douglas Gregorc0b39642010-04-15 23:40:53 +0000600 LookupOrdinaryName, ForRedeclaration);
Fariborz Jahanian305c6582009-01-08 01:10:55 +0000601 }
602 }
603 }
Chris Lattnerf8d17a52008-03-16 21:17:37 +0000604 ObjCInterfaceDecl *CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDeclU);
605 if (CDecl == 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000606 Diag(ClassLocation, diag::warn_undef_interface) << ClassName;
Chris Lattnerf8d17a52008-03-16 21:17:37 +0000607 if (CDeclU)
Chris Lattner8b265bd2008-11-23 23:20:13 +0000608 Diag(CDeclU->getLocation(), diag::note_previous_declaration);
John McCalld226f652010-08-21 09:40:31 +0000609 return 0;
Chris Lattner4d391482007-12-12 07:09:47 +0000610 }
Mike Stump1eb44332009-09-09 15:08:12 +0000611
Chris Lattnerf8d17a52008-03-16 21:17:37 +0000612 // Everything checked out, instantiate a new alias declaration AST.
Mike Stump1eb44332009-09-09 15:08:12 +0000613 ObjCCompatibleAliasDecl *AliasDecl =
Douglas Gregord0434102009-01-09 00:49:46 +0000614 ObjCCompatibleAliasDecl::Create(Context, CurContext, AtLoc, AliasName, CDecl);
Mike Stump1eb44332009-09-09 15:08:12 +0000615
Anders Carlsson15281452008-11-04 16:57:32 +0000616 if (!CheckObjCDeclScope(AliasDecl))
Douglas Gregor516ff432009-04-24 02:57:34 +0000617 PushOnScopeChains(AliasDecl, TUScope);
Douglas Gregord0434102009-01-09 00:49:46 +0000618
John McCalld226f652010-08-21 09:40:31 +0000619 return AliasDecl;
Chris Lattner4d391482007-12-12 07:09:47 +0000620}
621
Fariborz Jahanian819e9bf2011-05-13 18:02:08 +0000622bool Sema::CheckForwardProtocolDeclarationForCircularDependency(
Steve Naroff61d68522009-03-05 15:22:01 +0000623 IdentifierInfo *PName,
624 SourceLocation &Ploc, SourceLocation PrevLoc,
Fariborz Jahanian819e9bf2011-05-13 18:02:08 +0000625 const ObjCList<ObjCProtocolDecl> &PList) {
626
627 bool res = false;
Steve Naroff61d68522009-03-05 15:22:01 +0000628 for (ObjCList<ObjCProtocolDecl>::iterator I = PList.begin(),
629 E = PList.end(); I != E; ++I) {
Douglas Gregorc83c6872010-04-15 22:33:43 +0000630 if (ObjCProtocolDecl *PDecl = LookupProtocol((*I)->getIdentifier(),
631 Ploc)) {
Steve Naroff61d68522009-03-05 15:22:01 +0000632 if (PDecl->getIdentifier() == PName) {
633 Diag(Ploc, diag::err_protocol_has_circular_dependency);
634 Diag(PrevLoc, diag::note_previous_definition);
Fariborz Jahanian819e9bf2011-05-13 18:02:08 +0000635 res = true;
Steve Naroff61d68522009-03-05 15:22:01 +0000636 }
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +0000637
638 if (!PDecl->hasDefinition())
639 continue;
640
Fariborz Jahanian819e9bf2011-05-13 18:02:08 +0000641 if (CheckForwardProtocolDeclarationForCircularDependency(PName, Ploc,
642 PDecl->getLocation(), PDecl->getReferencedProtocols()))
643 res = true;
Steve Naroff61d68522009-03-05 15:22:01 +0000644 }
645 }
Fariborz Jahanian819e9bf2011-05-13 18:02:08 +0000646 return res;
Steve Naroff61d68522009-03-05 15:22:01 +0000647}
648
John McCalld226f652010-08-21 09:40:31 +0000649Decl *
Chris Lattnere13b9592008-07-26 04:03:38 +0000650Sema::ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc,
651 IdentifierInfo *ProtocolName,
652 SourceLocation ProtocolLoc,
John McCalld226f652010-08-21 09:40:31 +0000653 Decl * const *ProtoRefs,
Chris Lattnere13b9592008-07-26 04:03:38 +0000654 unsigned NumProtoRefs,
Douglas Gregor18df52b2010-01-16 15:02:53 +0000655 const SourceLocation *ProtoLocs,
Daniel Dunbar246e70f2008-09-26 04:48:09 +0000656 SourceLocation EndProtoLoc,
657 AttributeList *AttrList) {
Fariborz Jahanian96b69a72011-05-12 22:04:39 +0000658 bool err = false;
Daniel Dunbar246e70f2008-09-26 04:48:09 +0000659 // FIXME: Deal with AttrList.
Chris Lattner4d391482007-12-12 07:09:47 +0000660 assert(ProtocolName && "Missing protocol identifier");
Douglas Gregor27c6da22012-01-01 20:30:41 +0000661 ObjCProtocolDecl *PrevDecl = LookupProtocol(ProtocolName, ProtocolLoc,
662 ForRedeclaration);
663 ObjCProtocolDecl *PDecl = 0;
664 if (ObjCProtocolDecl *Def = PrevDecl? PrevDecl->getDefinition() : 0) {
665 // If we already have a definition, complain.
666 Diag(ProtocolLoc, diag::warn_duplicate_protocol_def) << ProtocolName;
667 Diag(Def->getLocation(), diag::note_previous_definition);
Mike Stump1eb44332009-09-09 15:08:12 +0000668
Douglas Gregor27c6da22012-01-01 20:30:41 +0000669 // Create a new protocol that is completely distinct from previous
670 // declarations, and do not make this protocol available for name lookup.
671 // That way, we'll end up completely ignoring the duplicate.
672 // FIXME: Can we turn this into an error?
673 PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
674 ProtocolLoc, AtProtoInterfaceLoc,
Douglas Gregorc9d3c7e2012-01-01 22:06:18 +0000675 /*PrevDecl=*/0);
Douglas Gregor27c6da22012-01-01 20:30:41 +0000676 PDecl->startDefinition();
677 } else {
678 if (PrevDecl) {
679 // Check for circular dependencies among protocol declarations. This can
680 // only happen if this protocol was forward-declared.
Argyrios Kyrtzidis4fc04da2011-11-13 22:08:30 +0000681 ObjCList<ObjCProtocolDecl> PList;
682 PList.set((ObjCProtocolDecl *const*)ProtoRefs, NumProtoRefs, Context);
683 err = CheckForwardProtocolDeclarationForCircularDependency(
Douglas Gregor27c6da22012-01-01 20:30:41 +0000684 ProtocolName, ProtocolLoc, PrevDecl->getLocation(), PList);
Argyrios Kyrtzidis4fc04da2011-11-13 22:08:30 +0000685 }
Douglas Gregor27c6da22012-01-01 20:30:41 +0000686
687 // Create the new declaration.
Argyrios Kyrtzidis1711fc92011-10-04 04:48:02 +0000688 PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
Argyrios Kyrtzidisb05d7b22011-10-17 19:48:06 +0000689 ProtocolLoc, AtProtoInterfaceLoc,
Douglas Gregorc9d3c7e2012-01-01 22:06:18 +0000690 /*PrevDecl=*/PrevDecl);
Douglas Gregor27c6da22012-01-01 20:30:41 +0000691
Douglas Gregor6e378de2009-04-23 23:18:26 +0000692 PushOnScopeChains(PDecl, TUScope);
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +0000693 PDecl->startDefinition();
Chris Lattnercca59d72008-03-16 01:23:04 +0000694 }
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +0000695
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +0000696 if (AttrList)
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000697 ProcessDeclAttributeList(TUScope, PDecl, AttrList);
Douglas Gregor27c6da22012-01-01 20:30:41 +0000698
699 // Merge attributes from previous declarations.
700 if (PrevDecl)
701 mergeDeclAttributes(PDecl, PrevDecl);
702
Fariborz Jahanian96b69a72011-05-12 22:04:39 +0000703 if (!err && NumProtoRefs ) {
Chris Lattnerc8581052008-03-16 20:19:15 +0000704 /// Check then save referenced protocols.
Roman Divacky31ba6132012-09-06 15:59:27 +0000705 PDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
Douglas Gregor18df52b2010-01-16 15:02:53 +0000706 ProtoLocs, Context);
Chris Lattner4d391482007-12-12 07:09:47 +0000707 }
Mike Stump1eb44332009-09-09 15:08:12 +0000708
709 CheckObjCDeclScope(PDecl);
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +0000710 return ActOnObjCContainerStartDefinition(PDecl);
Chris Lattner4d391482007-12-12 07:09:47 +0000711}
712
713/// FindProtocolDeclaration - This routine looks up protocols and
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +0000714/// issues an error if they are not declared. It returns list of
715/// protocol declarations in its 'Protocols' argument.
Chris Lattner4d391482007-12-12 07:09:47 +0000716void
Chris Lattnere13b9592008-07-26 04:03:38 +0000717Sema::FindProtocolDeclaration(bool WarnOnDeclarations,
Chris Lattner7caeabd2008-07-21 22:17:28 +0000718 const IdentifierLocPair *ProtocolId,
Chris Lattner4d391482007-12-12 07:09:47 +0000719 unsigned NumProtocols,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000720 SmallVectorImpl<Decl *> &Protocols) {
Chris Lattner4d391482007-12-12 07:09:47 +0000721 for (unsigned i = 0; i != NumProtocols; ++i) {
Douglas Gregorc83c6872010-04-15 22:33:43 +0000722 ObjCProtocolDecl *PDecl = LookupProtocol(ProtocolId[i].first,
723 ProtocolId[i].second);
Chris Lattnereacc3922008-07-26 03:47:43 +0000724 if (!PDecl) {
Kaelyn Uhrain2f4d88f2012-01-13 01:32:50 +0000725 DeclFilterCCC<ObjCProtocolDecl> Validator;
Douglas Gregord8bba9c2011-06-28 16:20:02 +0000726 TypoCorrection Corrected = CorrectTypo(
727 DeclarationNameInfo(ProtocolId[i].first, ProtocolId[i].second),
Kaelyn Uhrain16e46dd2012-01-31 23:49:25 +0000728 LookupObjCProtocolName, TUScope, NULL, Validator);
Douglas Gregord8bba9c2011-06-28 16:20:02 +0000729 if ((PDecl = Corrected.getCorrectionDeclAs<ObjCProtocolDecl>())) {
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000730 Diag(ProtocolId[i].second, diag::err_undeclared_protocol_suggest)
Douglas Gregord8bba9c2011-06-28 16:20:02 +0000731 << ProtocolId[i].first << Corrected.getCorrection();
Douglas Gregor67dd1d42010-01-07 00:17:44 +0000732 Diag(PDecl->getLocation(), diag::note_previous_decl)
733 << PDecl->getDeclName();
Douglas Gregorf06cdae2010-01-03 18:01:57 +0000734 }
735 }
736
737 if (!PDecl) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000738 Diag(ProtocolId[i].second, diag::err_undeclared_protocol)
Chris Lattner3c73c412008-11-19 08:23:25 +0000739 << ProtocolId[i].first;
Chris Lattnereacc3922008-07-26 03:47:43 +0000740 continue;
741 }
Mike Stump1eb44332009-09-09 15:08:12 +0000742
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000743 (void)DiagnoseUseOfDecl(PDecl, ProtocolId[i].second);
Chris Lattnereacc3922008-07-26 03:47:43 +0000744
745 // If this is a forward declaration and we are supposed to warn in this
746 // case, do it.
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +0000747 if (WarnOnDeclarations && !PDecl->hasDefinition())
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000748 Diag(ProtocolId[i].second, diag::warn_undef_protocolref)
Chris Lattner3c73c412008-11-19 08:23:25 +0000749 << ProtocolId[i].first;
John McCalld226f652010-08-21 09:40:31 +0000750 Protocols.push_back(PDecl);
Chris Lattner4d391482007-12-12 07:09:47 +0000751 }
752}
753
Fariborz Jahanian78c39c72009-03-02 19:06:08 +0000754/// DiagnoseClassExtensionDupMethods - Check for duplicate declaration of
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +0000755/// a class method in its extension.
756///
Mike Stump1eb44332009-09-09 15:08:12 +0000757void Sema::DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +0000758 ObjCInterfaceDecl *ID) {
759 if (!ID)
760 return; // Possibly due to previous error
761
762 llvm::DenseMap<Selector, const ObjCMethodDecl*> MethodMap;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000763 for (ObjCInterfaceDecl::method_iterator i = ID->meth_begin(),
764 e = ID->meth_end(); i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000765 ObjCMethodDecl *MD = *i;
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +0000766 MethodMap[MD->getSelector()] = MD;
767 }
768
769 if (MethodMap.empty())
770 return;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000771 for (ObjCCategoryDecl::method_iterator i = CAT->meth_begin(),
772 e = CAT->meth_end(); i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +0000773 ObjCMethodDecl *Method = *i;
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +0000774 const ObjCMethodDecl *&PrevMethod = MethodMap[Method->getSelector()];
775 if (PrevMethod && !MatchTwoMethodDeclarations(Method, PrevMethod)) {
776 Diag(Method->getLocation(), diag::err_duplicate_method_decl)
777 << Method->getDeclName();
778 Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
779 }
780 }
781}
782
James Dennett1dfbd922012-06-14 21:40:34 +0000783/// ActOnForwardProtocolDeclaration - Handle \@protocol foo;
Douglas Gregorbd9482d2012-01-01 21:23:57 +0000784Sema::DeclGroupPtrTy
Chris Lattner4d391482007-12-12 07:09:47 +0000785Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
Chris Lattner7caeabd2008-07-21 22:17:28 +0000786 const IdentifierLocPair *IdentList,
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +0000787 unsigned NumElts,
788 AttributeList *attrList) {
Douglas Gregorbd9482d2012-01-01 21:23:57 +0000789 SmallVector<Decl *, 8> DeclsInGroup;
Chris Lattner4d391482007-12-12 07:09:47 +0000790 for (unsigned i = 0; i != NumElts; ++i) {
Chris Lattner7caeabd2008-07-21 22:17:28 +0000791 IdentifierInfo *Ident = IdentList[i].first;
Douglas Gregor27c6da22012-01-01 20:30:41 +0000792 ObjCProtocolDecl *PrevDecl = LookupProtocol(Ident, IdentList[i].second,
793 ForRedeclaration);
794 ObjCProtocolDecl *PDecl
795 = ObjCProtocolDecl::Create(Context, CurContext, Ident,
796 IdentList[i].second, AtProtocolLoc,
Douglas Gregorc9d3c7e2012-01-01 22:06:18 +0000797 PrevDecl);
Douglas Gregor27c6da22012-01-01 20:30:41 +0000798
799 PushOnScopeChains(PDecl, TUScope);
Douglas Gregorbd9482d2012-01-01 21:23:57 +0000800 CheckObjCDeclScope(PDecl);
Douglas Gregor27c6da22012-01-01 20:30:41 +0000801
Douglas Gregor3937f872012-01-01 20:33:24 +0000802 if (attrList)
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000803 ProcessDeclAttributeList(TUScope, PDecl, attrList);
Douglas Gregor27c6da22012-01-01 20:30:41 +0000804
805 if (PrevDecl)
806 mergeDeclAttributes(PDecl, PrevDecl);
807
Douglas Gregorbd9482d2012-01-01 21:23:57 +0000808 DeclsInGroup.push_back(PDecl);
Chris Lattner4d391482007-12-12 07:09:47 +0000809 }
Mike Stump1eb44332009-09-09 15:08:12 +0000810
Douglas Gregorbd9482d2012-01-01 21:23:57 +0000811 return BuildDeclaratorGroup(DeclsInGroup.data(), DeclsInGroup.size(), false);
Chris Lattner4d391482007-12-12 07:09:47 +0000812}
813
John McCalld226f652010-08-21 09:40:31 +0000814Decl *Sema::
Chris Lattner7caeabd2008-07-21 22:17:28 +0000815ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
816 IdentifierInfo *ClassName, SourceLocation ClassLoc,
817 IdentifierInfo *CategoryName,
818 SourceLocation CategoryLoc,
John McCalld226f652010-08-21 09:40:31 +0000819 Decl * const *ProtoRefs,
Chris Lattner7caeabd2008-07-21 22:17:28 +0000820 unsigned NumProtoRefs,
Douglas Gregor18df52b2010-01-16 15:02:53 +0000821 const SourceLocation *ProtoLocs,
Chris Lattner7caeabd2008-07-21 22:17:28 +0000822 SourceLocation EndProtoLoc) {
Fariborz Jahanian80aa1cd2010-06-22 23:20:40 +0000823 ObjCCategoryDecl *CDecl;
Douglas Gregorc83c6872010-04-15 22:33:43 +0000824 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);
Ted Kremenek09b68972010-02-23 19:39:46 +0000825
826 /// Check that class of this category is already completely declared.
Douglas Gregorb3029962011-11-14 22:10:01 +0000827
828 if (!IDecl
829 || RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
Douglas Gregord10099e2012-05-04 16:32:21 +0000830 diag::err_category_forward_interface,
831 CategoryName == 0)) {
Ted Kremenek09b68972010-02-23 19:39:46 +0000832 // Create an invalid ObjCCategoryDecl to serve as context for
833 // the enclosing method declarations. We mark the decl invalid
834 // to make it clear that this isn't a valid AST.
835 CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
Argyrios Kyrtzidis955fadb2011-08-30 19:43:26 +0000836 ClassLoc, CategoryLoc, CategoryName,IDecl);
Ted Kremenek09b68972010-02-23 19:39:46 +0000837 CDecl->setInvalidDecl();
Argyrios Kyrtzidis9a0b6b42012-03-12 18:34:26 +0000838 CurContext->addDecl(CDecl);
Douglas Gregorb3029962011-11-14 22:10:01 +0000839
840 if (!IDecl)
841 Diag(ClassLoc, diag::err_undef_interface) << ClassName;
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +0000842 return ActOnObjCContainerStartDefinition(CDecl);
Ted Kremenek09b68972010-02-23 19:39:46 +0000843 }
844
Fariborz Jahanian80aa1cd2010-06-22 23:20:40 +0000845 if (!CategoryName && IDecl->getImplementation()) {
846 Diag(ClassLoc, diag::err_class_extension_after_impl) << ClassName;
847 Diag(IDecl->getImplementation()->getLocation(),
848 diag::note_implementation_declared);
Ted Kremenek09b68972010-02-23 19:39:46 +0000849 }
850
Fariborz Jahanian25760612010-02-15 21:55:26 +0000851 if (CategoryName) {
852 /// Check for duplicate interface declaration for this category
853 ObjCCategoryDecl *CDeclChain;
854 for (CDeclChain = IDecl->getCategoryList(); CDeclChain;
855 CDeclChain = CDeclChain->getNextClassCategory()) {
856 if (CDeclChain->getIdentifier() == CategoryName) {
857 // Class extensions can be declared multiple times.
858 Diag(CategoryLoc, diag::warn_dup_category_def)
859 << ClassName << CategoryName;
860 Diag(CDeclChain->getLocation(), diag::note_previous_definition);
861 break;
862 }
Chris Lattner70f19542009-02-16 21:26:43 +0000863 }
864 }
Chris Lattner70f19542009-02-16 21:26:43 +0000865
Argyrios Kyrtzidis955fadb2011-08-30 19:43:26 +0000866 CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
867 ClassLoc, CategoryLoc, CategoryName, IDecl);
868 // FIXME: PushOnScopeChains?
869 CurContext->addDecl(CDecl);
870
Chris Lattner4d391482007-12-12 07:09:47 +0000871 if (NumProtoRefs) {
Roman Divacky31ba6132012-09-06 15:59:27 +0000872 CDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
Douglas Gregor18df52b2010-01-16 15:02:53 +0000873 ProtoLocs, Context);
Fariborz Jahanian339798e2009-10-05 20:41:32 +0000874 // Protocols in the class extension belong to the class.
Fariborz Jahanian25760612010-02-15 21:55:26 +0000875 if (CDecl->IsClassExtension())
Roman Divacky31ba6132012-09-06 15:59:27 +0000876 IDecl->mergeClassExtensionProtocolList((ObjCProtocolDecl*const*)ProtoRefs,
Ted Kremenek53b94412010-09-01 01:21:15 +0000877 NumProtoRefs, Context);
Chris Lattner4d391482007-12-12 07:09:47 +0000878 }
Mike Stump1eb44332009-09-09 15:08:12 +0000879
Anders Carlsson15281452008-11-04 16:57:32 +0000880 CheckObjCDeclScope(CDecl);
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +0000881 return ActOnObjCContainerStartDefinition(CDecl);
Chris Lattner4d391482007-12-12 07:09:47 +0000882}
883
884/// ActOnStartCategoryImplementation - Perform semantic checks on the
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000885/// category implementation declaration and build an ObjCCategoryImplDecl
Chris Lattner4d391482007-12-12 07:09:47 +0000886/// object.
John McCalld226f652010-08-21 09:40:31 +0000887Decl *Sema::ActOnStartCategoryImplementation(
Chris Lattner4d391482007-12-12 07:09:47 +0000888 SourceLocation AtCatImplLoc,
889 IdentifierInfo *ClassName, SourceLocation ClassLoc,
890 IdentifierInfo *CatName, SourceLocation CatLoc) {
Douglas Gregorc83c6872010-04-15 22:33:43 +0000891 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +0000892 ObjCCategoryDecl *CatIDecl = 0;
Argyrios Kyrtzidis5a61e0c2012-03-02 19:14:29 +0000893 if (IDecl && IDecl->hasDefinition()) {
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +0000894 CatIDecl = IDecl->FindCategoryDeclaration(CatName);
895 if (!CatIDecl) {
896 // Category @implementation with no corresponding @interface.
897 // Create and install one.
Argyrios Kyrtzidis37f40572011-11-23 20:27:26 +0000898 CatIDecl = ObjCCategoryDecl::Create(Context, CurContext, AtCatImplLoc,
899 ClassLoc, CatLoc,
Argyrios Kyrtzidis955fadb2011-08-30 19:43:26 +0000900 CatName, IDecl);
Argyrios Kyrtzidis37f40572011-11-23 20:27:26 +0000901 CatIDecl->setImplicit();
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +0000902 }
903 }
904
Mike Stump1eb44332009-09-09 15:08:12 +0000905 ObjCCategoryImplDecl *CDecl =
Argyrios Kyrtzidis1711fc92011-10-04 04:48:02 +0000906 ObjCCategoryImplDecl::Create(Context, CurContext, CatName, IDecl,
Argyrios Kyrtzidisc6994002011-12-09 00:31:40 +0000907 ClassLoc, AtCatImplLoc, CatLoc);
Chris Lattner4d391482007-12-12 07:09:47 +0000908 /// Check that class of this category is already completely declared.
Douglas Gregorb3029962011-11-14 22:10:01 +0000909 if (!IDecl) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000910 Diag(ClassLoc, diag::err_undef_interface) << ClassName;
John McCall6c2c2502011-07-22 02:45:48 +0000911 CDecl->setInvalidDecl();
Douglas Gregorb3029962011-11-14 22:10:01 +0000912 } else if (RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
913 diag::err_undef_interface)) {
914 CDecl->setInvalidDecl();
John McCall6c2c2502011-07-22 02:45:48 +0000915 }
Chris Lattner4d391482007-12-12 07:09:47 +0000916
Douglas Gregord0434102009-01-09 00:49:46 +0000917 // FIXME: PushOnScopeChains?
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000918 CurContext->addDecl(CDecl);
Douglas Gregord0434102009-01-09 00:49:46 +0000919
Argyrios Kyrtzidisc076e372011-10-06 23:23:27 +0000920 // If the interface is deprecated/unavailable, warn/error about it.
921 if (IDecl)
922 DiagnoseUseOfDecl(IDecl, ClassLoc);
923
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +0000924 /// Check that CatName, category name, is not used in another implementation.
925 if (CatIDecl) {
926 if (CatIDecl->getImplementation()) {
927 Diag(ClassLoc, diag::err_dup_implementation_category) << ClassName
928 << CatName;
929 Diag(CatIDecl->getImplementation()->getLocation(),
930 diag::note_previous_definition);
Fariborz Jahanianb1224f62011-02-15 00:59:30 +0000931 } else {
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +0000932 CatIDecl->setImplementation(CDecl);
Fariborz Jahanianb1224f62011-02-15 00:59:30 +0000933 // Warn on implementating category of deprecated class under
934 // -Wdeprecated-implementations flag.
Fariborz Jahanian5ac96d52011-02-15 17:49:58 +0000935 DiagnoseObjCImplementedDeprecations(*this,
936 dyn_cast<NamedDecl>(IDecl),
937 CDecl->getLocation(), 2);
Fariborz Jahanianb1224f62011-02-15 00:59:30 +0000938 }
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +0000939 }
Mike Stump1eb44332009-09-09 15:08:12 +0000940
Anders Carlsson15281452008-11-04 16:57:32 +0000941 CheckObjCDeclScope(CDecl);
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +0000942 return ActOnObjCContainerStartDefinition(CDecl);
Chris Lattner4d391482007-12-12 07:09:47 +0000943}
944
John McCalld226f652010-08-21 09:40:31 +0000945Decl *Sema::ActOnStartClassImplementation(
Chris Lattner4d391482007-12-12 07:09:47 +0000946 SourceLocation AtClassImplLoc,
947 IdentifierInfo *ClassName, SourceLocation ClassLoc,
Mike Stump1eb44332009-09-09 15:08:12 +0000948 IdentifierInfo *SuperClassname,
Chris Lattner4d391482007-12-12 07:09:47 +0000949 SourceLocation SuperClassLoc) {
Douglas Gregordeacbdc2010-08-11 12:19:30 +0000950 ObjCInterfaceDecl* IDecl = 0;
Chris Lattner4d391482007-12-12 07:09:47 +0000951 // Check for another declaration kind with the same name.
John McCallf36e02d2009-10-09 21:13:30 +0000952 NamedDecl *PrevDecl
Douglas Gregorc0b39642010-04-15 23:40:53 +0000953 = LookupSingleName(TUScope, ClassName, ClassLoc, LookupOrdinaryName,
954 ForRedeclaration);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000955 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000956 Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
Chris Lattner5f4a6822008-11-23 23:12:31 +0000957 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Douglas Gregordeacbdc2010-08-11 12:19:30 +0000958 } else if ((IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl))) {
Douglas Gregor0af55012011-12-16 03:12:41 +0000959 RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
960 diag::warn_undef_interface);
Douglas Gregor95ff7422010-01-04 17:27:12 +0000961 } else {
962 // We did not find anything with the name ClassName; try to correct for
963 // typos in the class name.
Kaelyn Uhrain2f4d88f2012-01-13 01:32:50 +0000964 ObjCInterfaceValidatorCCC Validator;
965 if (TypoCorrection Corrected = CorrectTypo(
Douglas Gregord8bba9c2011-06-28 16:20:02 +0000966 DeclarationNameInfo(ClassName, ClassLoc), LookupOrdinaryName, TUScope,
Kaelyn Uhrain16e46dd2012-01-31 23:49:25 +0000967 NULL, Validator)) {
Douglas Gregora6f26382010-01-06 23:44:25 +0000968 // Suggest the (potentially) correct interface name. However, put the
969 // fix-it hint itself in a separate note, since changing the name in
Douglas Gregordeacbdc2010-08-11 12:19:30 +0000970 // the warning would make the fix-it change semantics.However, don't
Douglas Gregor95ff7422010-01-04 17:27:12 +0000971 // provide a code-modification hint or use the typo name for recovery,
972 // because this is just a warning. The program may actually be correct.
Kaelyn Uhrain2f4d88f2012-01-13 01:32:50 +0000973 IDecl = Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>();
Douglas Gregord8bba9c2011-06-28 16:20:02 +0000974 DeclarationName CorrectedName = Corrected.getCorrection();
Douglas Gregor95ff7422010-01-04 17:27:12 +0000975 Diag(ClassLoc, diag::warn_undef_interface_suggest)
Douglas Gregord8bba9c2011-06-28 16:20:02 +0000976 << ClassName << CorrectedName;
977 Diag(IDecl->getLocation(), diag::note_previous_decl) << CorrectedName
978 << FixItHint::CreateReplacement(ClassLoc, CorrectedName.getAsString());
Douglas Gregor95ff7422010-01-04 17:27:12 +0000979 IDecl = 0;
980 } else {
981 Diag(ClassLoc, diag::warn_undef_interface) << ClassName;
982 }
Chris Lattner4d391482007-12-12 07:09:47 +0000983 }
Mike Stump1eb44332009-09-09 15:08:12 +0000984
Chris Lattner4d391482007-12-12 07:09:47 +0000985 // Check that super class name is valid class name
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000986 ObjCInterfaceDecl* SDecl = 0;
Chris Lattner4d391482007-12-12 07:09:47 +0000987 if (SuperClassname) {
988 // Check if a different kind of symbol declared in this scope.
Douglas Gregorc83c6872010-04-15 22:33:43 +0000989 PrevDecl = LookupSingleName(TUScope, SuperClassname, SuperClassLoc,
990 LookupOrdinaryName);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000991 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000992 Diag(SuperClassLoc, diag::err_redefinition_different_kind)
993 << SuperClassname;
Chris Lattner5f4a6822008-11-23 23:12:31 +0000994 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Chris Lattner3c73c412008-11-19 08:23:25 +0000995 } else {
Mike Stump1eb44332009-09-09 15:08:12 +0000996 SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
Argyrios Kyrtzidiscd707ab2012-03-13 01:09:36 +0000997 if (SDecl && !SDecl->hasDefinition())
998 SDecl = 0;
Chris Lattner4d391482007-12-12 07:09:47 +0000999 if (!SDecl)
Chris Lattner3c73c412008-11-19 08:23:25 +00001000 Diag(SuperClassLoc, diag::err_undef_superclass)
1001 << SuperClassname << ClassName;
Douglas Gregor60ef3082011-12-15 00:29:59 +00001002 else if (IDecl && !declaresSameEntity(IDecl->getSuperClass(), SDecl)) {
Chris Lattner4d391482007-12-12 07:09:47 +00001003 // This implementation and its interface do not have the same
1004 // super class.
Chris Lattner3c73c412008-11-19 08:23:25 +00001005 Diag(SuperClassLoc, diag::err_conflicting_super_class)
Chris Lattner08631c52008-11-23 21:45:46 +00001006 << SDecl->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001007 Diag(SDecl->getLocation(), diag::note_previous_definition);
Chris Lattner4d391482007-12-12 07:09:47 +00001008 }
1009 }
1010 }
Mike Stump1eb44332009-09-09 15:08:12 +00001011
Chris Lattner4d391482007-12-12 07:09:47 +00001012 if (!IDecl) {
1013 // Legacy case of @implementation with no corresponding @interface.
1014 // Build, chain & install the interface decl into the identifier.
Daniel Dunbarf6414922008-08-20 18:02:42 +00001015
Mike Stump390b4cc2009-05-16 07:39:55 +00001016 // FIXME: Do we support attributes on the @implementation? If so we should
1017 // copy them over.
Mike Stump1eb44332009-09-09 15:08:12 +00001018 IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassImplLoc,
Douglas Gregor0af55012011-12-16 03:12:41 +00001019 ClassName, /*PrevDecl=*/0, ClassLoc,
1020 true);
Douglas Gregor2e5c15b2011-12-15 05:27:12 +00001021 IDecl->startDefinition();
Douglas Gregor05c272f2011-12-15 22:34:59 +00001022 if (SDecl) {
1023 IDecl->setSuperClass(SDecl);
1024 IDecl->setSuperClassLoc(SuperClassLoc);
1025 IDecl->setEndOfDefinitionLoc(SuperClassLoc);
1026 } else {
1027 IDecl->setEndOfDefinitionLoc(ClassLoc);
1028 }
1029
Douglas Gregor8b9fb302009-04-24 00:16:12 +00001030 PushOnScopeChains(IDecl, TUScope);
Douglas Gregordeacbdc2010-08-11 12:19:30 +00001031 } else {
1032 // Mark the interface as being completed, even if it was just as
1033 // @class ....;
1034 // declaration; the user cannot reopen it.
Douglas Gregor2e5c15b2011-12-15 05:27:12 +00001035 if (!IDecl->hasDefinition())
1036 IDecl->startDefinition();
Chris Lattner4d391482007-12-12 07:09:47 +00001037 }
Mike Stump1eb44332009-09-09 15:08:12 +00001038
1039 ObjCImplementationDecl* IMPDecl =
Argyrios Kyrtzidis1711fc92011-10-04 04:48:02 +00001040 ObjCImplementationDecl::Create(Context, CurContext, IDecl, SDecl,
1041 ClassLoc, AtClassImplLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001042
Anders Carlsson15281452008-11-04 16:57:32 +00001043 if (CheckObjCDeclScope(IMPDecl))
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +00001044 return ActOnObjCContainerStartDefinition(IMPDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001045
Chris Lattner4d391482007-12-12 07:09:47 +00001046 // Check that there is no duplicate implementation of this class.
Douglas Gregordeacbdc2010-08-11 12:19:30 +00001047 if (IDecl->getImplementation()) {
1048 // FIXME: Don't leak everything!
Chris Lattner3c73c412008-11-19 08:23:25 +00001049 Diag(ClassLoc, diag::err_dup_implementation_class) << ClassName;
Argyrios Kyrtzidis87018772009-07-21 00:06:04 +00001050 Diag(IDecl->getImplementation()->getLocation(),
1051 diag::note_previous_definition);
Douglas Gregordeacbdc2010-08-11 12:19:30 +00001052 } else { // add it to the list.
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +00001053 IDecl->setImplementation(IMPDecl);
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001054 PushOnScopeChains(IMPDecl, TUScope);
Fariborz Jahanianb1224f62011-02-15 00:59:30 +00001055 // Warn on implementating deprecated class under
1056 // -Wdeprecated-implementations flag.
Fariborz Jahanian5ac96d52011-02-15 17:49:58 +00001057 DiagnoseObjCImplementedDeprecations(*this,
1058 dyn_cast<NamedDecl>(IDecl),
1059 IMPDecl->getLocation(), 1);
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +00001060 }
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +00001061 return ActOnObjCContainerStartDefinition(IMPDecl);
Chris Lattner4d391482007-12-12 07:09:47 +00001062}
1063
Argyrios Kyrtzidis644af7b2012-02-23 21:11:20 +00001064Sema::DeclGroupPtrTy
1065Sema::ActOnFinishObjCImplementation(Decl *ObjCImpDecl, ArrayRef<Decl *> Decls) {
1066 SmallVector<Decl *, 64> DeclsInGroup;
1067 DeclsInGroup.reserve(Decls.size() + 1);
1068
1069 for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
1070 Decl *Dcl = Decls[i];
1071 if (!Dcl)
1072 continue;
1073 if (Dcl->getDeclContext()->isFileContext())
1074 Dcl->setTopLevelDeclInObjCContainer();
1075 DeclsInGroup.push_back(Dcl);
1076 }
1077
1078 DeclsInGroup.push_back(ObjCImpDecl);
1079
1080 return BuildDeclaratorGroup(DeclsInGroup.data(), DeclsInGroup.size(), false);
1081}
1082
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001083void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
1084 ObjCIvarDecl **ivars, unsigned numIvars,
Chris Lattner4d391482007-12-12 07:09:47 +00001085 SourceLocation RBrace) {
1086 assert(ImpDecl && "missing implementation decl");
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001087 ObjCInterfaceDecl* IDecl = ImpDecl->getClassInterface();
Chris Lattner4d391482007-12-12 07:09:47 +00001088 if (!IDecl)
1089 return;
James Dennett1dfbd922012-06-14 21:40:34 +00001090 /// Check case of non-existing \@interface decl.
1091 /// (legacy objective-c \@implementation decl without an \@interface decl).
Chris Lattner4d391482007-12-12 07:09:47 +00001092 /// Add implementations's ivar to the synthesize class's ivar list.
Steve Naroff33feeb02009-04-20 20:09:33 +00001093 if (IDecl->isImplicitInterfaceDecl()) {
Douglas Gregor05c272f2011-12-15 22:34:59 +00001094 IDecl->setEndOfDefinitionLoc(RBrace);
Fariborz Jahanian3a21cd92010-02-17 17:00:07 +00001095 // Add ivar's to class's DeclContext.
1096 for (unsigned i = 0, e = numIvars; i != e; ++i) {
Fariborz Jahanian2f14c4d2010-02-17 18:10:54 +00001097 ivars[i]->setLexicalDeclContext(ImpDecl);
Richard Smith1b7f9cb2012-03-13 03:12:56 +00001098 IDecl->makeDeclVisibleInContext(ivars[i]);
Fariborz Jahanian11062e12010-02-19 00:31:17 +00001099 ImpDecl->addDecl(ivars[i]);
Fariborz Jahanian3a21cd92010-02-17 17:00:07 +00001100 }
1101
Chris Lattner4d391482007-12-12 07:09:47 +00001102 return;
1103 }
1104 // If implementation has empty ivar list, just return.
1105 if (numIvars == 0)
1106 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001107
Chris Lattner4d391482007-12-12 07:09:47 +00001108 assert(ivars && "missing @implementation ivars");
John McCall260611a2012-06-20 06:18:46 +00001109 if (LangOpts.ObjCRuntime.isNonFragile()) {
Fariborz Jahanianbd94d442010-02-19 20:58:54 +00001110 if (ImpDecl->getSuperClass())
1111 Diag(ImpDecl->getLocation(), diag::warn_on_superclass_use);
1112 for (unsigned i = 0; i < numIvars; i++) {
1113 ObjCIvarDecl* ImplIvar = ivars[i];
1114 if (const ObjCIvarDecl *ClsIvar =
1115 IDecl->getIvarDecl(ImplIvar->getIdentifier())) {
1116 Diag(ImplIvar->getLocation(), diag::err_duplicate_ivar_declaration);
1117 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
1118 continue;
1119 }
Fariborz Jahanianbd94d442010-02-19 20:58:54 +00001120 // Instance ivar to Implementation's DeclContext.
1121 ImplIvar->setLexicalDeclContext(ImpDecl);
Richard Smith1b7f9cb2012-03-13 03:12:56 +00001122 IDecl->makeDeclVisibleInContext(ImplIvar);
Fariborz Jahanianbd94d442010-02-19 20:58:54 +00001123 ImpDecl->addDecl(ImplIvar);
1124 }
1125 return;
1126 }
Chris Lattner4d391482007-12-12 07:09:47 +00001127 // Check interface's Ivar list against those in the implementation.
1128 // names and types must match.
1129 //
Chris Lattner4d391482007-12-12 07:09:47 +00001130 unsigned j = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001131 ObjCInterfaceDecl::ivar_iterator
Chris Lattner4c525092007-12-12 17:58:05 +00001132 IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end();
1133 for (; numIvars > 0 && IVI != IVE; ++IVI) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001134 ObjCIvarDecl* ImplIvar = ivars[j++];
David Blaikie581deb32012-06-06 20:45:41 +00001135 ObjCIvarDecl* ClsIvar = *IVI;
Chris Lattner4d391482007-12-12 07:09:47 +00001136 assert (ImplIvar && "missing implementation ivar");
1137 assert (ClsIvar && "missing class ivar");
Mike Stump1eb44332009-09-09 15:08:12 +00001138
Steve Naroffca331292009-03-03 14:49:36 +00001139 // First, make sure the types match.
Richard Smitha6b8b2c2011-10-10 18:28:20 +00001140 if (!Context.hasSameType(ImplIvar->getType(), ClsIvar->getType())) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001141 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type)
Chris Lattner08631c52008-11-23 21:45:46 +00001142 << ImplIvar->getIdentifier()
1143 << ImplIvar->getType() << ClsIvar->getType();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001144 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
Richard Smitha6b8b2c2011-10-10 18:28:20 +00001145 } else if (ImplIvar->isBitField() && ClsIvar->isBitField() &&
1146 ImplIvar->getBitWidthValue(Context) !=
1147 ClsIvar->getBitWidthValue(Context)) {
1148 Diag(ImplIvar->getBitWidth()->getLocStart(),
1149 diag::err_conflicting_ivar_bitwidth) << ImplIvar->getIdentifier();
1150 Diag(ClsIvar->getBitWidth()->getLocStart(),
1151 diag::note_previous_definition);
Mike Stump1eb44332009-09-09 15:08:12 +00001152 }
Steve Naroffca331292009-03-03 14:49:36 +00001153 // Make sure the names are identical.
1154 if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001155 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name)
Chris Lattner08631c52008-11-23 21:45:46 +00001156 << ImplIvar->getIdentifier() << ClsIvar->getIdentifier();
Chris Lattner5f4a6822008-11-23 23:12:31 +00001157 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
Chris Lattner4d391482007-12-12 07:09:47 +00001158 }
1159 --numIvars;
Chris Lattner4d391482007-12-12 07:09:47 +00001160 }
Mike Stump1eb44332009-09-09 15:08:12 +00001161
Chris Lattner609e4c72007-12-12 18:11:49 +00001162 if (numIvars > 0)
Chris Lattner0e391052007-12-12 18:19:52 +00001163 Diag(ivars[j]->getLocation(), diag::err_inconsistant_ivar_count);
Chris Lattner609e4c72007-12-12 18:11:49 +00001164 else if (IVI != IVE)
David Blaikie262bc182012-04-30 02:36:29 +00001165 Diag(IVI->getLocation(), diag::err_inconsistant_ivar_count);
Chris Lattner4d391482007-12-12 07:09:47 +00001166}
1167
Steve Naroff3c2eb662008-02-10 21:38:56 +00001168void Sema::WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
Fariborz Jahanian52146832010-03-31 18:23:33 +00001169 bool &IncompleteImpl, unsigned DiagID) {
Fariborz Jahanian327126e2011-06-24 20:31:37 +00001170 // No point warning no definition of method which is 'unavailable'.
1171 if (method->hasAttr<UnavailableAttr>())
1172 return;
Steve Naroff3c2eb662008-02-10 21:38:56 +00001173 if (!IncompleteImpl) {
1174 Diag(ImpLoc, diag::warn_incomplete_impl);
1175 IncompleteImpl = true;
1176 }
Fariborz Jahanian61c8d3e2010-10-29 23:20:05 +00001177 if (DiagID == diag::warn_unimplemented_protocol_method)
1178 Diag(ImpLoc, DiagID) << method->getDeclName();
1179 else
1180 Diag(method->getLocation(), DiagID) << method->getDeclName();
Steve Naroff3c2eb662008-02-10 21:38:56 +00001181}
1182
David Chisnalle8a2d4c2010-10-25 17:23:52 +00001183/// Determines if type B can be substituted for type A. Returns true if we can
1184/// guarantee that anything that the user will do to an object of type A can
1185/// also be done to an object of type B. This is trivially true if the two
1186/// types are the same, or if B is a subclass of A. It becomes more complex
1187/// in cases where protocols are involved.
1188///
1189/// Object types in Objective-C describe the minimum requirements for an
1190/// object, rather than providing a complete description of a type. For
1191/// example, if A is a subclass of B, then B* may refer to an instance of A.
1192/// The principle of substitutability means that we may use an instance of A
1193/// anywhere that we may use an instance of B - it will implement all of the
1194/// ivars of B and all of the methods of B.
1195///
1196/// This substitutability is important when type checking methods, because
1197/// the implementation may have stricter type definitions than the interface.
1198/// The interface specifies minimum requirements, but the implementation may
1199/// have more accurate ones. For example, a method may privately accept
1200/// instances of B, but only publish that it accepts instances of A. Any
1201/// object passed to it will be type checked against B, and so will implicitly
1202/// by a valid A*. Similarly, a method may return a subclass of the class that
1203/// it is declared as returning.
1204///
1205/// This is most important when considering subclassing. A method in a
1206/// subclass must accept any object as an argument that its superclass's
1207/// implementation accepts. It may, however, accept a more general type
1208/// without breaking substitutability (i.e. you can still use the subclass
1209/// anywhere that you can use the superclass, but not vice versa). The
1210/// converse requirement applies to return types: the return type for a
1211/// subclass method must be a valid object of the kind that the superclass
1212/// advertises, but it may be specified more accurately. This avoids the need
1213/// for explicit down-casting by callers.
1214///
1215/// Note: This is a stricter requirement than for assignment.
John McCall10302c02010-10-28 02:34:38 +00001216static bool isObjCTypeSubstitutable(ASTContext &Context,
1217 const ObjCObjectPointerType *A,
1218 const ObjCObjectPointerType *B,
1219 bool rejectId) {
1220 // Reject a protocol-unqualified id.
1221 if (rejectId && B->isObjCIdType()) return false;
David Chisnalle8a2d4c2010-10-25 17:23:52 +00001222
1223 // If B is a qualified id, then A must also be a qualified id and it must
1224 // implement all of the protocols in B. It may not be a qualified class.
1225 // For example, MyClass<A> can be assigned to id<A>, but MyClass<A> is a
1226 // stricter definition so it is not substitutable for id<A>.
1227 if (B->isObjCQualifiedIdType()) {
1228 return A->isObjCQualifiedIdType() &&
John McCall10302c02010-10-28 02:34:38 +00001229 Context.ObjCQualifiedIdTypesAreCompatible(QualType(A, 0),
1230 QualType(B,0),
1231 false);
David Chisnalle8a2d4c2010-10-25 17:23:52 +00001232 }
1233
1234 /*
1235 // id is a special type that bypasses type checking completely. We want a
1236 // warning when it is used in one place but not another.
1237 if (C.isObjCIdType(A) || C.isObjCIdType(B)) return false;
1238
1239
1240 // If B is a qualified id, then A must also be a qualified id (which it isn't
1241 // if we've got this far)
1242 if (B->isObjCQualifiedIdType()) return false;
1243 */
1244
1245 // Now we know that A and B are (potentially-qualified) class types. The
1246 // normal rules for assignment apply.
John McCall10302c02010-10-28 02:34:38 +00001247 return Context.canAssignObjCInterfaces(A, B);
David Chisnalle8a2d4c2010-10-25 17:23:52 +00001248}
1249
John McCall10302c02010-10-28 02:34:38 +00001250static SourceRange getTypeRange(TypeSourceInfo *TSI) {
1251 return (TSI ? TSI->getTypeLoc().getSourceRange() : SourceRange());
1252}
1253
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001254static bool CheckMethodOverrideReturn(Sema &S,
John McCall10302c02010-10-28 02:34:38 +00001255 ObjCMethodDecl *MethodImpl,
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001256 ObjCMethodDecl *MethodDecl,
Fariborz Jahanianeee3ef12011-07-24 20:53:26 +00001257 bool IsProtocolMethodDecl,
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001258 bool IsOverridingMode,
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001259 bool Warn) {
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001260 if (IsProtocolMethodDecl &&
1261 (MethodDecl->getObjCDeclQualifier() !=
1262 MethodImpl->getObjCDeclQualifier())) {
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001263 if (Warn) {
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001264 S.Diag(MethodImpl->getLocation(),
1265 (IsOverridingMode ?
1266 diag::warn_conflicting_overriding_ret_type_modifiers
1267 : diag::warn_conflicting_ret_type_modifiers))
1268 << MethodImpl->getDeclName()
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001269 << getTypeRange(MethodImpl->getResultTypeSourceInfo());
1270 S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration)
1271 << getTypeRange(MethodDecl->getResultTypeSourceInfo());
1272 }
1273 else
1274 return false;
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001275 }
1276
John McCall10302c02010-10-28 02:34:38 +00001277 if (S.Context.hasSameUnqualifiedType(MethodImpl->getResultType(),
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001278 MethodDecl->getResultType()))
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001279 return true;
1280 if (!Warn)
1281 return false;
John McCall10302c02010-10-28 02:34:38 +00001282
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001283 unsigned DiagID =
1284 IsOverridingMode ? diag::warn_conflicting_overriding_ret_types
1285 : diag::warn_conflicting_ret_types;
John McCall10302c02010-10-28 02:34:38 +00001286
1287 // Mismatches between ObjC pointers go into a different warning
1288 // category, and sometimes they're even completely whitelisted.
1289 if (const ObjCObjectPointerType *ImplPtrTy =
1290 MethodImpl->getResultType()->getAs<ObjCObjectPointerType>()) {
1291 if (const ObjCObjectPointerType *IfacePtrTy =
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001292 MethodDecl->getResultType()->getAs<ObjCObjectPointerType>()) {
John McCall10302c02010-10-28 02:34:38 +00001293 // Allow non-matching return types as long as they don't violate
1294 // the principle of substitutability. Specifically, we permit
1295 // return types that are subclasses of the declared return type,
1296 // or that are more-qualified versions of the declared type.
1297 if (isObjCTypeSubstitutable(S.Context, IfacePtrTy, ImplPtrTy, false))
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001298 return false;
John McCall10302c02010-10-28 02:34:38 +00001299
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001300 DiagID =
1301 IsOverridingMode ? diag::warn_non_covariant_overriding_ret_types
1302 : diag::warn_non_covariant_ret_types;
John McCall10302c02010-10-28 02:34:38 +00001303 }
1304 }
1305
1306 S.Diag(MethodImpl->getLocation(), DiagID)
1307 << MethodImpl->getDeclName()
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001308 << MethodDecl->getResultType()
John McCall10302c02010-10-28 02:34:38 +00001309 << MethodImpl->getResultType()
1310 << getTypeRange(MethodImpl->getResultTypeSourceInfo());
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001311 S.Diag(MethodDecl->getLocation(),
1312 IsOverridingMode ? diag::note_previous_declaration
1313 : diag::note_previous_definition)
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001314 << getTypeRange(MethodDecl->getResultTypeSourceInfo());
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001315 return false;
John McCall10302c02010-10-28 02:34:38 +00001316}
1317
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001318static bool CheckMethodOverrideParam(Sema &S,
John McCall10302c02010-10-28 02:34:38 +00001319 ObjCMethodDecl *MethodImpl,
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001320 ObjCMethodDecl *MethodDecl,
John McCall10302c02010-10-28 02:34:38 +00001321 ParmVarDecl *ImplVar,
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001322 ParmVarDecl *IfaceVar,
Fariborz Jahanianeee3ef12011-07-24 20:53:26 +00001323 bool IsProtocolMethodDecl,
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001324 bool IsOverridingMode,
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001325 bool Warn) {
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001326 if (IsProtocolMethodDecl &&
1327 (ImplVar->getObjCDeclQualifier() !=
1328 IfaceVar->getObjCDeclQualifier())) {
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001329 if (Warn) {
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001330 if (IsOverridingMode)
1331 S.Diag(ImplVar->getLocation(),
1332 diag::warn_conflicting_overriding_param_modifiers)
1333 << getTypeRange(ImplVar->getTypeSourceInfo())
1334 << MethodImpl->getDeclName();
1335 else S.Diag(ImplVar->getLocation(),
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001336 diag::warn_conflicting_param_modifiers)
1337 << getTypeRange(ImplVar->getTypeSourceInfo())
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001338 << MethodImpl->getDeclName();
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001339 S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration)
1340 << getTypeRange(IfaceVar->getTypeSourceInfo());
1341 }
1342 else
1343 return false;
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001344 }
1345
John McCall10302c02010-10-28 02:34:38 +00001346 QualType ImplTy = ImplVar->getType();
1347 QualType IfaceTy = IfaceVar->getType();
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001348
John McCall10302c02010-10-28 02:34:38 +00001349 if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy))
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001350 return true;
1351
1352 if (!Warn)
1353 return false;
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001354 unsigned DiagID =
1355 IsOverridingMode ? diag::warn_conflicting_overriding_param_types
1356 : diag::warn_conflicting_param_types;
John McCall10302c02010-10-28 02:34:38 +00001357
1358 // Mismatches between ObjC pointers go into a different warning
1359 // category, and sometimes they're even completely whitelisted.
1360 if (const ObjCObjectPointerType *ImplPtrTy =
1361 ImplTy->getAs<ObjCObjectPointerType>()) {
1362 if (const ObjCObjectPointerType *IfacePtrTy =
1363 IfaceTy->getAs<ObjCObjectPointerType>()) {
1364 // Allow non-matching argument types as long as they don't
1365 // violate the principle of substitutability. Specifically, the
1366 // implementation must accept any objects that the superclass
1367 // accepts, however it may also accept others.
1368 if (isObjCTypeSubstitutable(S.Context, ImplPtrTy, IfacePtrTy, true))
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001369 return false;
John McCall10302c02010-10-28 02:34:38 +00001370
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001371 DiagID =
1372 IsOverridingMode ? diag::warn_non_contravariant_overriding_param_types
1373 : diag::warn_non_contravariant_param_types;
John McCall10302c02010-10-28 02:34:38 +00001374 }
1375 }
1376
1377 S.Diag(ImplVar->getLocation(), DiagID)
1378 << getTypeRange(ImplVar->getTypeSourceInfo())
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001379 << MethodImpl->getDeclName() << IfaceTy << ImplTy;
1380 S.Diag(IfaceVar->getLocation(),
1381 (IsOverridingMode ? diag::note_previous_declaration
1382 : diag::note_previous_definition))
John McCall10302c02010-10-28 02:34:38 +00001383 << getTypeRange(IfaceVar->getTypeSourceInfo());
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001384 return false;
John McCall10302c02010-10-28 02:34:38 +00001385}
John McCallf85e1932011-06-15 23:02:42 +00001386
1387/// In ARC, check whether the conventional meanings of the two methods
1388/// match. If they don't, it's a hard error.
1389static bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl,
1390 ObjCMethodDecl *decl) {
1391 ObjCMethodFamily implFamily = impl->getMethodFamily();
1392 ObjCMethodFamily declFamily = decl->getMethodFamily();
1393 if (implFamily == declFamily) return false;
1394
1395 // Since conventions are sorted by selector, the only possibility is
1396 // that the types differ enough to cause one selector or the other
1397 // to fall out of the family.
1398 assert(implFamily == OMF_None || declFamily == OMF_None);
1399
1400 // No further diagnostics required on invalid declarations.
1401 if (impl->isInvalidDecl() || decl->isInvalidDecl()) return true;
1402
1403 const ObjCMethodDecl *unmatched = impl;
1404 ObjCMethodFamily family = declFamily;
1405 unsigned errorID = diag::err_arc_lost_method_convention;
1406 unsigned noteID = diag::note_arc_lost_method_convention;
1407 if (declFamily == OMF_None) {
1408 unmatched = decl;
1409 family = implFamily;
1410 errorID = diag::err_arc_gained_method_convention;
1411 noteID = diag::note_arc_gained_method_convention;
1412 }
1413
1414 // Indexes into a %select clause in the diagnostic.
1415 enum FamilySelector {
1416 F_alloc, F_copy, F_mutableCopy = F_copy, F_init, F_new
1417 };
1418 FamilySelector familySelector = FamilySelector();
1419
1420 switch (family) {
1421 case OMF_None: llvm_unreachable("logic error, no method convention");
1422 case OMF_retain:
1423 case OMF_release:
1424 case OMF_autorelease:
1425 case OMF_dealloc:
Nico Weber80cb6e62011-08-28 22:35:17 +00001426 case OMF_finalize:
John McCallf85e1932011-06-15 23:02:42 +00001427 case OMF_retainCount:
1428 case OMF_self:
Fariborz Jahanian9670e172011-07-05 22:38:59 +00001429 case OMF_performSelector:
John McCallf85e1932011-06-15 23:02:42 +00001430 // Mismatches for these methods don't change ownership
1431 // conventions, so we don't care.
1432 return false;
1433
1434 case OMF_init: familySelector = F_init; break;
1435 case OMF_alloc: familySelector = F_alloc; break;
1436 case OMF_copy: familySelector = F_copy; break;
1437 case OMF_mutableCopy: familySelector = F_mutableCopy; break;
1438 case OMF_new: familySelector = F_new; break;
1439 }
1440
1441 enum ReasonSelector { R_NonObjectReturn, R_UnrelatedReturn };
1442 ReasonSelector reasonSelector;
1443
1444 // The only reason these methods don't fall within their families is
1445 // due to unusual result types.
1446 if (unmatched->getResultType()->isObjCObjectPointerType()) {
1447 reasonSelector = R_UnrelatedReturn;
1448 } else {
1449 reasonSelector = R_NonObjectReturn;
1450 }
1451
1452 S.Diag(impl->getLocation(), errorID) << familySelector << reasonSelector;
1453 S.Diag(decl->getLocation(), noteID) << familySelector << reasonSelector;
1454
1455 return true;
1456}
John McCall10302c02010-10-28 02:34:38 +00001457
Fariborz Jahanian8daab972008-12-05 18:18:52 +00001458void Sema::WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethodDecl,
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001459 ObjCMethodDecl *MethodDecl,
Fariborz Jahanian36bc2c62011-10-10 17:53:29 +00001460 bool IsProtocolMethodDecl) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001461 if (getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00001462 checkMethodFamilyMismatch(*this, ImpMethodDecl, MethodDecl))
1463 return;
1464
Fariborz Jahanian21761c82011-02-21 23:49:15 +00001465 CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl,
Fariborz Jahanian36bc2c62011-10-10 17:53:29 +00001466 IsProtocolMethodDecl, false,
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001467 true);
Mike Stump1eb44332009-09-09 15:08:12 +00001468
Chris Lattner3aff9192009-04-11 19:58:42 +00001469 for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
Douglas Gregor0a4a23a2012-05-17 23:13:29 +00001470 IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
1471 EF = MethodDecl->param_end();
1472 IM != EM && IF != EF; ++IM, ++IF) {
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001473 CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl, *IM, *IF,
Fariborz Jahanian36bc2c62011-10-10 17:53:29 +00001474 IsProtocolMethodDecl, false, true);
Fariborz Jahanian21121902011-08-08 18:03:17 +00001475 }
Fariborz Jahanian730cfb12011-08-10 17:16:30 +00001476
Fariborz Jahanian21121902011-08-08 18:03:17 +00001477 if (ImpMethodDecl->isVariadic() != MethodDecl->isVariadic()) {
Fariborz Jahanian36bc2c62011-10-10 17:53:29 +00001478 Diag(ImpMethodDecl->getLocation(),
1479 diag::warn_conflicting_variadic);
Fariborz Jahanian21121902011-08-08 18:03:17 +00001480 Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
Fariborz Jahanian21121902011-08-08 18:03:17 +00001481 }
Fariborz Jahanian21121902011-08-08 18:03:17 +00001482}
1483
Fariborz Jahanian36bc2c62011-10-10 17:53:29 +00001484void Sema::CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
1485 ObjCMethodDecl *Overridden,
1486 bool IsProtocolMethodDecl) {
1487
1488 CheckMethodOverrideReturn(*this, Method, Overridden,
1489 IsProtocolMethodDecl, true,
1490 true);
1491
1492 for (ObjCMethodDecl::param_iterator IM = Method->param_begin(),
Douglas Gregor0a4a23a2012-05-17 23:13:29 +00001493 IF = Overridden->param_begin(), EM = Method->param_end(),
1494 EF = Overridden->param_end();
1495 IM != EM && IF != EF; ++IM, ++IF) {
Fariborz Jahanian36bc2c62011-10-10 17:53:29 +00001496 CheckMethodOverrideParam(*this, Method, Overridden, *IM, *IF,
1497 IsProtocolMethodDecl, true, true);
1498 }
1499
1500 if (Method->isVariadic() != Overridden->isVariadic()) {
1501 Diag(Method->getLocation(),
1502 diag::warn_conflicting_overriding_variadic);
1503 Diag(Overridden->getLocation(), diag::note_previous_declaration);
1504 }
1505}
1506
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001507/// WarnExactTypedMethods - This routine issues a warning if method
1508/// implementation declaration matches exactly that of its declaration.
1509void Sema::WarnExactTypedMethods(ObjCMethodDecl *ImpMethodDecl,
1510 ObjCMethodDecl *MethodDecl,
1511 bool IsProtocolMethodDecl) {
1512 // don't issue warning when protocol method is optional because primary
1513 // class is not required to implement it and it is safe for protocol
1514 // to implement it.
1515 if (MethodDecl->getImplementationControl() == ObjCMethodDecl::Optional)
1516 return;
1517 // don't issue warning when primary class's method is
1518 // depecated/unavailable.
1519 if (MethodDecl->hasAttr<UnavailableAttr>() ||
1520 MethodDecl->hasAttr<DeprecatedAttr>())
1521 return;
1522
1523 bool match = CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl,
1524 IsProtocolMethodDecl, false, false);
1525 if (match)
1526 for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
Douglas Gregor0a4a23a2012-05-17 23:13:29 +00001527 IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
1528 EF = MethodDecl->param_end();
1529 IM != EM && IF != EF; ++IM, ++IF) {
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001530 match = CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl,
1531 *IM, *IF,
1532 IsProtocolMethodDecl, false, false);
1533 if (!match)
1534 break;
1535 }
1536 if (match)
1537 match = (ImpMethodDecl->isVariadic() == MethodDecl->isVariadic());
David Chisnall7ca13ef2011-08-08 17:32:19 +00001538 if (match)
1539 match = !(MethodDecl->isClassMethod() &&
1540 MethodDecl->getSelector() == GetNullarySelector("load", Context));
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001541
1542 if (match) {
1543 Diag(ImpMethodDecl->getLocation(),
1544 diag::warn_category_method_impl_match);
Ted Kremenek3306ec12012-02-27 22:55:11 +00001545 Diag(MethodDecl->getLocation(), diag::note_method_declared_at)
1546 << MethodDecl->getDeclName();
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001547 }
1548}
1549
Mike Stump390b4cc2009-05-16 07:39:55 +00001550/// FIXME: Type hierarchies in Objective-C can be deep. We could most likely
1551/// improve the efficiency of selector lookups and type checking by associating
1552/// with each protocol / interface / category the flattened instance tables. If
1553/// we used an immutable set to keep the table then it wouldn't add significant
1554/// memory cost and it would be handy for lookups.
Daniel Dunbarb20ef3e2008-08-27 05:40:03 +00001555
Steve Naroffefe7f362008-02-08 22:06:17 +00001556/// CheckProtocolMethodDefs - This routine checks unimplemented methods
Chris Lattner4d391482007-12-12 07:09:47 +00001557/// Declared in protocol, and those referenced by it.
Steve Naroffefe7f362008-02-08 22:06:17 +00001558void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc,
1559 ObjCProtocolDecl *PDecl,
Chris Lattner4d391482007-12-12 07:09:47 +00001560 bool& IncompleteImpl,
Benjamin Kramer811bfcd2012-05-27 13:28:52 +00001561 const SelectorSet &InsMap,
1562 const SelectorSet &ClsMap,
Fariborz Jahanianf2838592010-03-27 21:10:05 +00001563 ObjCContainerDecl *CDecl) {
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001564 ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl);
1565 ObjCInterfaceDecl *IDecl = C ? C->getClassInterface()
1566 : dyn_cast<ObjCInterfaceDecl>(CDecl);
Fariborz Jahanianf2838592010-03-27 21:10:05 +00001567 assert (IDecl && "CheckProtocolMethodDefs - IDecl is null");
1568
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001569 ObjCInterfaceDecl *Super = IDecl->getSuperClass();
Fariborz Jahaniancd187622009-05-22 17:12:32 +00001570 ObjCInterfaceDecl *NSIDecl = 0;
John McCall260611a2012-06-20 06:18:46 +00001571 if (getLangOpts().ObjCRuntime.isNeXTFamily()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001572 // check to see if class implements forwardInvocation method and objects
1573 // of this class are derived from 'NSProxy' so that to forward requests
Fariborz Jahaniancd187622009-05-22 17:12:32 +00001574 // from one object to another.
Mike Stump1eb44332009-09-09 15:08:12 +00001575 // Under such conditions, which means that every method possible is
1576 // implemented in the class, we should not issue "Method definition not
Fariborz Jahaniancd187622009-05-22 17:12:32 +00001577 // found" warnings.
1578 // FIXME: Use a general GetUnarySelector method for this.
1579 IdentifierInfo* II = &Context.Idents.get("forwardInvocation");
1580 Selector fISelector = Context.Selectors.getSelector(1, &II);
1581 if (InsMap.count(fISelector))
1582 // Is IDecl derived from 'NSProxy'? If so, no instance methods
1583 // need be implemented in the implementation.
1584 NSIDecl = IDecl->lookupInheritedClass(&Context.Idents.get("NSProxy"));
1585 }
Mike Stump1eb44332009-09-09 15:08:12 +00001586
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001587 // If a method lookup fails locally we still need to look and see if
1588 // the method was implemented by a base class or an inherited
1589 // protocol. This lookup is slow, but occurs rarely in correct code
1590 // and otherwise would terminate in a warning.
1591
Chris Lattner4d391482007-12-12 07:09:47 +00001592 // check unimplemented instance methods.
Fariborz Jahaniancd187622009-05-22 17:12:32 +00001593 if (!NSIDecl)
Mike Stump1eb44332009-09-09 15:08:12 +00001594 for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001595 E = PDecl->instmeth_end(); I != E; ++I) {
Fariborz Jahaniancd187622009-05-22 17:12:32 +00001596 ObjCMethodDecl *method = *I;
Mike Stump1eb44332009-09-09 15:08:12 +00001597 if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
Jordan Rose1e4691b2012-10-10 16:42:25 +00001598 !method->isPropertyAccessor() &&
1599 !InsMap.count(method->getSelector()) &&
1600 (!Super || !Super->lookupInstanceMethod(method->getSelector()))) {
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001601 // If a method is not implemented in the category implementation but
1602 // has been declared in its primary class, superclass,
1603 // or in one of their protocols, no need to issue the warning.
1604 // This is because method will be implemented in the primary class
1605 // or one of its super class implementation.
1606
Fariborz Jahaniancd187622009-05-22 17:12:32 +00001607 // Ugly, but necessary. Method declared in protcol might have
1608 // have been synthesized due to a property declared in the class which
1609 // uses the protocol.
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001610 if (ObjCMethodDecl *MethodInClass =
1611 IDecl->lookupInstanceMethod(method->getSelector(),
Fariborz Jahanianbf393be2012-04-05 22:14:12 +00001612 true /*shallowCategoryLookup*/))
Jordan Rose1e4691b2012-10-10 16:42:25 +00001613 if (C || MethodInClass->isPropertyAccessor())
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001614 continue;
1615 unsigned DIAG = diag::warn_unimplemented_protocol_method;
1616 if (Diags.getDiagnosticLevel(DIAG, ImpLoc)
1617 != DiagnosticsEngine::Ignored) {
1618 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl, DIAG);
Ted Kremenek3306ec12012-02-27 22:55:11 +00001619 Diag(method->getLocation(), diag::note_method_declared_at)
1620 << method->getDeclName();
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001621 Diag(CDecl->getLocation(), diag::note_required_for_protocol_at)
1622 << PDecl->getDeclName();
Fariborz Jahanian8822f7c2010-03-27 19:02:17 +00001623 }
Fariborz Jahaniancd187622009-05-22 17:12:32 +00001624 }
1625 }
Chris Lattner4d391482007-12-12 07:09:47 +00001626 // check unimplemented class methods
Mike Stump1eb44332009-09-09 15:08:12 +00001627 for (ObjCProtocolDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001628 I = PDecl->classmeth_begin(), E = PDecl->classmeth_end();
Douglas Gregor6ab35242009-04-09 21:40:53 +00001629 I != E; ++I) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001630 ObjCMethodDecl *method = *I;
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001631 if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
1632 !ClsMap.count(method->getSelector()) &&
Fariborz Jahanian8822f7c2010-03-27 19:02:17 +00001633 (!Super || !Super->lookupClassMethod(method->getSelector()))) {
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001634 // See above comment for instance method lookups.
1635 if (C && IDecl->lookupClassMethod(method->getSelector(),
Fariborz Jahanianbf393be2012-04-05 22:14:12 +00001636 true /*shallowCategoryLookup*/))
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001637 continue;
Fariborz Jahanian52146832010-03-31 18:23:33 +00001638 unsigned DIAG = diag::warn_unimplemented_protocol_method;
David Blaikied6471f72011-09-25 23:23:43 +00001639 if (Diags.getDiagnosticLevel(DIAG, ImpLoc) !=
1640 DiagnosticsEngine::Ignored) {
Fariborz Jahanian52146832010-03-31 18:23:33 +00001641 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl, DIAG);
Ted Kremenek3306ec12012-02-27 22:55:11 +00001642 Diag(method->getLocation(), diag::note_method_declared_at)
1643 << method->getDeclName();
Fariborz Jahanian52146832010-03-31 18:23:33 +00001644 Diag(IDecl->getLocation(), diag::note_required_for_protocol_at) <<
1645 PDecl->getDeclName();
1646 }
Fariborz Jahanian8822f7c2010-03-27 19:02:17 +00001647 }
Steve Naroff58dbdeb2007-12-14 23:37:57 +00001648 }
Chris Lattner780f3292008-07-21 21:32:27 +00001649 // Check on this protocols's referenced protocols, recursively.
1650 for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(),
1651 E = PDecl->protocol_end(); PI != E; ++PI)
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001652 CheckProtocolMethodDefs(ImpLoc, *PI, IncompleteImpl, InsMap, ClsMap, CDecl);
Chris Lattner4d391482007-12-12 07:09:47 +00001653}
1654
Fariborz Jahanian1e159bc2011-07-16 00:08:33 +00001655/// MatchAllMethodDeclarations - Check methods declared in interface
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001656/// or protocol against those declared in their implementations.
1657///
Benjamin Kramer811bfcd2012-05-27 13:28:52 +00001658void Sema::MatchAllMethodDeclarations(const SelectorSet &InsMap,
1659 const SelectorSet &ClsMap,
1660 SelectorSet &InsMapSeen,
1661 SelectorSet &ClsMapSeen,
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001662 ObjCImplDecl* IMPDecl,
1663 ObjCContainerDecl* CDecl,
1664 bool &IncompleteImpl,
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001665 bool ImmediateClass,
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001666 bool WarnCategoryMethodImpl) {
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001667 // Check and see if instance methods in class interface have been
1668 // implemented in the implementation class. If so, their types match.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001669 for (ObjCInterfaceDecl::instmeth_iterator I = CDecl->instmeth_begin(),
1670 E = CDecl->instmeth_end(); I != E; ++I) {
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001671 if (InsMapSeen.count((*I)->getSelector()))
1672 continue;
1673 InsMapSeen.insert((*I)->getSelector());
Jordan Rose1e4691b2012-10-10 16:42:25 +00001674 if (!(*I)->isPropertyAccessor() &&
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001675 !InsMap.count((*I)->getSelector())) {
1676 if (ImmediateClass)
Fariborz Jahanian52146832010-03-31 18:23:33 +00001677 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl,
1678 diag::note_undef_method_impl);
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001679 continue;
Mike Stumpac5fc7c2009-08-04 21:02:39 +00001680 } else {
Mike Stump1eb44332009-09-09 15:08:12 +00001681 ObjCMethodDecl *ImpMethodDecl =
Argyrios Kyrtzidis2334f3a2011-08-30 19:43:21 +00001682 IMPDecl->getInstanceMethod((*I)->getSelector());
1683 assert(CDecl->getInstanceMethod((*I)->getSelector()) &&
1684 "Expected to find the method through lookup as well");
1685 ObjCMethodDecl *MethodDecl = *I;
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001686 // ImpMethodDecl may be null as in a @dynamic property.
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001687 if (ImpMethodDecl) {
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001688 if (!WarnCategoryMethodImpl)
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001689 WarnConflictingTypedMethods(ImpMethodDecl, MethodDecl,
1690 isa<ObjCProtocolDecl>(CDecl));
Jordan Rose1e4691b2012-10-10 16:42:25 +00001691 else if (!MethodDecl->isPropertyAccessor())
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001692 WarnExactTypedMethods(ImpMethodDecl, MethodDecl,
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001693 isa<ObjCProtocolDecl>(CDecl));
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001694 }
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001695 }
1696 }
Mike Stump1eb44332009-09-09 15:08:12 +00001697
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001698 // Check and see if class methods in class interface have been
1699 // implemented in the implementation class. If so, their types match.
Mike Stump1eb44332009-09-09 15:08:12 +00001700 for (ObjCInterfaceDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001701 I = CDecl->classmeth_begin(), E = CDecl->classmeth_end(); I != E; ++I) {
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001702 if (ClsMapSeen.count((*I)->getSelector()))
1703 continue;
1704 ClsMapSeen.insert((*I)->getSelector());
1705 if (!ClsMap.count((*I)->getSelector())) {
1706 if (ImmediateClass)
Fariborz Jahanian52146832010-03-31 18:23:33 +00001707 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl,
1708 diag::note_undef_method_impl);
Mike Stumpac5fc7c2009-08-04 21:02:39 +00001709 } else {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001710 ObjCMethodDecl *ImpMethodDecl =
1711 IMPDecl->getClassMethod((*I)->getSelector());
Argyrios Kyrtzidis2334f3a2011-08-30 19:43:21 +00001712 assert(CDecl->getClassMethod((*I)->getSelector()) &&
1713 "Expected to find the method through lookup as well");
1714 ObjCMethodDecl *MethodDecl = *I;
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001715 if (!WarnCategoryMethodImpl)
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001716 WarnConflictingTypedMethods(ImpMethodDecl, MethodDecl,
1717 isa<ObjCProtocolDecl>(CDecl));
1718 else
1719 WarnExactTypedMethods(ImpMethodDecl, MethodDecl,
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001720 isa<ObjCProtocolDecl>(CDecl));
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001721 }
1722 }
Fariborz Jahanianf54e3ae2010-10-08 22:59:25 +00001723
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001724 if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
Fariborz Jahanian6a6bb282012-10-23 23:06:22 +00001725 // when checking that methods in implementation match their declaration,
1726 // i.e. when WarnCategoryMethodImpl is false, check declarations in class
1727 // extension; as well as those in categories.
1728 if (!WarnCategoryMethodImpl)
1729 for (const ObjCCategoryDecl *CDeclChain = I->getCategoryList();
1730 CDeclChain; CDeclChain = CDeclChain->getNextClassCategory())
1731 MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1732 IMPDecl,
1733 const_cast<ObjCCategoryDecl *>(CDeclChain),
1734 IncompleteImpl, false,
1735 WarnCategoryMethodImpl);
1736 else
1737 // Also methods in class extensions need be looked at next.
1738 for (const ObjCCategoryDecl *ClsExtDecl = I->getFirstClassExtension();
1739 ClsExtDecl; ClsExtDecl = ClsExtDecl->getNextClassExtension())
1740 MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1741 IMPDecl,
1742 const_cast<ObjCCategoryDecl *>(ClsExtDecl),
1743 IncompleteImpl, false,
1744 WarnCategoryMethodImpl);
Fariborz Jahanianf54e3ae2010-10-08 22:59:25 +00001745
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001746 // Check for any implementation of a methods declared in protocol.
Ted Kremenek53b94412010-09-01 01:21:15 +00001747 for (ObjCInterfaceDecl::all_protocol_iterator
1748 PI = I->all_referenced_protocol_begin(),
1749 E = I->all_referenced_protocol_end(); PI != E; ++PI)
Mike Stump1eb44332009-09-09 15:08:12 +00001750 MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1751 IMPDecl,
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001752 (*PI), IncompleteImpl, false,
1753 WarnCategoryMethodImpl);
Fariborz Jahanianeee3ef12011-07-24 20:53:26 +00001754
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001755 // FIXME. For now, we are not checking for extact match of methods
1756 // in category implementation and its primary class's super class.
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001757 if (!WarnCategoryMethodImpl && I->getSuperClass())
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001758 MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
Mike Stump1eb44332009-09-09 15:08:12 +00001759 IMPDecl,
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001760 I->getSuperClass(), IncompleteImpl, false);
1761 }
1762}
1763
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001764/// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
1765/// category matches with those implemented in its primary class and
1766/// warns each time an exact match is found.
1767void Sema::CheckCategoryVsClassMethodMatches(
1768 ObjCCategoryImplDecl *CatIMPDecl) {
Benjamin Kramer811bfcd2012-05-27 13:28:52 +00001769 SelectorSet InsMap, ClsMap;
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001770
1771 for (ObjCImplementationDecl::instmeth_iterator
1772 I = CatIMPDecl->instmeth_begin(),
1773 E = CatIMPDecl->instmeth_end(); I!=E; ++I)
1774 InsMap.insert((*I)->getSelector());
1775
1776 for (ObjCImplementationDecl::classmeth_iterator
1777 I = CatIMPDecl->classmeth_begin(),
1778 E = CatIMPDecl->classmeth_end(); I != E; ++I)
1779 ClsMap.insert((*I)->getSelector());
1780 if (InsMap.empty() && ClsMap.empty())
1781 return;
1782
1783 // Get category's primary class.
1784 ObjCCategoryDecl *CatDecl = CatIMPDecl->getCategoryDecl();
1785 if (!CatDecl)
1786 return;
1787 ObjCInterfaceDecl *IDecl = CatDecl->getClassInterface();
1788 if (!IDecl)
1789 return;
Benjamin Kramer811bfcd2012-05-27 13:28:52 +00001790 SelectorSet InsMapSeen, ClsMapSeen;
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001791 bool IncompleteImpl = false;
1792 MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1793 CatIMPDecl, IDecl,
Fariborz Jahanianbb3d14e2012-02-09 21:30:24 +00001794 IncompleteImpl, false,
1795 true /*WarnCategoryMethodImpl*/);
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001796}
Fariborz Jahanianeee3ef12011-07-24 20:53:26 +00001797
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001798void Sema::ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
Mike Stump1eb44332009-09-09 15:08:12 +00001799 ObjCContainerDecl* CDecl,
Chris Lattnercddc8882009-03-01 00:56:52 +00001800 bool IncompleteImpl) {
Benjamin Kramer811bfcd2012-05-27 13:28:52 +00001801 SelectorSet InsMap;
Chris Lattner4d391482007-12-12 07:09:47 +00001802 // Check and see if instance methods in class interface have been
1803 // implemented in the implementation class.
Mike Stump1eb44332009-09-09 15:08:12 +00001804 for (ObjCImplementationDecl::instmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001805 I = IMPDecl->instmeth_begin(), E = IMPDecl->instmeth_end(); I!=E; ++I)
Chris Lattner4c525092007-12-12 17:58:05 +00001806 InsMap.insert((*I)->getSelector());
Mike Stump1eb44332009-09-09 15:08:12 +00001807
Fariborz Jahanian12bac252009-04-14 23:15:21 +00001808 // Check and see if properties declared in the interface have either 1)
1809 // an implementation or 2) there is a @synthesize/@dynamic implementation
1810 // of the property in the @implementation.
Fariborz Jahanianeb4f2c52012-01-03 19:46:00 +00001811 if (const ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl))
John McCall260611a2012-06-20 06:18:46 +00001812 if (!(LangOpts.ObjCDefaultSynthProperties &&
1813 LangOpts.ObjCRuntime.isNonFragile()) ||
1814 IDecl->isObjCRequiresPropertyDefs())
Fariborz Jahanianeb4f2c52012-01-03 19:46:00 +00001815 DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, InsMap);
Fariborz Jahanian3ac1eda2010-01-20 01:51:55 +00001816
Benjamin Kramer811bfcd2012-05-27 13:28:52 +00001817 SelectorSet ClsMap;
Mike Stump1eb44332009-09-09 15:08:12 +00001818 for (ObjCImplementationDecl::classmeth_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001819 I = IMPDecl->classmeth_begin(),
1820 E = IMPDecl->classmeth_end(); I != E; ++I)
Chris Lattner4c525092007-12-12 17:58:05 +00001821 ClsMap.insert((*I)->getSelector());
Mike Stump1eb44332009-09-09 15:08:12 +00001822
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001823 // Check for type conflict of methods declared in a class/protocol and
1824 // its implementation; if any.
Benjamin Kramer811bfcd2012-05-27 13:28:52 +00001825 SelectorSet InsMapSeen, ClsMapSeen;
Mike Stump1eb44332009-09-09 15:08:12 +00001826 MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1827 IMPDecl, CDecl,
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001828 IncompleteImpl, true);
Fariborz Jahanian74133072011-08-03 18:21:12 +00001829
Fariborz Jahanianfefe91e2011-07-28 23:19:50 +00001830 // check all methods implemented in category against those declared
1831 // in its primary class.
1832 if (ObjCCategoryImplDecl *CatDecl =
1833 dyn_cast<ObjCCategoryImplDecl>(IMPDecl))
1834 CheckCategoryVsClassMethodMatches(CatDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001835
Chris Lattner4d391482007-12-12 07:09:47 +00001836 // Check the protocol list for unimplemented methods in the @implementation
1837 // class.
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001838 // Check and see if class methods in class interface have been
1839 // implemented in the implementation class.
Mike Stump1eb44332009-09-09 15:08:12 +00001840
Chris Lattnercddc8882009-03-01 00:56:52 +00001841 if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
Ted Kremenek53b94412010-09-01 01:21:15 +00001842 for (ObjCInterfaceDecl::all_protocol_iterator
1843 PI = I->all_referenced_protocol_begin(),
1844 E = I->all_referenced_protocol_end(); PI != E; ++PI)
Mike Stump1eb44332009-09-09 15:08:12 +00001845 CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl,
Chris Lattnercddc8882009-03-01 00:56:52 +00001846 InsMap, ClsMap, I);
1847 // Check class extensions (unnamed categories)
Fariborz Jahanian80aa1cd2010-06-22 23:20:40 +00001848 for (const ObjCCategoryDecl *Categories = I->getFirstClassExtension();
1849 Categories; Categories = Categories->getNextClassExtension())
1850 ImplMethodsVsClassMethods(S, IMPDecl,
1851 const_cast<ObjCCategoryDecl*>(Categories),
1852 IncompleteImpl);
Chris Lattnercddc8882009-03-01 00:56:52 +00001853 } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
Fariborz Jahanianb106fc62009-10-05 21:32:49 +00001854 // For extended class, unimplemented methods in its protocols will
1855 // be reported in the primary class.
Fariborz Jahanian25760612010-02-15 21:55:26 +00001856 if (!C->IsClassExtension()) {
Fariborz Jahanianb106fc62009-10-05 21:32:49 +00001857 for (ObjCCategoryDecl::protocol_iterator PI = C->protocol_begin(),
1858 E = C->protocol_end(); PI != E; ++PI)
1859 CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl,
Fariborz Jahanianf2838592010-03-27 21:10:05 +00001860 InsMap, ClsMap, CDecl);
Fariborz Jahanian3ad230e2010-01-20 19:36:21 +00001861 // Report unimplemented properties in the category as well.
1862 // When reporting on missing setter/getters, do not report when
1863 // setter/getter is implemented in category's primary class
1864 // implementation.
1865 if (ObjCInterfaceDecl *ID = C->getClassInterface())
1866 if (ObjCImplDecl *IMP = ID->getImplementation()) {
1867 for (ObjCImplementationDecl::instmeth_iterator
1868 I = IMP->instmeth_begin(), E = IMP->instmeth_end(); I!=E; ++I)
1869 InsMap.insert((*I)->getSelector());
1870 }
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001871 DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, InsMap);
Fariborz Jahanian3ad230e2010-01-20 19:36:21 +00001872 }
Chris Lattnercddc8882009-03-01 00:56:52 +00001873 } else
David Blaikieb219cfc2011-09-23 05:06:16 +00001874 llvm_unreachable("invalid ObjCContainerDecl type.");
Chris Lattner4d391482007-12-12 07:09:47 +00001875}
1876
Mike Stump1eb44332009-09-09 15:08:12 +00001877/// ActOnForwardClassDeclaration -
Fariborz Jahanian95ed7782011-08-27 20:50:59 +00001878Sema::DeclGroupPtrTy
Chris Lattner4d391482007-12-12 07:09:47 +00001879Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
Chris Lattnerbdbde4d2009-02-16 19:25:52 +00001880 IdentifierInfo **IdentList,
Ted Kremenekc09cba62009-11-17 23:12:20 +00001881 SourceLocation *IdentLocs,
Chris Lattnerbdbde4d2009-02-16 19:25:52 +00001882 unsigned NumElts) {
Fariborz Jahanian95ed7782011-08-27 20:50:59 +00001883 SmallVector<Decl *, 8> DeclsInGroup;
Chris Lattner4d391482007-12-12 07:09:47 +00001884 for (unsigned i = 0; i != NumElts; ++i) {
1885 // Check for another declaration kind with the same name.
John McCallf36e02d2009-10-09 21:13:30 +00001886 NamedDecl *PrevDecl
Douglas Gregorc83c6872010-04-15 22:33:43 +00001887 = LookupSingleName(TUScope, IdentList[i], IdentLocs[i],
Douglas Gregorc0b39642010-04-15 23:40:53 +00001888 LookupOrdinaryName, ForRedeclaration);
Douglas Gregorf57172b2008-12-08 18:40:42 +00001889 if (PrevDecl && PrevDecl->isTemplateParameter()) {
Douglas Gregor72c3f312008-12-05 18:15:24 +00001890 // Maybe we will complain about the shadowed template parameter.
1891 DiagnoseTemplateParameterShadow(AtClassLoc, PrevDecl);
1892 // Just pretend that we didn't see the previous declaration.
1893 PrevDecl = 0;
1894 }
1895
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001896 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Steve Naroffc7333882008-06-05 22:57:10 +00001897 // GCC apparently allows the following idiom:
1898 //
1899 // typedef NSObject < XCElementTogglerP > XCElementToggler;
1900 // @class XCElementToggler;
1901 //
Fariborz Jahaniane42670b2012-01-24 00:40:15 +00001902 // Here we have chosen to ignore the forward class declaration
1903 // with a warning. Since this is the implied behavior.
Richard Smith162e1c12011-04-15 14:24:37 +00001904 TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(PrevDecl);
John McCallc12c5bb2010-05-15 11:32:37 +00001905 if (!TDD || !TDD->getUnderlyingType()->isObjCObjectType()) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001906 Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];
Chris Lattner5f4a6822008-11-23 23:12:31 +00001907 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
John McCallc12c5bb2010-05-15 11:32:37 +00001908 } else {
Mike Stumpac5fc7c2009-08-04 21:02:39 +00001909 // a forward class declaration matching a typedef name of a class refers
Fariborz Jahaniane42670b2012-01-24 00:40:15 +00001910 // to the underlying class. Just ignore the forward class with a warning
1911 // as this will force the intended behavior which is to lookup the typedef
1912 // name.
1913 if (isa<ObjCObjectType>(TDD->getUnderlyingType())) {
1914 Diag(AtClassLoc, diag::warn_forward_class_redefinition) << IdentList[i];
1915 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1916 continue;
1917 }
Fariborz Jahaniancae27c52009-05-07 21:49:26 +00001918 }
Chris Lattner4d391482007-12-12 07:09:47 +00001919 }
Douglas Gregor7723fec2011-12-15 20:29:51 +00001920
1921 // Create a declaration to describe this forward declaration.
Douglas Gregor0af55012011-12-16 03:12:41 +00001922 ObjCInterfaceDecl *PrevIDecl
1923 = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
Douglas Gregor7723fec2011-12-15 20:29:51 +00001924 ObjCInterfaceDecl *IDecl
1925 = ObjCInterfaceDecl::Create(Context, CurContext, AtClassLoc,
Douglas Gregor375bb142011-12-27 22:43:10 +00001926 IdentList[i], PrevIDecl, IdentLocs[i]);
Douglas Gregor7723fec2011-12-15 20:29:51 +00001927 IDecl->setAtEndRange(IdentLocs[i]);
Douglas Gregor7723fec2011-12-15 20:29:51 +00001928
Douglas Gregor7723fec2011-12-15 20:29:51 +00001929 PushOnScopeChains(IDecl, TUScope);
Douglas Gregor375bb142011-12-27 22:43:10 +00001930 CheckObjCDeclScope(IDecl);
1931 DeclsInGroup.push_back(IDecl);
Chris Lattner4d391482007-12-12 07:09:47 +00001932 }
Fariborz Jahanian95ed7782011-08-27 20:50:59 +00001933
1934 return BuildDeclaratorGroup(DeclsInGroup.data(), DeclsInGroup.size(), false);
Chris Lattner4d391482007-12-12 07:09:47 +00001935}
1936
John McCall0f4c4c42011-06-16 01:15:19 +00001937static bool tryMatchRecordTypes(ASTContext &Context,
1938 Sema::MethodMatchStrategy strategy,
1939 const Type *left, const Type *right);
1940
John McCallf85e1932011-06-15 23:02:42 +00001941static bool matchTypes(ASTContext &Context, Sema::MethodMatchStrategy strategy,
1942 QualType leftQT, QualType rightQT) {
1943 const Type *left =
1944 Context.getCanonicalType(leftQT).getUnqualifiedType().getTypePtr();
1945 const Type *right =
1946 Context.getCanonicalType(rightQT).getUnqualifiedType().getTypePtr();
1947
1948 if (left == right) return true;
1949
1950 // If we're doing a strict match, the types have to match exactly.
1951 if (strategy == Sema::MMS_strict) return false;
1952
1953 if (left->isIncompleteType() || right->isIncompleteType()) return false;
1954
1955 // Otherwise, use this absurdly complicated algorithm to try to
1956 // validate the basic, low-level compatibility of the two types.
1957
1958 // As a minimum, require the sizes and alignments to match.
1959 if (Context.getTypeInfo(left) != Context.getTypeInfo(right))
1960 return false;
1961
1962 // Consider all the kinds of non-dependent canonical types:
1963 // - functions and arrays aren't possible as return and parameter types
1964
1965 // - vector types of equal size can be arbitrarily mixed
1966 if (isa<VectorType>(left)) return isa<VectorType>(right);
1967 if (isa<VectorType>(right)) return false;
1968
1969 // - references should only match references of identical type
John McCall0f4c4c42011-06-16 01:15:19 +00001970 // - structs, unions, and Objective-C objects must match more-or-less
1971 // exactly
John McCallf85e1932011-06-15 23:02:42 +00001972 // - everything else should be a scalar
1973 if (!left->isScalarType() || !right->isScalarType())
John McCall0f4c4c42011-06-16 01:15:19 +00001974 return tryMatchRecordTypes(Context, strategy, left, right);
John McCallf85e1932011-06-15 23:02:42 +00001975
John McCall1d9b3b22011-09-09 05:25:32 +00001976 // Make scalars agree in kind, except count bools as chars, and group
1977 // all non-member pointers together.
John McCallf85e1932011-06-15 23:02:42 +00001978 Type::ScalarTypeKind leftSK = left->getScalarTypeKind();
1979 Type::ScalarTypeKind rightSK = right->getScalarTypeKind();
1980 if (leftSK == Type::STK_Bool) leftSK = Type::STK_Integral;
1981 if (rightSK == Type::STK_Bool) rightSK = Type::STK_Integral;
John McCall1d9b3b22011-09-09 05:25:32 +00001982 if (leftSK == Type::STK_CPointer || leftSK == Type::STK_BlockPointer)
1983 leftSK = Type::STK_ObjCObjectPointer;
1984 if (rightSK == Type::STK_CPointer || rightSK == Type::STK_BlockPointer)
1985 rightSK = Type::STK_ObjCObjectPointer;
John McCallf85e1932011-06-15 23:02:42 +00001986
1987 // Note that data member pointers and function member pointers don't
1988 // intermix because of the size differences.
1989
1990 return (leftSK == rightSK);
1991}
Chris Lattner4d391482007-12-12 07:09:47 +00001992
John McCall0f4c4c42011-06-16 01:15:19 +00001993static bool tryMatchRecordTypes(ASTContext &Context,
1994 Sema::MethodMatchStrategy strategy,
1995 const Type *lt, const Type *rt) {
1996 assert(lt && rt && lt != rt);
1997
1998 if (!isa<RecordType>(lt) || !isa<RecordType>(rt)) return false;
1999 RecordDecl *left = cast<RecordType>(lt)->getDecl();
2000 RecordDecl *right = cast<RecordType>(rt)->getDecl();
2001
2002 // Require union-hood to match.
2003 if (left->isUnion() != right->isUnion()) return false;
2004
2005 // Require an exact match if either is non-POD.
2006 if ((isa<CXXRecordDecl>(left) && !cast<CXXRecordDecl>(left)->isPOD()) ||
2007 (isa<CXXRecordDecl>(right) && !cast<CXXRecordDecl>(right)->isPOD()))
2008 return false;
2009
2010 // Require size and alignment to match.
2011 if (Context.getTypeInfo(lt) != Context.getTypeInfo(rt)) return false;
2012
2013 // Require fields to match.
2014 RecordDecl::field_iterator li = left->field_begin(), le = left->field_end();
2015 RecordDecl::field_iterator ri = right->field_begin(), re = right->field_end();
2016 for (; li != le && ri != re; ++li, ++ri) {
2017 if (!matchTypes(Context, strategy, li->getType(), ri->getType()))
2018 return false;
2019 }
2020 return (li == le && ri == re);
2021}
2022
Chris Lattner4d391482007-12-12 07:09:47 +00002023/// MatchTwoMethodDeclarations - Checks that two methods have matching type and
2024/// returns true, or false, accordingly.
2025/// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
John McCallf85e1932011-06-15 23:02:42 +00002026bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *left,
2027 const ObjCMethodDecl *right,
2028 MethodMatchStrategy strategy) {
2029 if (!matchTypes(Context, strategy,
2030 left->getResultType(), right->getResultType()))
2031 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00002032
David Blaikie4e4d0842012-03-11 07:00:24 +00002033 if (getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00002034 (left->hasAttr<NSReturnsRetainedAttr>()
2035 != right->hasAttr<NSReturnsRetainedAttr>() ||
2036 left->hasAttr<NSConsumesSelfAttr>()
2037 != right->hasAttr<NSConsumesSelfAttr>()))
2038 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00002039
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +00002040 ObjCMethodDecl::param_const_iterator
Douglas Gregor0a4a23a2012-05-17 23:13:29 +00002041 li = left->param_begin(), le = left->param_end(), ri = right->param_begin(),
2042 re = right->param_end();
Mike Stump1eb44332009-09-09 15:08:12 +00002043
Douglas Gregor0a4a23a2012-05-17 23:13:29 +00002044 for (; li != le && ri != re; ++li, ++ri) {
John McCallf85e1932011-06-15 23:02:42 +00002045 assert(ri != right->param_end() && "Param mismatch");
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +00002046 const ParmVarDecl *lparm = *li, *rparm = *ri;
John McCallf85e1932011-06-15 23:02:42 +00002047
2048 if (!matchTypes(Context, strategy, lparm->getType(), rparm->getType()))
2049 return false;
2050
David Blaikie4e4d0842012-03-11 07:00:24 +00002051 if (getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00002052 lparm->hasAttr<NSConsumedAttr>() != rparm->hasAttr<NSConsumedAttr>())
2053 return false;
Chris Lattner4d391482007-12-12 07:09:47 +00002054 }
2055 return true;
2056}
2057
Douglas Gregorff310c72012-05-01 23:37:00 +00002058void Sema::addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method) {
Douglas Gregor44fae522012-01-25 00:19:56 +00002059 // If the list is empty, make it a singleton list.
2060 if (List->Method == 0) {
2061 List->Method = Method;
2062 List->Next = 0;
Douglas Gregorff310c72012-05-01 23:37:00 +00002063 return;
Douglas Gregor44fae522012-01-25 00:19:56 +00002064 }
2065
2066 // We've seen a method with this name, see if we have already seen this type
2067 // signature.
2068 ObjCMethodList *Previous = List;
2069 for (; List; Previous = List, List = List->Next) {
Douglas Gregor5ac4b692012-01-25 00:49:42 +00002070 if (!MatchTwoMethodDeclarations(Method, List->Method))
Douglas Gregor44fae522012-01-25 00:19:56 +00002071 continue;
2072
2073 ObjCMethodDecl *PrevObjCMethod = List->Method;
2074
2075 // Propagate the 'defined' bit.
2076 if (Method->isDefined())
2077 PrevObjCMethod->setDefined(true);
2078
2079 // If a method is deprecated, push it in the global pool.
2080 // This is used for better diagnostics.
2081 if (Method->isDeprecated()) {
2082 if (!PrevObjCMethod->isDeprecated())
2083 List->Method = Method;
2084 }
2085 // If new method is unavailable, push it into global pool
2086 // unless previous one is deprecated.
2087 if (Method->isUnavailable()) {
2088 if (PrevObjCMethod->getAvailability() < AR_Deprecated)
2089 List->Method = Method;
2090 }
2091
Douglas Gregorff310c72012-05-01 23:37:00 +00002092 return;
Douglas Gregor44fae522012-01-25 00:19:56 +00002093 }
2094
2095 // We have a new signature for an existing method - add it.
2096 // This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
Douglas Gregor5ac4b692012-01-25 00:49:42 +00002097 ObjCMethodList *Mem = BumpAlloc.Allocate<ObjCMethodList>();
Douglas Gregor44fae522012-01-25 00:19:56 +00002098 Previous->Next = new (Mem) ObjCMethodList(Method, 0);
2099}
2100
Sebastian Redldb9d2142010-08-02 23:18:59 +00002101/// \brief Read the contents of the method pool for a given selector from
2102/// external storage.
Douglas Gregor5ac4b692012-01-25 00:49:42 +00002103void Sema::ReadMethodPool(Selector Sel) {
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002104 assert(ExternalSource && "We need an external AST source");
Douglas Gregor5ac4b692012-01-25 00:49:42 +00002105 ExternalSource->ReadMethodPool(Sel);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002106}
2107
Douglas Gregorff310c72012-05-01 23:37:00 +00002108void Sema::AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl,
Sebastian Redldb9d2142010-08-02 23:18:59 +00002109 bool instance) {
Argyrios Kyrtzidis9a0b6b42012-03-12 18:34:26 +00002110 // Ignore methods of invalid containers.
2111 if (cast<Decl>(Method->getDeclContext())->isInvalidDecl())
Douglas Gregorff310c72012-05-01 23:37:00 +00002112 return;
Argyrios Kyrtzidis9a0b6b42012-03-12 18:34:26 +00002113
Douglas Gregor0d266d62012-01-25 00:59:09 +00002114 if (ExternalSource)
2115 ReadMethodPool(Method->getSelector());
2116
Sebastian Redldb9d2142010-08-02 23:18:59 +00002117 GlobalMethodPool::iterator Pos = MethodPool.find(Method->getSelector());
Douglas Gregor0d266d62012-01-25 00:59:09 +00002118 if (Pos == MethodPool.end())
2119 Pos = MethodPool.insert(std::make_pair(Method->getSelector(),
2120 GlobalMethods())).first;
Douglas Gregor44fae522012-01-25 00:19:56 +00002121
Fariborz Jahanian3fe10412010-07-22 18:24:20 +00002122 Method->setDefined(impl);
Douglas Gregor44fae522012-01-25 00:19:56 +00002123
Sebastian Redldb9d2142010-08-02 23:18:59 +00002124 ObjCMethodList &Entry = instance ? Pos->second.first : Pos->second.second;
Douglas Gregorff310c72012-05-01 23:37:00 +00002125 addMethodToGlobalList(&Entry, Method);
Chris Lattner4d391482007-12-12 07:09:47 +00002126}
2127
John McCallf85e1932011-06-15 23:02:42 +00002128/// Determines if this is an "acceptable" loose mismatch in the global
2129/// method pool. This exists mostly as a hack to get around certain
2130/// global mismatches which we can't afford to make warnings / errors.
2131/// Really, what we want is a way to take a method out of the global
2132/// method pool.
2133static bool isAcceptableMethodMismatch(ObjCMethodDecl *chosen,
2134 ObjCMethodDecl *other) {
2135 if (!chosen->isInstanceMethod())
2136 return false;
2137
2138 Selector sel = chosen->getSelector();
2139 if (!sel.isUnarySelector() || sel.getNameForSlot(0) != "length")
2140 return false;
2141
2142 // Don't complain about mismatches for -length if the method we
2143 // chose has an integral result type.
2144 return (chosen->getResultType()->isIntegerType());
2145}
2146
Sebastian Redldb9d2142010-08-02 23:18:59 +00002147ObjCMethodDecl *Sema::LookupMethodInGlobalPool(Selector Sel, SourceRange R,
Fariborz Jahanian6b308f62010-08-09 23:27:58 +00002148 bool receiverIdOrClass,
Sebastian Redldb9d2142010-08-02 23:18:59 +00002149 bool warn, bool instance) {
Douglas Gregor0d266d62012-01-25 00:59:09 +00002150 if (ExternalSource)
2151 ReadMethodPool(Sel);
2152
Sebastian Redldb9d2142010-08-02 23:18:59 +00002153 GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
Douglas Gregor0d266d62012-01-25 00:59:09 +00002154 if (Pos == MethodPool.end())
2155 return 0;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002156
Sebastian Redldb9d2142010-08-02 23:18:59 +00002157 ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
Mike Stump1eb44332009-09-09 15:08:12 +00002158
Sebastian Redldb9d2142010-08-02 23:18:59 +00002159 if (warn && MethList.Method && MethList.Next) {
John McCallf85e1932011-06-15 23:02:42 +00002160 bool issueDiagnostic = false, issueError = false;
2161
2162 // We support a warning which complains about *any* difference in
2163 // method signature.
2164 bool strictSelectorMatch =
2165 (receiverIdOrClass && warn &&
2166 (Diags.getDiagnosticLevel(diag::warn_strict_multiple_method_decl,
2167 R.getBegin()) !=
David Blaikied6471f72011-09-25 23:23:43 +00002168 DiagnosticsEngine::Ignored));
Fariborz Jahanian6b308f62010-08-09 23:27:58 +00002169 if (strictSelectorMatch)
2170 for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) {
John McCallf85e1932011-06-15 23:02:42 +00002171 if (!MatchTwoMethodDeclarations(MethList.Method, Next->Method,
2172 MMS_strict)) {
2173 issueDiagnostic = true;
2174 break;
2175 }
Fariborz Jahanian6b308f62010-08-09 23:27:58 +00002176 }
2177
John McCallf85e1932011-06-15 23:02:42 +00002178 // If we didn't see any strict differences, we won't see any loose
2179 // differences. In ARC, however, we also need to check for loose
2180 // mismatches, because most of them are errors.
2181 if (!strictSelectorMatch ||
David Blaikie4e4d0842012-03-11 07:00:24 +00002182 (issueDiagnostic && getLangOpts().ObjCAutoRefCount))
Fariborz Jahanian6b308f62010-08-09 23:27:58 +00002183 for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) {
John McCallf85e1932011-06-15 23:02:42 +00002184 // This checks if the methods differ in type mismatch.
2185 if (!MatchTwoMethodDeclarations(MethList.Method, Next->Method,
2186 MMS_loose) &&
2187 !isAcceptableMethodMismatch(MethList.Method, Next->Method)) {
2188 issueDiagnostic = true;
David Blaikie4e4d0842012-03-11 07:00:24 +00002189 if (getLangOpts().ObjCAutoRefCount)
John McCallf85e1932011-06-15 23:02:42 +00002190 issueError = true;
2191 break;
2192 }
Fariborz Jahanian6b308f62010-08-09 23:27:58 +00002193 }
2194
John McCallf85e1932011-06-15 23:02:42 +00002195 if (issueDiagnostic) {
2196 if (issueError)
2197 Diag(R.getBegin(), diag::err_arc_multiple_method_decl) << Sel << R;
2198 else if (strictSelectorMatch)
Fariborz Jahanian6b308f62010-08-09 23:27:58 +00002199 Diag(R.getBegin(), diag::warn_strict_multiple_method_decl) << Sel << R;
2200 else
2201 Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R;
John McCallf85e1932011-06-15 23:02:42 +00002202
2203 Diag(MethList.Method->getLocStart(),
2204 issueError ? diag::note_possibility : diag::note_using)
Sebastian Redldb9d2142010-08-02 23:18:59 +00002205 << MethList.Method->getSourceRange();
2206 for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next)
2207 Diag(Next->Method->getLocStart(), diag::note_also_found)
2208 << Next->Method->getSourceRange();
2209 }
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002210 }
2211 return MethList.Method;
2212}
2213
Fariborz Jahanian3fe10412010-07-22 18:24:20 +00002214ObjCMethodDecl *Sema::LookupImplementedMethodInGlobalPool(Selector Sel) {
Sebastian Redldb9d2142010-08-02 23:18:59 +00002215 GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
2216 if (Pos == MethodPool.end())
2217 return 0;
2218
2219 GlobalMethods &Methods = Pos->second;
2220
2221 if (Methods.first.Method && Methods.first.Method->isDefined())
2222 return Methods.first.Method;
2223 if (Methods.second.Method && Methods.second.Method->isDefined())
2224 return Methods.second.Method;
Fariborz Jahanian3fe10412010-07-22 18:24:20 +00002225 return 0;
2226}
2227
Fariborz Jahanianf914b972010-02-23 23:41:11 +00002228/// DiagnoseDuplicateIvars -
2229/// Check for duplicate ivars in the entire class at the start of
James Dennett1dfbd922012-06-14 21:40:34 +00002230/// \@implementation. This becomes necesssary because class extension can
Fariborz Jahanianf914b972010-02-23 23:41:11 +00002231/// add ivars to a class in random order which will not be known until
James Dennett1dfbd922012-06-14 21:40:34 +00002232/// class's \@implementation is seen.
Fariborz Jahanianf914b972010-02-23 23:41:11 +00002233void Sema::DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID,
2234 ObjCInterfaceDecl *SID) {
2235 for (ObjCInterfaceDecl::ivar_iterator IVI = ID->ivar_begin(),
2236 IVE = ID->ivar_end(); IVI != IVE; ++IVI) {
David Blaikie581deb32012-06-06 20:45:41 +00002237 ObjCIvarDecl* Ivar = *IVI;
Fariborz Jahanianf914b972010-02-23 23:41:11 +00002238 if (Ivar->isInvalidDecl())
2239 continue;
2240 if (IdentifierInfo *II = Ivar->getIdentifier()) {
2241 ObjCIvarDecl* prevIvar = SID->lookupInstanceVariable(II);
2242 if (prevIvar) {
2243 Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
2244 Diag(prevIvar->getLocation(), diag::note_previous_declaration);
2245 Ivar->setInvalidDecl();
2246 }
2247 }
2248 }
2249}
2250
Erik Verbruggend64251f2011-12-06 09:25:23 +00002251Sema::ObjCContainerKind Sema::getObjCContainerKind() const {
2252 switch (CurContext->getDeclKind()) {
2253 case Decl::ObjCInterface:
2254 return Sema::OCK_Interface;
2255 case Decl::ObjCProtocol:
2256 return Sema::OCK_Protocol;
2257 case Decl::ObjCCategory:
2258 if (dyn_cast<ObjCCategoryDecl>(CurContext)->IsClassExtension())
2259 return Sema::OCK_ClassExtension;
2260 else
2261 return Sema::OCK_Category;
2262 case Decl::ObjCImplementation:
2263 return Sema::OCK_Implementation;
2264 case Decl::ObjCCategoryImpl:
2265 return Sema::OCK_CategoryImplementation;
2266
2267 default:
2268 return Sema::OCK_None;
2269 }
2270}
2271
Steve Naroffa56f6162007-12-18 01:30:32 +00002272// Note: For class/category implemenations, allMethods/allProperties is
2273// always null.
Erik Verbruggend64251f2011-12-06 09:25:23 +00002274Decl *Sema::ActOnAtEnd(Scope *S, SourceRange AtEnd,
2275 Decl **allMethods, unsigned allNum,
2276 Decl **allProperties, unsigned pNum,
2277 DeclGroupPtrTy *allTUVars, unsigned tuvNum) {
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00002278
Erik Verbruggend64251f2011-12-06 09:25:23 +00002279 if (getObjCContainerKind() == Sema::OCK_None)
2280 return 0;
2281
2282 assert(AtEnd.isValid() && "Invalid location for '@end'");
2283
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00002284 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
2285 Decl *ClassDecl = cast<Decl>(OCD);
Fariborz Jahanian63e963c2009-11-16 18:57:01 +00002286
Mike Stump1eb44332009-09-09 15:08:12 +00002287 bool isInterfaceDeclKind =
Chris Lattnerf8d17a52008-03-16 21:17:37 +00002288 isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
2289 || isa<ObjCProtocolDecl>(ClassDecl);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002290 bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
Steve Naroff09c47192009-01-09 15:36:25 +00002291
Steve Naroff0701bbb2009-01-08 17:28:14 +00002292 // FIXME: Remove these and use the ObjCContainerDecl/DeclContext.
2293 llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
2294 llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
2295
Chris Lattner4d391482007-12-12 07:09:47 +00002296 for (unsigned i = 0; i < allNum; i++ ) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002297 ObjCMethodDecl *Method =
John McCalld226f652010-08-21 09:40:31 +00002298 cast_or_null<ObjCMethodDecl>(allMethods[i]);
Chris Lattner4d391482007-12-12 07:09:47 +00002299
2300 if (!Method) continue; // Already issued a diagnostic.
Douglas Gregorf8d49f62009-01-09 17:18:27 +00002301 if (Method->isInstanceMethod()) {
Chris Lattner4d391482007-12-12 07:09:47 +00002302 /// Check for instance method of the same name with incompatible types
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002303 const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()];
Mike Stump1eb44332009-09-09 15:08:12 +00002304 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
Chris Lattner4d391482007-12-12 07:09:47 +00002305 : false;
Mike Stump1eb44332009-09-09 15:08:12 +00002306 if ((isInterfaceDeclKind && PrevMethod && !match)
Eli Friedman82b4e762008-12-16 20:15:50 +00002307 || (checkIdenticalMethods && match)) {
Chris Lattner5f4a6822008-11-23 23:12:31 +00002308 Diag(Method->getLocation(), diag::err_duplicate_method_decl)
Chris Lattner077bf5e2008-11-24 03:33:13 +00002309 << Method->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00002310 Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
Douglas Gregorbdb2d502010-12-21 17:34:17 +00002311 Method->setInvalidDecl();
Chris Lattner4d391482007-12-12 07:09:47 +00002312 } else {
Fariborz Jahanian72096462011-12-13 19:40:34 +00002313 if (PrevMethod) {
Argyrios Kyrtzidis3a919e72011-10-14 08:02:31 +00002314 Method->setAsRedeclaration(PrevMethod);
Fariborz Jahanian72096462011-12-13 19:40:34 +00002315 if (!Context.getSourceManager().isInSystemHeader(
2316 Method->getLocation()))
2317 Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
2318 << Method->getDeclName();
2319 Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
2320 }
Chris Lattner4d391482007-12-12 07:09:47 +00002321 InsMap[Method->getSelector()] = Method;
2322 /// The following allows us to typecheck messages to "id".
Douglas Gregorff310c72012-05-01 23:37:00 +00002323 AddInstanceMethodToGlobalPool(Method);
Chris Lattner4d391482007-12-12 07:09:47 +00002324 }
Mike Stumpac5fc7c2009-08-04 21:02:39 +00002325 } else {
Chris Lattner4d391482007-12-12 07:09:47 +00002326 /// Check for class method of the same name with incompatible types
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002327 const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()];
Mike Stump1eb44332009-09-09 15:08:12 +00002328 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
Chris Lattner4d391482007-12-12 07:09:47 +00002329 : false;
Mike Stump1eb44332009-09-09 15:08:12 +00002330 if ((isInterfaceDeclKind && PrevMethod && !match)
Eli Friedman82b4e762008-12-16 20:15:50 +00002331 || (checkIdenticalMethods && match)) {
Chris Lattner5f4a6822008-11-23 23:12:31 +00002332 Diag(Method->getLocation(), diag::err_duplicate_method_decl)
Chris Lattner077bf5e2008-11-24 03:33:13 +00002333 << Method->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00002334 Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
Douglas Gregorbdb2d502010-12-21 17:34:17 +00002335 Method->setInvalidDecl();
Chris Lattner4d391482007-12-12 07:09:47 +00002336 } else {
Fariborz Jahanian72096462011-12-13 19:40:34 +00002337 if (PrevMethod) {
Argyrios Kyrtzidis3a919e72011-10-14 08:02:31 +00002338 Method->setAsRedeclaration(PrevMethod);
Fariborz Jahanian72096462011-12-13 19:40:34 +00002339 if (!Context.getSourceManager().isInSystemHeader(
2340 Method->getLocation()))
2341 Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
2342 << Method->getDeclName();
2343 Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
2344 }
Chris Lattner4d391482007-12-12 07:09:47 +00002345 ClsMap[Method->getSelector()] = Method;
Douglas Gregorff310c72012-05-01 23:37:00 +00002346 AddFactoryMethodToGlobalPool(Method);
Chris Lattner4d391482007-12-12 07:09:47 +00002347 }
2348 }
2349 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002350 if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
Mike Stump1eb44332009-09-09 15:08:12 +00002351 // Compares properties declared in this class to those of its
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002352 // super class.
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00002353 ComparePropertiesInBaseAndSuper(I);
John McCalld226f652010-08-21 09:40:31 +00002354 CompareProperties(I, I);
Steve Naroff09c47192009-01-09 15:36:25 +00002355 } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
Fariborz Jahanian77e14bd2008-12-06 19:59:02 +00002356 // Categories are used to extend the class by declaring new methods.
Mike Stump1eb44332009-09-09 15:08:12 +00002357 // By the same token, they are also used to add new properties. No
Fariborz Jahanian77e14bd2008-12-06 19:59:02 +00002358 // need to compare the added property to those in the class.
Daniel Dunbarb20ef3e2008-08-27 05:40:03 +00002359
Fariborz Jahanian107089f2010-01-18 18:41:16 +00002360 // Compare protocol properties with those in category
John McCalld226f652010-08-21 09:40:31 +00002361 CompareProperties(C, C);
Fariborz Jahanian88f5e9b2010-12-10 23:36:33 +00002362 if (C->IsClassExtension()) {
2363 ObjCInterfaceDecl *CCPrimary = C->getClassInterface();
2364 DiagnoseClassExtensionDupMethods(C, CCPrimary);
Fariborz Jahanian88f5e9b2010-12-10 23:36:33 +00002365 }
Chris Lattner4d391482007-12-12 07:09:47 +00002366 }
Steve Naroff09c47192009-01-09 15:36:25 +00002367 if (ObjCContainerDecl *CDecl = dyn_cast<ObjCContainerDecl>(ClassDecl)) {
Fariborz Jahanian25760612010-02-15 21:55:26 +00002368 if (CDecl->getIdentifier())
2369 // ProcessPropertyDecl is responsible for diagnosing conflicts with any
2370 // user-defined setter/getter. It also synthesizes setter/getter methods
2371 // and adds them to the DeclContext and global method pools.
2372 for (ObjCContainerDecl::prop_iterator I = CDecl->prop_begin(),
2373 E = CDecl->prop_end();
2374 I != E; ++I)
David Blaikie581deb32012-06-06 20:45:41 +00002375 ProcessPropertyDecl(*I, CDecl);
Ted Kremenek782f2f52010-01-07 01:20:12 +00002376 CDecl->setAtEndRange(AtEnd);
Steve Naroff09c47192009-01-09 15:36:25 +00002377 }
2378 if (ObjCImplementationDecl *IC=dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
Ted Kremenek782f2f52010-01-07 01:20:12 +00002379 IC->setAtEndRange(AtEnd);
Fariborz Jahanian7ca8b062009-11-11 22:40:11 +00002380 if (ObjCInterfaceDecl* IDecl = IC->getClassInterface()) {
Fariborz Jahanianc78f6842010-12-11 18:39:37 +00002381 // Any property declared in a class extension might have user
2382 // declared setter or getter in current class extension or one
2383 // of the other class extensions. Mark them as synthesized as
2384 // property will be synthesized when property with same name is
2385 // seen in the @implementation.
2386 for (const ObjCCategoryDecl *ClsExtDecl =
2387 IDecl->getFirstClassExtension();
2388 ClsExtDecl; ClsExtDecl = ClsExtDecl->getNextClassExtension()) {
2389 for (ObjCContainerDecl::prop_iterator I = ClsExtDecl->prop_begin(),
2390 E = ClsExtDecl->prop_end(); I != E; ++I) {
David Blaikie581deb32012-06-06 20:45:41 +00002391 ObjCPropertyDecl *Property = *I;
Fariborz Jahanianc78f6842010-12-11 18:39:37 +00002392 // Skip over properties declared @dynamic
2393 if (const ObjCPropertyImplDecl *PIDecl
2394 = IC->FindPropertyImplDecl(Property->getIdentifier()))
2395 if (PIDecl->getPropertyImplementation()
2396 == ObjCPropertyImplDecl::Dynamic)
2397 continue;
2398
2399 for (const ObjCCategoryDecl *CExtDecl =
2400 IDecl->getFirstClassExtension();
2401 CExtDecl; CExtDecl = CExtDecl->getNextClassExtension()) {
2402 if (ObjCMethodDecl *GetterMethod =
2403 CExtDecl->getInstanceMethod(Property->getGetterName()))
Jordan Rose1e4691b2012-10-10 16:42:25 +00002404 GetterMethod->setPropertyAccessor(true);
Fariborz Jahanianc78f6842010-12-11 18:39:37 +00002405 if (!Property->isReadOnly())
2406 if (ObjCMethodDecl *SetterMethod =
2407 CExtDecl->getInstanceMethod(Property->getSetterName()))
Jordan Rose1e4691b2012-10-10 16:42:25 +00002408 SetterMethod->setPropertyAccessor(true);
Fariborz Jahanianc78f6842010-12-11 18:39:37 +00002409 }
2410 }
2411 }
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00002412 ImplMethodsVsClassMethods(S, IC, IDecl);
Fariborz Jahanian7ca8b062009-11-11 22:40:11 +00002413 AtomicPropertySetterGetterRules(IC, IDecl);
John McCallf85e1932011-06-15 23:02:42 +00002414 DiagnoseOwningPropertyGetterSynthesis(IC);
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +00002415
Patrick Beardb2f68202012-04-06 18:12:22 +00002416 bool HasRootClassAttr = IDecl->hasAttr<ObjCRootClassAttr>();
2417 if (IDecl->getSuperClass() == NULL) {
2418 // This class has no superclass, so check that it has been marked with
2419 // __attribute((objc_root_class)).
2420 if (!HasRootClassAttr) {
2421 SourceLocation DeclLoc(IDecl->getLocation());
2422 SourceLocation SuperClassLoc(PP.getLocForEndOfToken(DeclLoc));
2423 Diag(DeclLoc, diag::warn_objc_root_class_missing)
2424 << IDecl->getIdentifier();
2425 // See if NSObject is in the current scope, and if it is, suggest
2426 // adding " : NSObject " to the class declaration.
2427 NamedDecl *IF = LookupSingleName(TUScope,
2428 NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject),
2429 DeclLoc, LookupOrdinaryName);
2430 ObjCInterfaceDecl *NSObjectDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
2431 if (NSObjectDecl && NSObjectDecl->getDefinition()) {
2432 Diag(SuperClassLoc, diag::note_objc_needs_superclass)
2433 << FixItHint::CreateInsertion(SuperClassLoc, " : NSObject ");
2434 } else {
2435 Diag(SuperClassLoc, diag::note_objc_needs_superclass);
2436 }
2437 }
2438 } else if (HasRootClassAttr) {
2439 // Complain that only root classes may have this attribute.
2440 Diag(IDecl->getLocation(), diag::err_objc_root_class_subclass);
2441 }
2442
John McCall260611a2012-06-20 06:18:46 +00002443 if (LangOpts.ObjCRuntime.isNonFragile()) {
Fariborz Jahanianf914b972010-02-23 23:41:11 +00002444 while (IDecl->getSuperClass()) {
2445 DiagnoseDuplicateIvars(IDecl, IDecl->getSuperClass());
2446 IDecl = IDecl->getSuperClass();
2447 }
Patrick Beardb2f68202012-04-06 18:12:22 +00002448 }
Fariborz Jahanian7ca8b062009-11-11 22:40:11 +00002449 }
Fariborz Jahaniane4498c62010-04-28 16:11:27 +00002450 SetIvarInitializers(IC);
Mike Stump1eb44332009-09-09 15:08:12 +00002451 } else if (ObjCCategoryImplDecl* CatImplClass =
Steve Naroff09c47192009-01-09 15:36:25 +00002452 dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
Ted Kremenek782f2f52010-01-07 01:20:12 +00002453 CatImplClass->setAtEndRange(AtEnd);
Mike Stump1eb44332009-09-09 15:08:12 +00002454
Chris Lattner4d391482007-12-12 07:09:47 +00002455 // Find category interface decl and then check that all methods declared
Daniel Dunbarb20ef3e2008-08-27 05:40:03 +00002456 // in this interface are implemented in the category @implementation.
Chris Lattner97a58872009-02-16 18:32:47 +00002457 if (ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface()) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002458 for (ObjCCategoryDecl *Categories = IDecl->getCategoryList();
Chris Lattner4d391482007-12-12 07:09:47 +00002459 Categories; Categories = Categories->getNextClassCategory()) {
2460 if (Categories->getIdentifier() == CatImplClass->getIdentifier()) {
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00002461 ImplMethodsVsClassMethods(S, CatImplClass, Categories);
Chris Lattner4d391482007-12-12 07:09:47 +00002462 break;
2463 }
2464 }
2465 }
2466 }
Chris Lattner682bf922009-03-29 16:50:03 +00002467 if (isInterfaceDeclKind) {
2468 // Reject invalid vardecls.
2469 for (unsigned i = 0; i != tuvNum; i++) {
2470 DeclGroupRef DG = allTUVars[i].getAsVal<DeclGroupRef>();
2471 for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
2472 if (VarDecl *VDecl = dyn_cast<VarDecl>(*I)) {
Daniel Dunbar5466c7b2009-04-14 02:25:56 +00002473 if (!VDecl->hasExternalStorage())
Steve Naroff87454162009-04-13 17:58:46 +00002474 Diag(VDecl->getLocation(), diag::err_objc_var_decl_inclass);
Fariborz Jahanianb31cb7f2009-03-21 18:06:45 +00002475 }
Chris Lattner682bf922009-03-29 16:50:03 +00002476 }
Fariborz Jahanian38e24c72009-03-18 22:33:24 +00002477 }
Fariborz Jahanian10af8792011-08-29 17:33:12 +00002478 ActOnObjCContainerFinishDefinition();
Argyrios Kyrtzidisb4a686d2011-10-17 19:48:13 +00002479
2480 for (unsigned i = 0; i != tuvNum; i++) {
2481 DeclGroupRef DG = allTUVars[i].getAsVal<DeclGroupRef>();
Argyrios Kyrtzidisc14a03d2011-11-23 20:27:36 +00002482 for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
2483 (*I)->setTopLevelDeclInObjCContainer();
Argyrios Kyrtzidisb4a686d2011-10-17 19:48:13 +00002484 Consumer.HandleTopLevelDeclInObjCContainer(DG);
2485 }
Erik Verbruggend64251f2011-12-06 09:25:23 +00002486
Dmitri Gribenkoabd56c82012-07-13 01:06:46 +00002487 ActOnDocumentableDecl(ClassDecl);
Erik Verbruggend64251f2011-12-06 09:25:23 +00002488 return ClassDecl;
Chris Lattner4d391482007-12-12 07:09:47 +00002489}
2490
2491
2492/// CvtQTToAstBitMask - utility routine to produce an AST bitmask for
2493/// objective-c's type qualifier from the parser version of the same info.
Mike Stump1eb44332009-09-09 15:08:12 +00002494static Decl::ObjCDeclQualifier
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002495CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) {
John McCall09e2c522011-05-01 03:04:29 +00002496 return (Decl::ObjCDeclQualifier) (unsigned) PQTVal;
Chris Lattner4d391482007-12-12 07:09:47 +00002497}
2498
Ted Kremenek422bae72010-04-18 04:59:38 +00002499static inline
Fariborz Jahanian129a60b2012-08-24 23:50:13 +00002500unsigned countAlignAttr(const AttrVec &A) {
2501 unsigned count=0;
2502 for (AttrVec::const_iterator i = A.begin(), e = A.end(); i != e; ++i)
2503 if ((*i)->getKind() == attr::Aligned)
2504 ++count;
2505 return count;
2506}
2507
2508static inline
Fariborz Jahanian7fda4002011-10-22 01:21:15 +00002509bool containsInvalidMethodImplAttribute(ObjCMethodDecl *IMD,
2510 const AttrVec &A) {
2511 // If method is only declared in implementation (private method),
Fariborz Jahanian7fda4002011-10-22 01:21:15 +00002512 // No need to issue any diagnostics on method definition with attributes.
Fariborz Jahanianee28a4b2011-10-22 01:56:45 +00002513 if (!IMD)
Fariborz Jahanian7fda4002011-10-22 01:21:15 +00002514 return false;
Fariborz Jahanian129a60b2012-08-24 23:50:13 +00002515
Fariborz Jahanianee28a4b2011-10-22 01:56:45 +00002516 // method declared in interface has no attribute.
Fariborz Jahanian129a60b2012-08-24 23:50:13 +00002517 // But implementation has attributes. This is invalid.
2518 // Except when implementation has 'Align' attribute which is
2519 // immaterial to method declared in interface.
Fariborz Jahanianee28a4b2011-10-22 01:56:45 +00002520 if (!IMD->hasAttrs())
Fariborz Jahanian129a60b2012-08-24 23:50:13 +00002521 return (A.size() > countAlignAttr(A));
Fariborz Jahanianee28a4b2011-10-22 01:56:45 +00002522
Fariborz Jahanian7fda4002011-10-22 01:21:15 +00002523 const AttrVec &D = IMD->getAttrs();
Fariborz Jahanian7fda4002011-10-22 01:21:15 +00002524
Fariborz Jahanian129a60b2012-08-24 23:50:13 +00002525 unsigned countAlignOnImpl = countAlignAttr(A);
2526 if (!countAlignOnImpl && (A.size() != D.size()))
2527 return true;
2528 else if (countAlignOnImpl) {
2529 unsigned countAlignOnDecl = countAlignAttr(D);
2530 if (countAlignOnDecl && (A.size() != D.size()))
2531 return true;
2532 else if (!countAlignOnDecl &&
2533 ((A.size()-countAlignOnImpl) != D.size()))
2534 return true;
2535 }
2536
Fariborz Jahanian7fda4002011-10-22 01:21:15 +00002537 // attributes on method declaration and definition must match exactly.
2538 // Note that we have at most a couple of attributes on methods, so this
2539 // n*n search is good enough.
2540 for (AttrVec::const_iterator i = A.begin(), e = A.end(); i != e; ++i) {
Fariborz Jahanian129a60b2012-08-24 23:50:13 +00002541 if ((*i)->getKind() == attr::Aligned)
2542 continue;
Fariborz Jahanian7fda4002011-10-22 01:21:15 +00002543 bool match = false;
2544 for (AttrVec::const_iterator i1 = D.begin(), e1 = D.end(); i1 != e1; ++i1) {
2545 if ((*i)->getKind() == (*i1)->getKind()) {
2546 match = true;
2547 break;
2548 }
2549 }
2550 if (!match)
Sean Huntcf807c42010-08-18 23:23:40 +00002551 return true;
Fariborz Jahanian7fda4002011-10-22 01:21:15 +00002552 }
Fariborz Jahanian129a60b2012-08-24 23:50:13 +00002553
Sean Huntcf807c42010-08-18 23:23:40 +00002554 return false;
Ted Kremenek422bae72010-04-18 04:59:38 +00002555}
2556
Douglas Gregor926df6c2011-06-11 01:09:30 +00002557/// \brief Check whether the declared result type of the given Objective-C
2558/// method declaration is compatible with the method's class.
2559///
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002560static Sema::ResultTypeCompatibilityKind
Douglas Gregor926df6c2011-06-11 01:09:30 +00002561CheckRelatedResultTypeCompatibility(Sema &S, ObjCMethodDecl *Method,
2562 ObjCInterfaceDecl *CurrentClass) {
2563 QualType ResultType = Method->getResultType();
Douglas Gregor926df6c2011-06-11 01:09:30 +00002564
2565 // If an Objective-C method inherits its related result type, then its
2566 // declared result type must be compatible with its own class type. The
2567 // declared result type is compatible if:
2568 if (const ObjCObjectPointerType *ResultObjectType
2569 = ResultType->getAs<ObjCObjectPointerType>()) {
2570 // - it is id or qualified id, or
2571 if (ResultObjectType->isObjCIdType() ||
2572 ResultObjectType->isObjCQualifiedIdType())
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002573 return Sema::RTC_Compatible;
Douglas Gregor926df6c2011-06-11 01:09:30 +00002574
2575 if (CurrentClass) {
2576 if (ObjCInterfaceDecl *ResultClass
2577 = ResultObjectType->getInterfaceDecl()) {
2578 // - it is the same as the method's class type, or
Douglas Gregor60ef3082011-12-15 00:29:59 +00002579 if (declaresSameEntity(CurrentClass, ResultClass))
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002580 return Sema::RTC_Compatible;
Douglas Gregor926df6c2011-06-11 01:09:30 +00002581
2582 // - it is a superclass of the method's class type
2583 if (ResultClass->isSuperClassOf(CurrentClass))
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002584 return Sema::RTC_Compatible;
Douglas Gregor926df6c2011-06-11 01:09:30 +00002585 }
Douglas Gregore97179c2011-09-08 01:46:34 +00002586 } else {
2587 // Any Objective-C pointer type might be acceptable for a protocol
2588 // method; we just don't know.
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002589 return Sema::RTC_Unknown;
Douglas Gregor926df6c2011-06-11 01:09:30 +00002590 }
2591 }
2592
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002593 return Sema::RTC_Incompatible;
Douglas Gregor926df6c2011-06-11 01:09:30 +00002594}
2595
John McCall6c2c2502011-07-22 02:45:48 +00002596namespace {
2597/// A helper class for searching for methods which a particular method
2598/// overrides.
2599class OverrideSearch {
Daniel Dunbarb732fce2012-02-29 03:04:05 +00002600public:
John McCall6c2c2502011-07-22 02:45:48 +00002601 Sema &S;
2602 ObjCMethodDecl *Method;
Daniel Dunbarb732fce2012-02-29 03:04:05 +00002603 llvm::SmallPtrSet<ObjCMethodDecl*, 4> Overridden;
John McCall6c2c2502011-07-22 02:45:48 +00002604 bool Recursive;
2605
2606public:
2607 OverrideSearch(Sema &S, ObjCMethodDecl *method) : S(S), Method(method) {
2608 Selector selector = method->getSelector();
2609
2610 // Bypass this search if we've never seen an instance/class method
2611 // with this selector before.
2612 Sema::GlobalMethodPool::iterator it = S.MethodPool.find(selector);
2613 if (it == S.MethodPool.end()) {
Axel Naumann0ec56b72012-10-18 19:05:02 +00002614 if (!S.getExternalSource()) return;
Douglas Gregor5ac4b692012-01-25 00:49:42 +00002615 S.ReadMethodPool(selector);
2616
2617 it = S.MethodPool.find(selector);
2618 if (it == S.MethodPool.end())
2619 return;
John McCall6c2c2502011-07-22 02:45:48 +00002620 }
2621 ObjCMethodList &list =
2622 method->isInstanceMethod() ? it->second.first : it->second.second;
2623 if (!list.Method) return;
2624
2625 ObjCContainerDecl *container
2626 = cast<ObjCContainerDecl>(method->getDeclContext());
2627
2628 // Prevent the search from reaching this container again. This is
2629 // important with categories, which override methods from the
2630 // interface and each other.
Douglas Gregorc9683342012-05-03 21:25:24 +00002631 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(container)) {
2632 searchFromContainer(container);
Douglas Gregordd872242012-05-17 22:39:14 +00002633 if (ObjCInterfaceDecl *Interface = Category->getClassInterface())
2634 searchFromContainer(Interface);
Douglas Gregorc9683342012-05-03 21:25:24 +00002635 } else {
2636 searchFromContainer(container);
2637 }
Douglas Gregor926df6c2011-06-11 01:09:30 +00002638 }
John McCall6c2c2502011-07-22 02:45:48 +00002639
Daniel Dunbarb732fce2012-02-29 03:04:05 +00002640 typedef llvm::SmallPtrSet<ObjCMethodDecl*, 128>::iterator iterator;
John McCall6c2c2502011-07-22 02:45:48 +00002641 iterator begin() const { return Overridden.begin(); }
2642 iterator end() const { return Overridden.end(); }
2643
2644private:
2645 void searchFromContainer(ObjCContainerDecl *container) {
2646 if (container->isInvalidDecl()) return;
2647
2648 switch (container->getDeclKind()) {
2649#define OBJCCONTAINER(type, base) \
2650 case Decl::type: \
2651 searchFrom(cast<type##Decl>(container)); \
2652 break;
2653#define ABSTRACT_DECL(expansion)
2654#define DECL(type, base) \
2655 case Decl::type:
2656#include "clang/AST/DeclNodes.inc"
2657 llvm_unreachable("not an ObjC container!");
2658 }
2659 }
2660
2661 void searchFrom(ObjCProtocolDecl *protocol) {
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00002662 if (!protocol->hasDefinition())
2663 return;
2664
John McCall6c2c2502011-07-22 02:45:48 +00002665 // A method in a protocol declaration overrides declarations from
2666 // referenced ("parent") protocols.
2667 search(protocol->getReferencedProtocols());
2668 }
2669
2670 void searchFrom(ObjCCategoryDecl *category) {
2671 // A method in a category declaration overrides declarations from
2672 // the main class and from protocols the category references.
Douglas Gregorc9683342012-05-03 21:25:24 +00002673 // The main class is handled in the constructor.
John McCall6c2c2502011-07-22 02:45:48 +00002674 search(category->getReferencedProtocols());
2675 }
2676
2677 void searchFrom(ObjCCategoryImplDecl *impl) {
2678 // A method in a category definition that has a category
2679 // declaration overrides declarations from the category
2680 // declaration.
2681 if (ObjCCategoryDecl *category = impl->getCategoryDecl()) {
2682 search(category);
Douglas Gregordd872242012-05-17 22:39:14 +00002683 if (ObjCInterfaceDecl *Interface = category->getClassInterface())
2684 search(Interface);
John McCall6c2c2502011-07-22 02:45:48 +00002685
2686 // Otherwise it overrides declarations from the class.
Douglas Gregordd872242012-05-17 22:39:14 +00002687 } else if (ObjCInterfaceDecl *Interface = impl->getClassInterface()) {
2688 search(Interface);
John McCall6c2c2502011-07-22 02:45:48 +00002689 }
2690 }
2691
2692 void searchFrom(ObjCInterfaceDecl *iface) {
2693 // A method in a class declaration overrides declarations from
Douglas Gregor2e5c15b2011-12-15 05:27:12 +00002694 if (!iface->hasDefinition())
2695 return;
2696
John McCall6c2c2502011-07-22 02:45:48 +00002697 // - categories,
2698 for (ObjCCategoryDecl *category = iface->getCategoryList();
2699 category; category = category->getNextClassCategory())
2700 search(category);
2701
2702 // - the super class, and
2703 if (ObjCInterfaceDecl *super = iface->getSuperClass())
2704 search(super);
2705
2706 // - any referenced protocols.
2707 search(iface->getReferencedProtocols());
2708 }
2709
2710 void searchFrom(ObjCImplementationDecl *impl) {
2711 // A method in a class implementation overrides declarations from
2712 // the class interface.
Douglas Gregordd872242012-05-17 22:39:14 +00002713 if (ObjCInterfaceDecl *Interface = impl->getClassInterface())
2714 search(Interface);
John McCall6c2c2502011-07-22 02:45:48 +00002715 }
2716
2717
2718 void search(const ObjCProtocolList &protocols) {
2719 for (ObjCProtocolList::iterator i = protocols.begin(), e = protocols.end();
2720 i != e; ++i)
2721 search(*i);
2722 }
2723
2724 void search(ObjCContainerDecl *container) {
John McCall6c2c2502011-07-22 02:45:48 +00002725 // Check for a method in this container which matches this selector.
2726 ObjCMethodDecl *meth = container->getMethod(Method->getSelector(),
2727 Method->isInstanceMethod());
2728
2729 // If we find one, record it and bail out.
2730 if (meth) {
2731 Overridden.insert(meth);
2732 return;
2733 }
2734
2735 // Otherwise, search for methods that a hypothetical method here
2736 // would have overridden.
2737
2738 // Note that we're now in a recursive case.
2739 Recursive = true;
2740
2741 searchFromContainer(container);
2742 }
2743};
Douglas Gregor926df6c2011-06-11 01:09:30 +00002744}
2745
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002746void Sema::CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
2747 ObjCInterfaceDecl *CurrentClass,
2748 ResultTypeCompatibilityKind RTC) {
2749 // Search for overridden methods and merge information down from them.
2750 OverrideSearch overrides(*this, ObjCMethod);
2751 // Keep track if the method overrides any method in the class's base classes,
2752 // its protocols, or its categories' protocols; we will keep that info
2753 // in the ObjCMethodDecl.
2754 // For this info, a method in an implementation is not considered as
2755 // overriding the same method in the interface or its categories.
2756 bool hasOverriddenMethodsInBaseOrProtocol = false;
2757 for (OverrideSearch::iterator
2758 i = overrides.begin(), e = overrides.end(); i != e; ++i) {
2759 ObjCMethodDecl *overridden = *i;
2760
2761 if (isa<ObjCProtocolDecl>(overridden->getDeclContext()) ||
2762 CurrentClass != overridden->getClassInterface() ||
2763 overridden->isOverriding())
2764 hasOverriddenMethodsInBaseOrProtocol = true;
2765
2766 // Propagate down the 'related result type' bit from overridden methods.
2767 if (RTC != Sema::RTC_Incompatible && overridden->hasRelatedResultType())
2768 ObjCMethod->SetRelatedResultType();
2769
2770 // Then merge the declarations.
2771 mergeObjCMethodDecls(ObjCMethod, overridden);
2772
2773 if (ObjCMethod->isImplicit() && overridden->isImplicit())
2774 continue; // Conflicting properties are detected elsewhere.
2775
2776 // Check for overriding methods
2777 if (isa<ObjCInterfaceDecl>(ObjCMethod->getDeclContext()) ||
2778 isa<ObjCImplementationDecl>(ObjCMethod->getDeclContext()))
2779 CheckConflictingOverridingMethod(ObjCMethod, overridden,
2780 isa<ObjCProtocolDecl>(overridden->getDeclContext()));
2781
2782 if (CurrentClass && overridden->getDeclContext() != CurrentClass &&
Fariborz Jahanianc4133a42012-07-05 22:26:07 +00002783 isa<ObjCInterfaceDecl>(overridden->getDeclContext()) &&
2784 !overridden->isImplicit() /* not meant for properties */) {
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002785 ObjCMethodDecl::param_iterator ParamI = ObjCMethod->param_begin(),
2786 E = ObjCMethod->param_end();
Douglas Gregor0a4a23a2012-05-17 23:13:29 +00002787 ObjCMethodDecl::param_iterator PrevI = overridden->param_begin(),
2788 PrevE = overridden->param_end();
2789 for (; ParamI != E && PrevI != PrevE; ++ParamI, ++PrevI) {
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002790 assert(PrevI != overridden->param_end() && "Param mismatch");
2791 QualType T1 = Context.getCanonicalType((*ParamI)->getType());
2792 QualType T2 = Context.getCanonicalType((*PrevI)->getType());
2793 // If type of argument of method in this class does not match its
2794 // respective argument type in the super class method, issue warning;
2795 if (!Context.typesAreCompatible(T1, T2)) {
2796 Diag((*ParamI)->getLocation(), diag::ext_typecheck_base_super)
2797 << T1 << T2;
2798 Diag(overridden->getLocation(), diag::note_previous_declaration);
2799 break;
2800 }
2801 }
2802 }
2803 }
2804
2805 ObjCMethod->setOverriding(hasOverriddenMethodsInBaseOrProtocol);
2806}
2807
John McCalld226f652010-08-21 09:40:31 +00002808Decl *Sema::ActOnMethodDeclaration(
Fariborz Jahanian7f532532011-02-09 22:20:01 +00002809 Scope *S,
Chris Lattner4d391482007-12-12 07:09:47 +00002810 SourceLocation MethodLoc, SourceLocation EndLoc,
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00002811 tok::TokenKind MethodType,
John McCallb3d87482010-08-24 05:47:05 +00002812 ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
Argyrios Kyrtzidis11d77162011-10-03 06:36:36 +00002813 ArrayRef<SourceLocation> SelectorLocs,
Chris Lattner4d391482007-12-12 07:09:47 +00002814 Selector Sel,
2815 // optional arguments. The number of types/arguments is obtained
2816 // from the Sel.getNumArgs().
Chris Lattnere294d3f2009-04-11 18:57:04 +00002817 ObjCArgInfo *ArgInfo,
Fariborz Jahanian4f4fd922010-04-08 00:30:06 +00002818 DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, // c-style args
Chris Lattner4d391482007-12-12 07:09:47 +00002819 AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind,
Fariborz Jahanian90ba78c2011-03-12 18:54:30 +00002820 bool isVariadic, bool MethodDefinition) {
Steve Naroffda323ad2008-02-29 21:48:07 +00002821 // Make sure we can establish a context for the method.
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00002822 if (!CurContext->isObjCContainer()) {
Steve Naroffda323ad2008-02-29 21:48:07 +00002823 Diag(MethodLoc, diag::error_missing_method_context);
John McCalld226f652010-08-21 09:40:31 +00002824 return 0;
Steve Naroffda323ad2008-02-29 21:48:07 +00002825 }
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00002826 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
2827 Decl *ClassDecl = cast<Decl>(OCD);
Chris Lattner4d391482007-12-12 07:09:47 +00002828 QualType resultDeclType;
Mike Stump1eb44332009-09-09 15:08:12 +00002829
Douglas Gregore97179c2011-09-08 01:46:34 +00002830 bool HasRelatedResultType = false;
Douglas Gregor4bc1cb62010-03-08 14:59:44 +00002831 TypeSourceInfo *ResultTInfo = 0;
Steve Naroffccef3712009-02-20 22:59:16 +00002832 if (ReturnType) {
Douglas Gregor4bc1cb62010-03-08 14:59:44 +00002833 resultDeclType = GetTypeFromParser(ReturnType, &ResultTInfo);
Mike Stump1eb44332009-09-09 15:08:12 +00002834
Steve Naroffccef3712009-02-20 22:59:16 +00002835 // Methods cannot return interface types. All ObjC objects are
2836 // passed by reference.
John McCallc12c5bb2010-05-15 11:32:37 +00002837 if (resultDeclType->isObjCObjectType()) {
Chris Lattner2dd979f2009-04-11 19:08:56 +00002838 Diag(MethodLoc, diag::err_object_cannot_be_passed_returned_by_value)
2839 << 0 << resultDeclType;
John McCalld226f652010-08-21 09:40:31 +00002840 return 0;
Douglas Gregor926df6c2011-06-11 01:09:30 +00002841 }
Douglas Gregore97179c2011-09-08 01:46:34 +00002842
2843 HasRelatedResultType = (resultDeclType == Context.getObjCInstanceType());
Fariborz Jahanianaab24a62011-07-21 17:00:47 +00002844 } else { // get the type for "id".
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002845 resultDeclType = Context.getObjCIdType();
Fariborz Jahanianfeb4fa12011-07-21 17:38:14 +00002846 Diag(MethodLoc, diag::warn_missing_method_return_type)
Argyrios Kyrtzidis11d77162011-10-03 06:36:36 +00002847 << FixItHint::CreateInsertion(SelectorLocs.front(), "(id)");
Fariborz Jahanianaab24a62011-07-21 17:00:47 +00002848 }
Mike Stump1eb44332009-09-09 15:08:12 +00002849
2850 ObjCMethodDecl* ObjCMethod =
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +00002851 ObjCMethodDecl::Create(Context, MethodLoc, EndLoc, Sel,
Argyrios Kyrtzidis11d77162011-10-03 06:36:36 +00002852 resultDeclType,
Douglas Gregor4bc1cb62010-03-08 14:59:44 +00002853 ResultTInfo,
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00002854 CurContext,
Chris Lattner6c4ae5d2008-03-16 00:49:28 +00002855 MethodType == tok::minus, isVariadic,
Jordan Rose1e4691b2012-10-10 16:42:25 +00002856 /*isPropertyAccessor=*/false,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002857 /*isImplicitlyDeclared=*/false, /*isDefined=*/false,
Douglas Gregor926df6c2011-06-11 01:09:30 +00002858 MethodDeclKind == tok::objc_optional
2859 ? ObjCMethodDecl::Optional
2860 : ObjCMethodDecl::Required,
Douglas Gregore97179c2011-09-08 01:46:34 +00002861 HasRelatedResultType);
Mike Stump1eb44332009-09-09 15:08:12 +00002862
Chris Lattner5f9e2722011-07-23 10:55:15 +00002863 SmallVector<ParmVarDecl*, 16> Params;
Mike Stump1eb44332009-09-09 15:08:12 +00002864
Chris Lattner7db638d2009-04-11 19:42:43 +00002865 for (unsigned i = 0, e = Sel.getNumArgs(); i != e; ++i) {
John McCall58e46772009-10-23 21:48:59 +00002866 QualType ArgType;
John McCalla93c9342009-12-07 02:54:59 +00002867 TypeSourceInfo *DI;
Mike Stump1eb44332009-09-09 15:08:12 +00002868
Chris Lattnere294d3f2009-04-11 18:57:04 +00002869 if (ArgInfo[i].Type == 0) {
John McCall58e46772009-10-23 21:48:59 +00002870 ArgType = Context.getObjCIdType();
2871 DI = 0;
Chris Lattnere294d3f2009-04-11 18:57:04 +00002872 } else {
John McCall58e46772009-10-23 21:48:59 +00002873 ArgType = GetTypeFromParser(ArgInfo[i].Type, &DI);
Steve Naroff6082c622008-12-09 19:36:17 +00002874 // Perform the default array/function conversions (C99 6.7.5.3p[7,8]).
Douglas Gregor79e6bd32011-07-12 04:42:08 +00002875 ArgType = Context.getAdjustedParameterType(ArgType);
Chris Lattnere294d3f2009-04-11 18:57:04 +00002876 }
Mike Stump1eb44332009-09-09 15:08:12 +00002877
Fariborz Jahanian7f532532011-02-09 22:20:01 +00002878 LookupResult R(*this, ArgInfo[i].Name, ArgInfo[i].NameLoc,
2879 LookupOrdinaryName, ForRedeclaration);
2880 LookupName(R, S);
2881 if (R.isSingleResult()) {
2882 NamedDecl *PrevDecl = R.getFoundDecl();
2883 if (S->isDeclScope(PrevDecl)) {
Fariborz Jahanian90ba78c2011-03-12 18:54:30 +00002884 Diag(ArgInfo[i].NameLoc,
2885 (MethodDefinition ? diag::warn_method_param_redefinition
2886 : diag::warn_method_param_declaration))
Fariborz Jahanian7f532532011-02-09 22:20:01 +00002887 << ArgInfo[i].Name;
2888 Diag(PrevDecl->getLocation(),
2889 diag::note_previous_declaration);
2890 }
2891 }
2892
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00002893 SourceLocation StartLoc = DI
2894 ? DI->getTypeLoc().getBeginLoc()
2895 : ArgInfo[i].NameLoc;
2896
John McCall81ef3e62011-04-23 02:46:06 +00002897 ParmVarDecl* Param = CheckParameter(ObjCMethod, StartLoc,
2898 ArgInfo[i].NameLoc, ArgInfo[i].Name,
2899 ArgType, DI, SC_None, SC_None);
Mike Stump1eb44332009-09-09 15:08:12 +00002900
John McCall70798862011-05-02 00:30:12 +00002901 Param->setObjCMethodScopeInfo(i);
2902
Chris Lattner0ed844b2008-04-04 06:12:32 +00002903 Param->setObjCDeclQualifier(
Chris Lattnere294d3f2009-04-11 18:57:04 +00002904 CvtQTToAstBitMask(ArgInfo[i].DeclSpec.getObjCDeclQualifier()));
Mike Stump1eb44332009-09-09 15:08:12 +00002905
Chris Lattnerf97e8fa2009-04-11 19:34:56 +00002906 // Apply the attributes to the parameter.
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00002907 ProcessDeclAttributeList(TUScope, Param, ArgInfo[i].ArgAttrs);
Mike Stump1eb44332009-09-09 15:08:12 +00002908
Fariborz Jahanian47b1d962012-01-14 18:44:35 +00002909 if (Param->hasAttr<BlocksAttr>()) {
2910 Diag(Param->getLocation(), diag::err_block_on_nonlocal);
2911 Param->setInvalidDecl();
2912 }
Fariborz Jahanian7f532532011-02-09 22:20:01 +00002913 S->AddDecl(Param);
2914 IdResolver.AddDecl(Param);
2915
Chris Lattner0ed844b2008-04-04 06:12:32 +00002916 Params.push_back(Param);
2917 }
Fariborz Jahanian7f532532011-02-09 22:20:01 +00002918
Fariborz Jahanian4f4fd922010-04-08 00:30:06 +00002919 for (unsigned i = 0, e = CNumArgs; i != e; ++i) {
John McCalld226f652010-08-21 09:40:31 +00002920 ParmVarDecl *Param = cast<ParmVarDecl>(CParamInfo[i].Param);
Fariborz Jahanian4f4fd922010-04-08 00:30:06 +00002921 QualType ArgType = Param->getType();
2922 if (ArgType.isNull())
2923 ArgType = Context.getObjCIdType();
2924 else
2925 // Perform the default array/function conversions (C99 6.7.5.3p[7,8]).
Douglas Gregor79e6bd32011-07-12 04:42:08 +00002926 ArgType = Context.getAdjustedParameterType(ArgType);
John McCallc12c5bb2010-05-15 11:32:37 +00002927 if (ArgType->isObjCObjectType()) {
Fariborz Jahanian4f4fd922010-04-08 00:30:06 +00002928 Diag(Param->getLocation(),
2929 diag::err_object_cannot_be_passed_returned_by_value)
2930 << 1 << ArgType;
2931 Param->setInvalidDecl();
2932 }
2933 Param->setDeclContext(ObjCMethod);
Fariborz Jahanian7f532532011-02-09 22:20:01 +00002934
Fariborz Jahanian4f4fd922010-04-08 00:30:06 +00002935 Params.push_back(Param);
2936 }
2937
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +00002938 ObjCMethod->setMethodParams(Context, Params, SelectorLocs);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002939 ObjCMethod->setObjCDeclQualifier(
2940 CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier()));
Daniel Dunbar35682492008-09-26 04:12:28 +00002941
2942 if (AttrList)
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00002943 ProcessDeclAttributeList(TUScope, ObjCMethod, AttrList);
Mike Stump1eb44332009-09-09 15:08:12 +00002944
Douglas Gregorbdb2d502010-12-21 17:34:17 +00002945 // Add the method now.
John McCall6c2c2502011-07-22 02:45:48 +00002946 const ObjCMethodDecl *PrevMethod = 0;
2947 if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
Chris Lattner4d391482007-12-12 07:09:47 +00002948 if (MethodType == tok::minus) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002949 PrevMethod = ImpDecl->getInstanceMethod(Sel);
2950 ImpDecl->addInstanceMethod(ObjCMethod);
Chris Lattner4d391482007-12-12 07:09:47 +00002951 } else {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002952 PrevMethod = ImpDecl->getClassMethod(Sel);
2953 ImpDecl->addClassMethod(ObjCMethod);
Chris Lattner4d391482007-12-12 07:09:47 +00002954 }
Douglas Gregor926df6c2011-06-11 01:09:30 +00002955
Fariborz Jahanian7fda4002011-10-22 01:21:15 +00002956 ObjCMethodDecl *IMD = 0;
2957 if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface())
2958 IMD = IDecl->lookupMethod(ObjCMethod->getSelector(),
2959 ObjCMethod->isInstanceMethod());
Sean Huntcf807c42010-08-18 23:23:40 +00002960 if (ObjCMethod->hasAttrs() &&
Fariborz Jahanianec236782011-12-06 00:02:41 +00002961 containsInvalidMethodImplAttribute(IMD, ObjCMethod->getAttrs())) {
Fariborz Jahanian28441e62011-12-21 00:09:11 +00002962 SourceLocation MethodLoc = IMD->getLocation();
2963 if (!getSourceManager().isInSystemHeader(MethodLoc)) {
2964 Diag(EndLoc, diag::warn_attribute_method_def);
Ted Kremenek3306ec12012-02-27 22:55:11 +00002965 Diag(MethodLoc, diag::note_method_declared_at)
2966 << ObjCMethod->getDeclName();
Fariborz Jahanian28441e62011-12-21 00:09:11 +00002967 }
Fariborz Jahanianec236782011-12-06 00:02:41 +00002968 }
Douglas Gregorbdb2d502010-12-21 17:34:17 +00002969 } else {
2970 cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod);
Chris Lattner4d391482007-12-12 07:09:47 +00002971 }
John McCall6c2c2502011-07-22 02:45:48 +00002972
Chris Lattner4d391482007-12-12 07:09:47 +00002973 if (PrevMethod) {
2974 // You can never have two method definitions with the same name.
Chris Lattner5f4a6822008-11-23 23:12:31 +00002975 Diag(ObjCMethod->getLocation(), diag::err_duplicate_method_decl)
Chris Lattner077bf5e2008-11-24 03:33:13 +00002976 << ObjCMethod->getDeclName();
Chris Lattner5f4a6822008-11-23 23:12:31 +00002977 Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
Mike Stump1eb44332009-09-09 15:08:12 +00002978 }
John McCall54abf7d2009-11-04 02:18:39 +00002979
Douglas Gregor926df6c2011-06-11 01:09:30 +00002980 // If this Objective-C method does not have a related result type, but we
2981 // are allowed to infer related result types, try to do so based on the
2982 // method family.
2983 ObjCInterfaceDecl *CurrentClass = dyn_cast<ObjCInterfaceDecl>(ClassDecl);
2984 if (!CurrentClass) {
2985 if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl))
2986 CurrentClass = Cat->getClassInterface();
2987 else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(ClassDecl))
2988 CurrentClass = Impl->getClassInterface();
2989 else if (ObjCCategoryImplDecl *CatImpl
2990 = dyn_cast<ObjCCategoryImplDecl>(ClassDecl))
2991 CurrentClass = CatImpl->getClassInterface();
2992 }
John McCall6c2c2502011-07-22 02:45:48 +00002993
Douglas Gregore97179c2011-09-08 01:46:34 +00002994 ResultTypeCompatibilityKind RTC
2995 = CheckRelatedResultTypeCompatibility(*this, ObjCMethod, CurrentClass);
John McCall6c2c2502011-07-22 02:45:48 +00002996
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002997 CheckObjCMethodOverrides(ObjCMethod, CurrentClass, RTC);
John McCall6c2c2502011-07-22 02:45:48 +00002998
John McCallf85e1932011-06-15 23:02:42 +00002999 bool ARCError = false;
David Blaikie4e4d0842012-03-11 07:00:24 +00003000 if (getLangOpts().ObjCAutoRefCount)
John McCallf85e1932011-06-15 23:02:42 +00003001 ARCError = CheckARCMethodDecl(*this, ObjCMethod);
3002
Douglas Gregore97179c2011-09-08 01:46:34 +00003003 // Infer the related result type when possible.
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00003004 if (!ARCError && RTC == Sema::RTC_Compatible &&
Douglas Gregore97179c2011-09-08 01:46:34 +00003005 !ObjCMethod->hasRelatedResultType() &&
3006 LangOpts.ObjCInferRelatedResultType) {
Douglas Gregor926df6c2011-06-11 01:09:30 +00003007 bool InferRelatedResultType = false;
3008 switch (ObjCMethod->getMethodFamily()) {
3009 case OMF_None:
3010 case OMF_copy:
3011 case OMF_dealloc:
Nico Weber80cb6e62011-08-28 22:35:17 +00003012 case OMF_finalize:
Douglas Gregor926df6c2011-06-11 01:09:30 +00003013 case OMF_mutableCopy:
3014 case OMF_release:
3015 case OMF_retainCount:
Fariborz Jahanian9670e172011-07-05 22:38:59 +00003016 case OMF_performSelector:
Douglas Gregor926df6c2011-06-11 01:09:30 +00003017 break;
3018
3019 case OMF_alloc:
3020 case OMF_new:
3021 InferRelatedResultType = ObjCMethod->isClassMethod();
3022 break;
3023
3024 case OMF_init:
3025 case OMF_autorelease:
3026 case OMF_retain:
3027 case OMF_self:
3028 InferRelatedResultType = ObjCMethod->isInstanceMethod();
3029 break;
3030 }
3031
John McCall6c2c2502011-07-22 02:45:48 +00003032 if (InferRelatedResultType)
Douglas Gregor926df6c2011-06-11 01:09:30 +00003033 ObjCMethod->SetRelatedResultType();
Douglas Gregor926df6c2011-06-11 01:09:30 +00003034 }
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00003035
3036 ActOnDocumentableDecl(ObjCMethod);
3037
John McCalld226f652010-08-21 09:40:31 +00003038 return ObjCMethod;
Chris Lattner4d391482007-12-12 07:09:47 +00003039}
3040
Chris Lattnercc98eac2008-12-17 07:13:27 +00003041bool Sema::CheckObjCDeclScope(Decl *D) {
Fariborz Jahanian58a76492011-08-22 18:34:22 +00003042 // Following is also an error. But it is caused by a missing @end
3043 // and diagnostic is issued elsewhere.
Argyrios Kyrtzidisfce79eb2012-03-23 23:24:23 +00003044 if (isa<ObjCContainerDecl>(CurContext->getRedeclContext()))
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00003045 return false;
Argyrios Kyrtzidisfce79eb2012-03-23 23:24:23 +00003046
3047 // If we switched context to translation unit while we are still lexically in
3048 // an objc container, it means the parser missed emitting an error.
3049 if (isa<TranslationUnitDecl>(getCurLexicalContext()->getRedeclContext()))
3050 return false;
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00003051
Anders Carlsson15281452008-11-04 16:57:32 +00003052 Diag(D->getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope);
3053 D->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00003054
Anders Carlsson15281452008-11-04 16:57:32 +00003055 return true;
3056}
Chris Lattnercc98eac2008-12-17 07:13:27 +00003057
James Dennett1dfbd922012-06-14 21:40:34 +00003058/// Called whenever \@defs(ClassName) is encountered in the source. Inserts the
Chris Lattnercc98eac2008-12-17 07:13:27 +00003059/// instance variables of ClassName into Decls.
John McCalld226f652010-08-21 09:40:31 +00003060void Sema::ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
Chris Lattnercc98eac2008-12-17 07:13:27 +00003061 IdentifierInfo *ClassName,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003062 SmallVectorImpl<Decl*> &Decls) {
Chris Lattnercc98eac2008-12-17 07:13:27 +00003063 // Check that ClassName is a valid class
Douglas Gregorc83c6872010-04-15 22:33:43 +00003064 ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName, DeclStart);
Chris Lattnercc98eac2008-12-17 07:13:27 +00003065 if (!Class) {
3066 Diag(DeclStart, diag::err_undef_interface) << ClassName;
3067 return;
3068 }
John McCall260611a2012-06-20 06:18:46 +00003069 if (LangOpts.ObjCRuntime.isNonFragile()) {
Fariborz Jahanian0468fb92009-04-21 20:28:41 +00003070 Diag(DeclStart, diag::err_atdef_nonfragile_interface);
3071 return;
3072 }
Mike Stump1eb44332009-09-09 15:08:12 +00003073
Chris Lattnercc98eac2008-12-17 07:13:27 +00003074 // Collect the instance variables
Jordy Rosedb8264e2011-07-22 02:08:32 +00003075 SmallVector<const ObjCIvarDecl*, 32> Ivars;
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +00003076 Context.DeepCollectObjCIvars(Class, true, Ivars);
Fariborz Jahanian41833352009-06-04 17:08:55 +00003077 // For each ivar, create a fresh ObjCAtDefsFieldDecl.
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +00003078 for (unsigned i = 0; i < Ivars.size(); i++) {
Jordy Rosedb8264e2011-07-22 02:08:32 +00003079 const FieldDecl* ID = cast<FieldDecl>(Ivars[i]);
John McCalld226f652010-08-21 09:40:31 +00003080 RecordDecl *Record = dyn_cast<RecordDecl>(TagD);
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00003081 Decl *FD = ObjCAtDefsFieldDecl::Create(Context, Record,
3082 /*FIXME: StartL=*/ID->getLocation(),
3083 ID->getLocation(),
Fariborz Jahanian41833352009-06-04 17:08:55 +00003084 ID->getIdentifier(), ID->getType(),
3085 ID->getBitWidth());
John McCalld226f652010-08-21 09:40:31 +00003086 Decls.push_back(FD);
Fariborz Jahanian41833352009-06-04 17:08:55 +00003087 }
Mike Stump1eb44332009-09-09 15:08:12 +00003088
Chris Lattnercc98eac2008-12-17 07:13:27 +00003089 // Introduce all of these fields into the appropriate scope.
Chris Lattner5f9e2722011-07-23 10:55:15 +00003090 for (SmallVectorImpl<Decl*>::iterator D = Decls.begin();
Chris Lattnercc98eac2008-12-17 07:13:27 +00003091 D != Decls.end(); ++D) {
John McCalld226f652010-08-21 09:40:31 +00003092 FieldDecl *FD = cast<FieldDecl>(*D);
David Blaikie4e4d0842012-03-11 07:00:24 +00003093 if (getLangOpts().CPlusPlus)
Chris Lattnercc98eac2008-12-17 07:13:27 +00003094 PushOnScopeChains(cast<FieldDecl>(FD), S);
John McCalld226f652010-08-21 09:40:31 +00003095 else if (RecordDecl *Record = dyn_cast<RecordDecl>(TagD))
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003096 Record->addDecl(FD);
Chris Lattnercc98eac2008-12-17 07:13:27 +00003097 }
3098}
3099
Douglas Gregor160b5632010-04-26 17:32:49 +00003100/// \brief Build a type-check a new Objective-C exception variable declaration.
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00003101VarDecl *Sema::BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType T,
3102 SourceLocation StartLoc,
3103 SourceLocation IdLoc,
3104 IdentifierInfo *Id,
Douglas Gregor160b5632010-04-26 17:32:49 +00003105 bool Invalid) {
3106 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
3107 // duration shall not be qualified by an address-space qualifier."
3108 // Since all parameters have automatic store duration, they can not have
3109 // an address space.
3110 if (T.getAddressSpace() != 0) {
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00003111 Diag(IdLoc, diag::err_arg_with_address_space);
Douglas Gregor160b5632010-04-26 17:32:49 +00003112 Invalid = true;
3113 }
3114
3115 // An @catch parameter must be an unqualified object pointer type;
3116 // FIXME: Recover from "NSObject foo" by inserting the * in "NSObject *foo"?
3117 if (Invalid) {
3118 // Don't do any further checking.
Douglas Gregorbe270a02010-04-26 17:57:08 +00003119 } else if (T->isDependentType()) {
3120 // Okay: we don't know what this type will instantiate to.
Douglas Gregor160b5632010-04-26 17:32:49 +00003121 } else if (!T->isObjCObjectPointerType()) {
3122 Invalid = true;
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00003123 Diag(IdLoc ,diag::err_catch_param_not_objc_type);
Douglas Gregor160b5632010-04-26 17:32:49 +00003124 } else if (T->isObjCQualifiedIdType()) {
3125 Invalid = true;
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00003126 Diag(IdLoc, diag::err_illegal_qualifiers_on_catch_parm);
Douglas Gregor160b5632010-04-26 17:32:49 +00003127 }
3128
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00003129 VarDecl *New = VarDecl::Create(Context, CurContext, StartLoc, IdLoc, Id,
3130 T, TInfo, SC_None, SC_None);
Douglas Gregor324b54d2010-05-03 18:51:14 +00003131 New->setExceptionVariable(true);
3132
Douglas Gregor9aab9c42011-12-10 01:22:52 +00003133 // In ARC, infer 'retaining' for variables of retainable type.
David Blaikie4e4d0842012-03-11 07:00:24 +00003134 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(New))
Douglas Gregor9aab9c42011-12-10 01:22:52 +00003135 Invalid = true;
3136
Douglas Gregor160b5632010-04-26 17:32:49 +00003137 if (Invalid)
3138 New->setInvalidDecl();
3139 return New;
3140}
3141
John McCalld226f652010-08-21 09:40:31 +00003142Decl *Sema::ActOnObjCExceptionDecl(Scope *S, Declarator &D) {
Douglas Gregor160b5632010-04-26 17:32:49 +00003143 const DeclSpec &DS = D.getDeclSpec();
3144
3145 // We allow the "register" storage class on exception variables because
3146 // GCC did, but we drop it completely. Any other storage class is an error.
3147 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
3148 Diag(DS.getStorageClassSpecLoc(), diag::warn_register_objc_catch_parm)
3149 << FixItHint::CreateRemoval(SourceRange(DS.getStorageClassSpecLoc()));
3150 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
3151 Diag(DS.getStorageClassSpecLoc(), diag::err_storage_spec_on_catch_parm)
3152 << DS.getStorageClassSpec();
3153 }
3154 if (D.getDeclSpec().isThreadSpecified())
3155 Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
3156 D.getMutableDeclSpec().ClearStorageClassSpecs();
3157
3158 DiagnoseFunctionSpecifiers(D);
3159
3160 // Check that there are no default arguments inside the type of this
3161 // exception object (C++ only).
David Blaikie4e4d0842012-03-11 07:00:24 +00003162 if (getLangOpts().CPlusPlus)
Douglas Gregor160b5632010-04-26 17:32:49 +00003163 CheckExtraCXXDefaultArguments(D);
3164
Argyrios Kyrtzidis32153982011-06-28 03:01:15 +00003165 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
John McCallbf1a0282010-06-04 23:28:52 +00003166 QualType ExceptionType = TInfo->getType();
Douglas Gregor160b5632010-04-26 17:32:49 +00003167
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00003168 VarDecl *New = BuildObjCExceptionDecl(TInfo, ExceptionType,
3169 D.getSourceRange().getBegin(),
3170 D.getIdentifierLoc(),
3171 D.getIdentifier(),
Douglas Gregor160b5632010-04-26 17:32:49 +00003172 D.isInvalidType());
3173
3174 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
3175 if (D.getCXXScopeSpec().isSet()) {
3176 Diag(D.getIdentifierLoc(), diag::err_qualified_objc_catch_parm)
3177 << D.getCXXScopeSpec().getRange();
3178 New->setInvalidDecl();
3179 }
3180
3181 // Add the parameter declaration into this scope.
John McCalld226f652010-08-21 09:40:31 +00003182 S->AddDecl(New);
Douglas Gregor160b5632010-04-26 17:32:49 +00003183 if (D.getIdentifier())
3184 IdResolver.AddDecl(New);
3185
3186 ProcessDeclAttributes(S, New, D);
3187
3188 if (New->hasAttr<BlocksAttr>())
3189 Diag(New->getLocation(), diag::err_block_on_nonlocal);
John McCalld226f652010-08-21 09:40:31 +00003190 return New;
Douglas Gregor4e6c0d12010-04-23 23:01:43 +00003191}
Fariborz Jahanian786cd152010-04-27 17:18:58 +00003192
3193/// CollectIvarsToConstructOrDestruct - Collect those ivars which require
Fariborz Jahaniane4498c62010-04-28 16:11:27 +00003194/// initialization.
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +00003195void Sema::CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003196 SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +00003197 for (ObjCIvarDecl *Iv = OI->all_declared_ivar_begin(); Iv;
3198 Iv= Iv->getNextIvar()) {
Fariborz Jahanian786cd152010-04-27 17:18:58 +00003199 QualType QT = Context.getBaseElementType(Iv->getType());
Douglas Gregor68dd3ee2010-05-20 02:24:22 +00003200 if (QT->isRecordType())
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +00003201 Ivars.push_back(Iv);
Fariborz Jahanian786cd152010-04-27 17:18:58 +00003202 }
3203}
Fariborz Jahaniane4498c62010-04-28 16:11:27 +00003204
Fariborz Jahanian3fe10412010-07-22 18:24:20 +00003205void Sema::DiagnoseUseOfUnimplementedSelectors() {
Douglas Gregor5b9dc7c2011-07-28 14:54:22 +00003206 // Load referenced selectors from the external source.
3207 if (ExternalSource) {
3208 SmallVector<std::pair<Selector, SourceLocation>, 4> Sels;
3209 ExternalSource->ReadReferencedSelectors(Sels);
3210 for (unsigned I = 0, N = Sels.size(); I != N; ++I)
3211 ReferencedSelectors[Sels[I].first] = Sels[I].second;
3212 }
3213
Fariborz Jahanian8b789132011-02-04 23:19:27 +00003214 // Warning will be issued only when selector table is
3215 // generated (which means there is at lease one implementation
3216 // in the TU). This is to match gcc's behavior.
3217 if (ReferencedSelectors.empty() ||
3218 !Context.AnyObjCImplementation())
Fariborz Jahanian3fe10412010-07-22 18:24:20 +00003219 return;
3220 for (llvm::DenseMap<Selector, SourceLocation>::iterator S =
3221 ReferencedSelectors.begin(),
3222 E = ReferencedSelectors.end(); S != E; ++S) {
3223 Selector Sel = (*S).first;
3224 if (!LookupImplementedMethodInGlobalPool(Sel))
3225 Diag((*S).second, diag::warn_unimplemented_selector) << Sel;
3226 }
3227 return;
3228}