clang  3.8.0
SemaDeclObjC.cpp
Go to the documentation of this file.
1 //===--- SemaDeclObjC.cpp - Semantic Analysis for ObjC Declarations -------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements semantic analysis for Objective C declarations.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprObjC.h"
23 #include "clang/Sema/DeclSpec.h"
25 #include "clang/Sema/Lookup.h"
26 #include "clang/Sema/Scope.h"
27 #include "clang/Sema/ScopeInfo.h"
28 #include "llvm/ADT/DenseMap.h"
29 #include "llvm/ADT/DenseSet.h"
30 #include "TypeLocBuilder.h"
31 
32 using namespace clang;
33 
34 /// Check whether the given method, which must be in the 'init'
35 /// family, is a valid member of that family.
36 ///
37 /// \param receiverTypeIfCall - if null, check this as if declaring it;
38 /// if non-null, check this as if making a call to it with the given
39 /// receiver type
40 ///
41 /// \return true to indicate that there was an error and appropriate
42 /// actions were taken
44  QualType receiverTypeIfCall) {
45  if (method->isInvalidDecl()) return true;
46 
47  // This castAs is safe: methods that don't return an object
48  // pointer won't be inferred as inits and will reject an explicit
49  // objc_method_family(init).
50 
51  // We ignore protocols here. Should we? What about Class?
52 
53  const ObjCObjectType *result =
55 
56  if (result->isObjCId()) {
57  return false;
58  } else if (result->isObjCClass()) {
59  // fall through: always an error
60  } else {
61  ObjCInterfaceDecl *resultClass = result->getInterface();
62  assert(resultClass && "unexpected object type!");
63 
64  // It's okay for the result type to still be a forward declaration
65  // if we're checking an interface declaration.
66  if (!resultClass->hasDefinition()) {
67  if (receiverTypeIfCall.isNull() &&
68  !isa<ObjCImplementationDecl>(method->getDeclContext()))
69  return false;
70 
71  // Otherwise, we try to compare class types.
72  } else {
73  // If this method was declared in a protocol, we can't check
74  // anything unless we have a receiver type that's an interface.
75  const ObjCInterfaceDecl *receiverClass = nullptr;
76  if (isa<ObjCProtocolDecl>(method->getDeclContext())) {
77  if (receiverTypeIfCall.isNull())
78  return false;
79 
80  receiverClass = receiverTypeIfCall->castAs<ObjCObjectPointerType>()
81  ->getInterfaceDecl();
82 
83  // This can be null for calls to e.g. id<Foo>.
84  if (!receiverClass) return false;
85  } else {
86  receiverClass = method->getClassInterface();
87  assert(receiverClass && "method not associated with a class!");
88  }
89 
90  // If either class is a subclass of the other, it's fine.
91  if (receiverClass->isSuperClassOf(resultClass) ||
92  resultClass->isSuperClassOf(receiverClass))
93  return false;
94  }
95  }
96 
97  SourceLocation loc = method->getLocation();
98 
99  // If we're in a system header, and this is not a call, just make
100  // the method unusable.
101  if (receiverTypeIfCall.isNull() && getSourceManager().isInSystemHeader(loc)) {
102  method->addAttr(UnavailableAttr::CreateImplicit(Context, "",
103  UnavailableAttr::IR_ARCInitReturnsUnrelated, loc));
104  return true;
105  }
106 
107  // Otherwise, it's an error.
108  Diag(loc, diag::err_arc_init_method_unrelated_result_type);
109  method->setInvalidDecl();
110  return true;
111 }
112 
114  const ObjCMethodDecl *Overridden) {
115  if (Overridden->hasRelatedResultType() &&
116  !NewMethod->hasRelatedResultType()) {
117  // This can only happen when the method follows a naming convention that
118  // implies a related result type, and the original (overridden) method has
119  // a suitable return type, but the new (overriding) method does not have
120  // a suitable return type.
121  QualType ResultType = NewMethod->getReturnType();
122  SourceRange ResultTypeRange = NewMethod->getReturnTypeSourceRange();
123 
124  // Figure out which class this method is part of, if any.
125  ObjCInterfaceDecl *CurrentClass
126  = dyn_cast<ObjCInterfaceDecl>(NewMethod->getDeclContext());
127  if (!CurrentClass) {
128  DeclContext *DC = NewMethod->getDeclContext();
129  if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(DC))
130  CurrentClass = Cat->getClassInterface();
131  else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(DC))
132  CurrentClass = Impl->getClassInterface();
133  else if (ObjCCategoryImplDecl *CatImpl
134  = dyn_cast<ObjCCategoryImplDecl>(DC))
135  CurrentClass = CatImpl->getClassInterface();
136  }
137 
138  if (CurrentClass) {
139  Diag(NewMethod->getLocation(),
140  diag::warn_related_result_type_compatibility_class)
141  << Context.getObjCInterfaceType(CurrentClass)
142  << ResultType
143  << ResultTypeRange;
144  } else {
145  Diag(NewMethod->getLocation(),
146  diag::warn_related_result_type_compatibility_protocol)
147  << ResultType
148  << ResultTypeRange;
149  }
150 
151  if (ObjCMethodFamily Family = Overridden->getMethodFamily())
152  Diag(Overridden->getLocation(),
153  diag::note_related_result_type_family)
154  << /*overridden method*/ 0
155  << Family;
156  else
157  Diag(Overridden->getLocation(),
158  diag::note_related_result_type_overridden);
159  }
160  if (getLangOpts().ObjCAutoRefCount) {
161  if ((NewMethod->hasAttr<NSReturnsRetainedAttr>() !=
162  Overridden->hasAttr<NSReturnsRetainedAttr>())) {
163  Diag(NewMethod->getLocation(),
164  diag::err_nsreturns_retained_attribute_mismatch) << 1;
165  Diag(Overridden->getLocation(), diag::note_previous_decl)
166  << "method";
167  }
168  if ((NewMethod->hasAttr<NSReturnsNotRetainedAttr>() !=
169  Overridden->hasAttr<NSReturnsNotRetainedAttr>())) {
170  Diag(NewMethod->getLocation(),
171  diag::err_nsreturns_retained_attribute_mismatch) << 0;
172  Diag(Overridden->getLocation(), diag::note_previous_decl)
173  << "method";
174  }
176  oe = Overridden->param_end();
178  ni = NewMethod->param_begin(), ne = NewMethod->param_end();
179  ni != ne && oi != oe; ++ni, ++oi) {
180  const ParmVarDecl *oldDecl = (*oi);
181  ParmVarDecl *newDecl = (*ni);
182  if (newDecl->hasAttr<NSConsumedAttr>() !=
183  oldDecl->hasAttr<NSConsumedAttr>()) {
184  Diag(newDecl->getLocation(),
185  diag::err_nsconsumed_attribute_mismatch);
186  Diag(oldDecl->getLocation(), diag::note_previous_decl)
187  << "parameter";
188  }
189  }
190  }
191 }
192 
193 /// \brief Check a method declaration for compatibility with the Objective-C
194 /// ARC conventions.
196  ObjCMethodFamily family = method->getMethodFamily();
197  switch (family) {
198  case OMF_None:
199  case OMF_finalize:
200  case OMF_retain:
201  case OMF_release:
202  case OMF_autorelease:
203  case OMF_retainCount:
204  case OMF_self:
205  case OMF_initialize:
206  case OMF_performSelector:
207  return false;
208 
209  case OMF_dealloc:
210  if (!Context.hasSameType(method->getReturnType(), Context.VoidTy)) {
211  SourceRange ResultTypeRange = method->getReturnTypeSourceRange();
212  if (ResultTypeRange.isInvalid())
213  Diag(method->getLocation(), diag::error_dealloc_bad_result_type)
214  << method->getReturnType()
215  << FixItHint::CreateInsertion(method->getSelectorLoc(0), "(void)");
216  else
217  Diag(method->getLocation(), diag::error_dealloc_bad_result_type)
218  << method->getReturnType()
219  << FixItHint::CreateReplacement(ResultTypeRange, "void");
220  return true;
221  }
222  return false;
223 
224  case OMF_init:
225  // If the method doesn't obey the init rules, don't bother annotating it.
226  if (checkInitMethod(method, QualType()))
227  return true;
228 
229  method->addAttr(NSConsumesSelfAttr::CreateImplicit(Context));
230 
231  // Don't add a second copy of this attribute, but otherwise don't
232  // let it be suppressed.
233  if (method->hasAttr<NSReturnsRetainedAttr>())
234  return false;
235  break;
236 
237  case OMF_alloc:
238  case OMF_copy:
239  case OMF_mutableCopy:
240  case OMF_new:
241  if (method->hasAttr<NSReturnsRetainedAttr>() ||
242  method->hasAttr<NSReturnsNotRetainedAttr>() ||
243  method->hasAttr<NSReturnsAutoreleasedAttr>())
244  return false;
245  break;
246  }
247 
248  method->addAttr(NSReturnsRetainedAttr::CreateImplicit(Context));
249  return false;
250 }
251 
253  NamedDecl *ND,
254  SourceLocation ImplLoc,
255  int select) {
256  if (ND && ND->isDeprecated()) {
257  S.Diag(ImplLoc, diag::warn_deprecated_def) << select;
258  if (select == 0)
259  S.Diag(ND->getLocation(), diag::note_method_declared_at)
260  << ND->getDeclName();
261  else
262  S.Diag(ND->getLocation(), diag::note_previous_decl) << "class";
263  }
264 }
265 
266 /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
267 /// pool.
269  ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D);
270 
271  // If we don't have a valid method decl, simply return.
272  if (!MDecl)
273  return;
274  if (MDecl->isInstanceMethod())
275  AddInstanceMethodToGlobalPool(MDecl, true);
276  else
277  AddFactoryMethodToGlobalPool(MDecl, true);
278 }
279 
280 /// HasExplicitOwnershipAttr - returns true when pointer to ObjC pointer
281 /// has explicit ownership attribute; false otherwise.
282 static bool
284  QualType T = Param->getType();
285 
286  if (const PointerType *PT = T->getAs<PointerType>()) {
287  T = PT->getPointeeType();
288  } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
289  T = RT->getPointeeType();
290  } else {
291  return true;
292  }
293 
294  // If we have a lifetime qualifier, but it's local, we must have
295  // inferred it. So, it is implicit.
296  return !T.getLocalQualifiers().hasObjCLifetime();
297 }
298 
299 /// ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible
300 /// and user declared, in the method definition's AST.
302  assert((getCurMethodDecl() == nullptr) && "Methodparsing confused");
303  ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D);
304 
305  // If we don't have a valid method decl, simply return.
306  if (!MDecl)
307  return;
308 
309  // Allow all of Sema to see that we are entering a method definition.
310  PushDeclContext(FnBodyScope, MDecl);
312 
313  // Create Decl objects for each parameter, entrring them in the scope for
314  // binding to their use.
315 
316  // Insert the invisible arguments, self and _cmd!
318 
319  PushOnScopeChains(MDecl->getSelfDecl(), FnBodyScope);
320  PushOnScopeChains(MDecl->getCmdDecl(), FnBodyScope);
321 
322  // The ObjC parser requires parameter names so there's no need to check.
324  /*CheckParameterNames=*/false);
325 
326  // Introduce all of the other parameters into this scope.
327  for (auto *Param : MDecl->params()) {
328  if (!Param->isInvalidDecl() &&
329  getLangOpts().ObjCAutoRefCount &&
330  !HasExplicitOwnershipAttr(*this, Param))
331  Diag(Param->getLocation(), diag::warn_arc_strong_pointer_objc_pointer) <<
332  Param->getType();
333 
334  if (Param->getIdentifier())
335  PushOnScopeChains(Param, FnBodyScope);
336  }
337 
338  // In ARC, disallow definition of retain/release/autorelease/retainCount
339  if (getLangOpts().ObjCAutoRefCount) {
340  switch (MDecl->getMethodFamily()) {
341  case OMF_retain:
342  case OMF_retainCount:
343  case OMF_release:
344  case OMF_autorelease:
345  Diag(MDecl->getLocation(), diag::err_arc_illegal_method_def)
346  << 0 << MDecl->getSelector();
347  break;
348 
349  case OMF_None:
350  case OMF_dealloc:
351  case OMF_finalize:
352  case OMF_alloc:
353  case OMF_init:
354  case OMF_mutableCopy:
355  case OMF_copy:
356  case OMF_new:
357  case OMF_self:
358  case OMF_initialize:
359  case OMF_performSelector:
360  break;
361  }
362  }
363 
364  // Warn on deprecated methods under -Wdeprecated-implementations,
365  // and prepare for warning on missing super calls.
366  if (ObjCInterfaceDecl *IC = MDecl->getClassInterface()) {
367  ObjCMethodDecl *IMD =
368  IC->lookupMethod(MDecl->getSelector(), MDecl->isInstanceMethod());
369 
370  if (IMD) {
371  ObjCImplDecl *ImplDeclOfMethodDef =
372  dyn_cast<ObjCImplDecl>(MDecl->getDeclContext());
373  ObjCContainerDecl *ContDeclOfMethodDecl =
374  dyn_cast<ObjCContainerDecl>(IMD->getDeclContext());
375  ObjCImplDecl *ImplDeclOfMethodDecl = nullptr;
376  if (ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(ContDeclOfMethodDecl))
377  ImplDeclOfMethodDecl = OID->getImplementation();
378  else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ContDeclOfMethodDecl)) {
379  if (CD->IsClassExtension()) {
380  if (ObjCInterfaceDecl *OID = CD->getClassInterface())
381  ImplDeclOfMethodDecl = OID->getImplementation();
382  } else
383  ImplDeclOfMethodDecl = CD->getImplementation();
384  }
385  // No need to issue deprecated warning if deprecated mehod in class/category
386  // is being implemented in its own implementation (no overriding is involved).
387  if (!ImplDeclOfMethodDecl || ImplDeclOfMethodDecl != ImplDeclOfMethodDef)
389  dyn_cast<NamedDecl>(IMD),
390  MDecl->getLocation(), 0);
391  }
392 
393  if (MDecl->getMethodFamily() == OMF_init) {
397  IC->getSuperClass() != nullptr;
398  } else if (IC->hasDesignatedInitializers()) {
401  }
402  }
403 
404  // If this is "dealloc" or "finalize", set some bit here.
405  // Then in ActOnSuperMessage() (SemaExprObjC), set it back to false.
406  // Finally, in ActOnFinishFunctionBody() (SemaDecl), warn if flag is set.
407  // Only do this if the current class actually has a superclass.
408  if (const ObjCInterfaceDecl *SuperClass = IC->getSuperClass()) {
409  ObjCMethodFamily Family = MDecl->getMethodFamily();
410  if (Family == OMF_dealloc) {
411  if (!(getLangOpts().ObjCAutoRefCount ||
412  getLangOpts().getGC() == LangOptions::GCOnly))
414 
415  } else if (Family == OMF_finalize) {
416  if (Context.getLangOpts().getGC() != LangOptions::NonGC)
418 
419  } else {
420  const ObjCMethodDecl *SuperMethod =
421  SuperClass->lookupMethod(MDecl->getSelector(),
422  MDecl->isInstanceMethod());
424  (SuperMethod && SuperMethod->hasAttr<ObjCRequiresSuperAttr>());
425  }
426  }
427  }
428 }
429 
430 namespace {
431 
432 // Callback to only accept typo corrections that are Objective-C classes.
433 // If an ObjCInterfaceDecl* is given to the constructor, then the validation
434 // function will reject corrections to that class.
435 class ObjCInterfaceValidatorCCC : public CorrectionCandidateCallback {
436  public:
437  ObjCInterfaceValidatorCCC() : CurrentIDecl(nullptr) {}
438  explicit ObjCInterfaceValidatorCCC(ObjCInterfaceDecl *IDecl)
439  : CurrentIDecl(IDecl) {}
440 
441  bool ValidateCandidate(const TypoCorrection &candidate) override {
443  return ID && !declaresSameEntity(ID, CurrentIDecl);
444  }
445 
446  private:
447  ObjCInterfaceDecl *CurrentIDecl;
448 };
449 
450 } // end anonymous namespace
451 
452 static void diagnoseUseOfProtocols(Sema &TheSema,
453  ObjCContainerDecl *CD,
454  ObjCProtocolDecl *const *ProtoRefs,
455  unsigned NumProtoRefs,
456  const SourceLocation *ProtoLocs) {
457  assert(ProtoRefs);
458  // Diagnose availability in the context of the ObjC container.
459  Sema::ContextRAII SavedContext(TheSema, CD);
460  for (unsigned i = 0; i < NumProtoRefs; ++i) {
461  (void)TheSema.DiagnoseUseOfDecl(ProtoRefs[i], ProtoLocs[i]);
462  }
463 }
464 
465 void Sema::
467  SourceLocation AtInterfaceLoc,
468  ObjCInterfaceDecl *IDecl,
469  IdentifierInfo *ClassName,
470  SourceLocation ClassLoc,
471  IdentifierInfo *SuperName,
472  SourceLocation SuperLoc,
473  ArrayRef<ParsedType> SuperTypeArgs,
474  SourceRange SuperTypeArgsRange) {
475  // Check if a different kind of symbol declared in this scope.
476  NamedDecl *PrevDecl = LookupSingleName(TUScope, SuperName, SuperLoc,
478 
479  if (!PrevDecl) {
480  // Try to correct for a typo in the superclass name without correcting
481  // to the class we're defining.
482  if (TypoCorrection Corrected = CorrectTypo(
483  DeclarationNameInfo(SuperName, SuperLoc),
485  nullptr, llvm::make_unique<ObjCInterfaceValidatorCCC>(IDecl),
487  diagnoseTypo(Corrected, PDiag(diag::err_undef_superclass_suggest)
488  << SuperName << ClassName);
489  PrevDecl = Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>();
490  }
491  }
492 
493  if (declaresSameEntity(PrevDecl, IDecl)) {
494  Diag(SuperLoc, diag::err_recursive_superclass)
495  << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
496  IDecl->setEndOfDefinitionLoc(ClassLoc);
497  } else {
498  ObjCInterfaceDecl *SuperClassDecl =
499  dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
500  QualType SuperClassType;
501 
502  // Diagnose classes that inherit from deprecated classes.
503  if (SuperClassDecl) {
504  (void)DiagnoseUseOfDecl(SuperClassDecl, SuperLoc);
505  SuperClassType = Context.getObjCInterfaceType(SuperClassDecl);
506  }
507 
508  if (PrevDecl && !SuperClassDecl) {
509  // The previous declaration was not a class decl. Check if we have a
510  // typedef. If we do, get the underlying class type.
511  if (const TypedefNameDecl *TDecl =
512  dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
513  QualType T = TDecl->getUnderlyingType();
514  if (T->isObjCObjectType()) {
515  if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface()) {
516  SuperClassDecl = dyn_cast<ObjCInterfaceDecl>(IDecl);
517  SuperClassType = Context.getTypeDeclType(TDecl);
518 
519  // This handles the following case:
520  // @interface NewI @end
521  // typedef NewI DeprI __attribute__((deprecated("blah")))
522  // @interface SI : DeprI /* warn here */ @end
523  (void)DiagnoseUseOfDecl(const_cast<TypedefNameDecl*>(TDecl), SuperLoc);
524  }
525  }
526  }
527 
528  // This handles the following case:
529  //
530  // typedef int SuperClass;
531  // @interface MyClass : SuperClass {} @end
532  //
533  if (!SuperClassDecl) {
534  Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName;
535  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
536  }
537  }
538 
539  if (!dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
540  if (!SuperClassDecl)
541  Diag(SuperLoc, diag::err_undef_superclass)
542  << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
543  else if (RequireCompleteType(SuperLoc,
544  SuperClassType,
545  diag::err_forward_superclass,
546  SuperClassDecl->getDeclName(),
547  ClassName,
548  SourceRange(AtInterfaceLoc, ClassLoc))) {
549  SuperClassDecl = nullptr;
550  SuperClassType = QualType();
551  }
552  }
553 
554  if (SuperClassType.isNull()) {
555  assert(!SuperClassDecl && "Failed to set SuperClassType?");
556  return;
557  }
558 
559  // Handle type arguments on the superclass.
560  TypeSourceInfo *SuperClassTInfo = nullptr;
561  if (!SuperTypeArgs.empty()) {
563  S,
564  SuperLoc,
565  CreateParsedType(SuperClassType,
566  nullptr),
567  SuperTypeArgsRange.getBegin(),
568  SuperTypeArgs,
569  SuperTypeArgsRange.getEnd(),
570  SourceLocation(),
571  { },
572  { },
573  SourceLocation());
574  if (!fullSuperClassType.isUsable())
575  return;
576 
577  SuperClassType = GetTypeFromParser(fullSuperClassType.get(),
578  &SuperClassTInfo);
579  }
580 
581  if (!SuperClassTInfo) {
582  SuperClassTInfo = Context.getTrivialTypeSourceInfo(SuperClassType,
583  SuperLoc);
584  }
585 
586  IDecl->setSuperClass(SuperClassTInfo);
587  IDecl->setEndOfDefinitionLoc(SuperClassTInfo->getTypeLoc().getLocEnd());
588  }
589 }
590 
592  ObjCTypeParamVariance variance,
593  SourceLocation varianceLoc,
594  unsigned index,
595  IdentifierInfo *paramName,
596  SourceLocation paramLoc,
597  SourceLocation colonLoc,
598  ParsedType parsedTypeBound) {
599  // If there was an explicitly-provided type bound, check it.
600  TypeSourceInfo *typeBoundInfo = nullptr;
601  if (parsedTypeBound) {
602  // The type bound can be any Objective-C pointer type.
603  QualType typeBound = GetTypeFromParser(parsedTypeBound, &typeBoundInfo);
604  if (typeBound->isObjCObjectPointerType()) {
605  // okay
606  } else if (typeBound->isObjCObjectType()) {
607  // The user forgot the * on an Objective-C pointer type, e.g.,
608  // "T : NSView".
610  typeBoundInfo->getTypeLoc().getEndLoc());
611  Diag(typeBoundInfo->getTypeLoc().getBeginLoc(),
612  diag::err_objc_type_param_bound_missing_pointer)
613  << typeBound << paramName
614  << FixItHint::CreateInsertion(starLoc, " *");
615 
616  // Create a new type location builder so we can update the type
617  // location information we have.
618  TypeLocBuilder builder;
619  builder.pushFullCopy(typeBoundInfo->getTypeLoc());
620 
621  // Create the Objective-C pointer type.
622  typeBound = Context.getObjCObjectPointerType(typeBound);
624  = builder.push<ObjCObjectPointerTypeLoc>(typeBound);
625  newT.setStarLoc(starLoc);
626 
627  // Form the new type source information.
628  typeBoundInfo = builder.getTypeSourceInfo(Context, typeBound);
629  } else {
630  // Not a valid type bound.
631  Diag(typeBoundInfo->getTypeLoc().getBeginLoc(),
632  diag::err_objc_type_param_bound_nonobject)
633  << typeBound << paramName;
634 
635  // Forget the bound; we'll default to id later.
636  typeBoundInfo = nullptr;
637  }
638 
639  // Type bounds cannot have qualifiers (even indirectly) or explicit
640  // nullability.
641  if (typeBoundInfo) {
642  QualType typeBound = typeBoundInfo->getType();
643  TypeLoc qual = typeBoundInfo->getTypeLoc().findExplicitQualifierLoc();
644  if (qual || typeBound.hasQualifiers()) {
645  bool diagnosed = false;
646  SourceRange rangeToRemove;
647  if (qual) {
648  if (auto attr = qual.getAs<AttributedTypeLoc>()) {
649  rangeToRemove = attr.getLocalSourceRange();
650  if (attr.getTypePtr()->getImmediateNullability()) {
651  Diag(attr.getLocStart(),
652  diag::err_objc_type_param_bound_explicit_nullability)
653  << paramName << typeBound
654  << FixItHint::CreateRemoval(rangeToRemove);
655  diagnosed = true;
656  }
657  }
658  }
659 
660  if (!diagnosed) {
661  Diag(qual ? qual.getLocStart()
662  : typeBoundInfo->getTypeLoc().getLocStart(),
663  diag::err_objc_type_param_bound_qualified)
664  << paramName << typeBound << typeBound.getQualifiers().getAsString()
665  << FixItHint::CreateRemoval(rangeToRemove);
666  }
667 
668  // If the type bound has qualifiers other than CVR, we need to strip
669  // them or we'll probably assert later when trying to apply new
670  // qualifiers.
671  Qualifiers quals = typeBound.getQualifiers();
672  quals.removeCVRQualifiers();
673  if (!quals.empty()) {
674  typeBoundInfo =
676  }
677  }
678  }
679  }
680 
681  // If there was no explicit type bound (or we removed it due to an error),
682  // use 'id' instead.
683  if (!typeBoundInfo) {
684  colonLoc = SourceLocation();
686  }
687 
688  // Create the type parameter.
689  return ObjCTypeParamDecl::Create(Context, CurContext, variance, varianceLoc,
690  index, paramLoc, paramName, colonLoc,
691  typeBoundInfo);
692 }
693 
695  SourceLocation lAngleLoc,
696  ArrayRef<Decl *> typeParamsIn,
697  SourceLocation rAngleLoc) {
698  // We know that the array only contains Objective-C type parameters.
700  typeParams(
701  reinterpret_cast<ObjCTypeParamDecl * const *>(typeParamsIn.data()),
702  typeParamsIn.size());
703 
704  // Diagnose redeclarations of type parameters.
705  // We do this now because Objective-C type parameters aren't pushed into
706  // scope until later (after the instance variable block), but we want the
707  // diagnostics to occur right after we parse the type parameter list.
708  llvm::SmallDenseMap<IdentifierInfo *, ObjCTypeParamDecl *> knownParams;
709  for (auto typeParam : typeParams) {
710  auto known = knownParams.find(typeParam->getIdentifier());
711  if (known != knownParams.end()) {
712  Diag(typeParam->getLocation(), diag::err_objc_type_param_redecl)
713  << typeParam->getIdentifier()
714  << SourceRange(known->second->getLocation());
715 
716  typeParam->setInvalidDecl();
717  } else {
718  knownParams.insert(std::make_pair(typeParam->getIdentifier(), typeParam));
719 
720  // Push the type parameter into scope.
721  PushOnScopeChains(typeParam, S, /*AddToContext=*/false);
722  }
723  }
724 
725  // Create the parameter list.
726  return ObjCTypeParamList::create(Context, lAngleLoc, typeParams, rAngleLoc);
727 }
728 
730  for (auto typeParam : *typeParamList) {
731  if (!typeParam->isInvalidDecl()) {
732  S->RemoveDecl(typeParam);
733  IdResolver.RemoveDecl(typeParam);
734  }
735  }
736 }
737 
738 namespace {
739  /// The context in which an Objective-C type parameter list occurs, for use
740  /// in diagnostics.
741  enum class TypeParamListContext {
742  ForwardDeclaration,
743  Definition,
744  Category,
745  Extension
746  };
747 } // end anonymous namespace
748 
749 /// Check consistency between two Objective-C type parameter lists, e.g.,
750 /// between a category/extension and an \@interface or between an \@class and an
751 /// \@interface.
753  ObjCTypeParamList *prevTypeParams,
754  ObjCTypeParamList *newTypeParams,
755  TypeParamListContext newContext) {
756  // If the sizes don't match, complain about that.
757  if (prevTypeParams->size() != newTypeParams->size()) {
758  SourceLocation diagLoc;
759  if (newTypeParams->size() > prevTypeParams->size()) {
760  diagLoc = newTypeParams->begin()[prevTypeParams->size()]->getLocation();
761  } else {
762  diagLoc = S.getLocForEndOfToken(newTypeParams->back()->getLocEnd());
763  }
764 
765  S.Diag(diagLoc, diag::err_objc_type_param_arity_mismatch)
766  << static_cast<unsigned>(newContext)
767  << (newTypeParams->size() > prevTypeParams->size())
768  << prevTypeParams->size()
769  << newTypeParams->size();
770 
771  return true;
772  }
773 
774  // Match up the type parameters.
775  for (unsigned i = 0, n = prevTypeParams->size(); i != n; ++i) {
776  ObjCTypeParamDecl *prevTypeParam = prevTypeParams->begin()[i];
777  ObjCTypeParamDecl *newTypeParam = newTypeParams->begin()[i];
778 
779  // Check for consistency of the variance.
780  if (newTypeParam->getVariance() != prevTypeParam->getVariance()) {
781  if (newTypeParam->getVariance() == ObjCTypeParamVariance::Invariant &&
782  newContext != TypeParamListContext::Definition) {
783  // When the new type parameter is invariant and is not part
784  // of the definition, just propagate the variance.
785  newTypeParam->setVariance(prevTypeParam->getVariance());
786  } else if (prevTypeParam->getVariance()
788  !(isa<ObjCInterfaceDecl>(prevTypeParam->getDeclContext()) &&
789  cast<ObjCInterfaceDecl>(prevTypeParam->getDeclContext())
790  ->getDefinition() == prevTypeParam->getDeclContext())) {
791  // When the old parameter is invariant and was not part of the
792  // definition, just ignore the difference because it doesn't
793  // matter.
794  } else {
795  {
796  // Diagnose the conflict and update the second declaration.
797  SourceLocation diagLoc = newTypeParam->getVarianceLoc();
798  if (diagLoc.isInvalid())
799  diagLoc = newTypeParam->getLocStart();
800 
801  auto diag = S.Diag(diagLoc,
802  diag::err_objc_type_param_variance_conflict)
803  << static_cast<unsigned>(newTypeParam->getVariance())
804  << newTypeParam->getDeclName()
805  << static_cast<unsigned>(prevTypeParam->getVariance())
806  << prevTypeParam->getDeclName();
807  switch (prevTypeParam->getVariance()) {
809  diag << FixItHint::CreateRemoval(newTypeParam->getVarianceLoc());
810  break;
811 
814  StringRef newVarianceStr
815  = prevTypeParam->getVariance() == ObjCTypeParamVariance::Covariant
816  ? "__covariant"
817  : "__contravariant";
818  if (newTypeParam->getVariance()
820  diag << FixItHint::CreateInsertion(newTypeParam->getLocStart(),
821  (newVarianceStr + " ").str());
822  } else {
823  diag << FixItHint::CreateReplacement(newTypeParam->getVarianceLoc(),
824  newVarianceStr);
825  }
826  }
827  }
828  }
829 
830  S.Diag(prevTypeParam->getLocation(), diag::note_objc_type_param_here)
831  << prevTypeParam->getDeclName();
832 
833  // Override the variance.
834  newTypeParam->setVariance(prevTypeParam->getVariance());
835  }
836  }
837 
838  // If the bound types match, there's nothing to do.
839  if (S.Context.hasSameType(prevTypeParam->getUnderlyingType(),
840  newTypeParam->getUnderlyingType()))
841  continue;
842 
843  // If the new type parameter's bound was explicit, complain about it being
844  // different from the original.
845  if (newTypeParam->hasExplicitBound()) {
846  SourceRange newBoundRange = newTypeParam->getTypeSourceInfo()
848  S.Diag(newBoundRange.getBegin(), diag::err_objc_type_param_bound_conflict)
849  << newTypeParam->getUnderlyingType()
850  << newTypeParam->getDeclName()
851  << prevTypeParam->hasExplicitBound()
852  << prevTypeParam->getUnderlyingType()
853  << (newTypeParam->getDeclName() == prevTypeParam->getDeclName())
854  << prevTypeParam->getDeclName()
856  newBoundRange,
857  prevTypeParam->getUnderlyingType().getAsString(
859 
860  S.Diag(prevTypeParam->getLocation(), diag::note_objc_type_param_here)
861  << prevTypeParam->getDeclName();
862 
863  // Override the new type parameter's bound type with the previous type,
864  // so that it's consistent.
865  newTypeParam->setTypeSourceInfo(
867  continue;
868  }
869 
870  // The new type parameter got the implicit bound of 'id'. That's okay for
871  // categories and extensions (overwrite it later), but not for forward
872  // declarations and @interfaces, because those must be standalone.
873  if (newContext == TypeParamListContext::ForwardDeclaration ||
874  newContext == TypeParamListContext::Definition) {
875  // Diagnose this problem for forward declarations and definitions.
876  SourceLocation insertionLoc
877  = S.getLocForEndOfToken(newTypeParam->getLocation());
878  std::string newCode
879  = " : " + prevTypeParam->getUnderlyingType().getAsString(
881  S.Diag(newTypeParam->getLocation(),
882  diag::err_objc_type_param_bound_missing)
883  << prevTypeParam->getUnderlyingType()
884  << newTypeParam->getDeclName()
885  << (newContext == TypeParamListContext::ForwardDeclaration)
886  << FixItHint::CreateInsertion(insertionLoc, newCode);
887 
888  S.Diag(prevTypeParam->getLocation(), diag::note_objc_type_param_here)
889  << prevTypeParam->getDeclName();
890  }
891 
892  // Update the new type parameter's bound to match the previous one.
893  newTypeParam->setTypeSourceInfo(
895  }
896 
897  return false;
898 }
899 
900 Decl *Sema::
902  IdentifierInfo *ClassName, SourceLocation ClassLoc,
903  ObjCTypeParamList *typeParamList,
904  IdentifierInfo *SuperName, SourceLocation SuperLoc,
905  ArrayRef<ParsedType> SuperTypeArgs,
906  SourceRange SuperTypeArgsRange,
907  Decl * const *ProtoRefs, unsigned NumProtoRefs,
908  const SourceLocation *ProtoLocs,
909  SourceLocation EndProtoLoc, AttributeList *AttrList) {
910  assert(ClassName && "Missing class identifier");
911 
912  // Check for another declaration kind with the same name.
913  NamedDecl *PrevDecl = LookupSingleName(TUScope, ClassName, ClassLoc,
915 
916  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
917  Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
918  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
919  }
920 
921  // Create a declaration to describe this @interface.
922  ObjCInterfaceDecl* PrevIDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
923 
924  if (PrevIDecl && PrevIDecl->getIdentifier() != ClassName) {
925  // A previous decl with a different name is because of
926  // @compatibility_alias, for example:
927  // \code
928  // @class NewImage;
929  // @compatibility_alias OldImage NewImage;
930  // \endcode
931  // A lookup for 'OldImage' will return the 'NewImage' decl.
932  //
933  // In such a case use the real declaration name, instead of the alias one,
934  // otherwise we will break IdentifierResolver and redecls-chain invariants.
935  // FIXME: If necessary, add a bit to indicate that this ObjCInterfaceDecl
936  // has been aliased.
937  ClassName = PrevIDecl->getIdentifier();
938  }
939 
940  // If there was a forward declaration with type parameters, check
941  // for consistency.
942  if (PrevIDecl) {
943  if (ObjCTypeParamList *prevTypeParamList = PrevIDecl->getTypeParamList()) {
944  if (typeParamList) {
945  // Both have type parameter lists; check for consistency.
946  if (checkTypeParamListConsistency(*this, prevTypeParamList,
947  typeParamList,
948  TypeParamListContext::Definition)) {
949  typeParamList = nullptr;
950  }
951  } else {
952  Diag(ClassLoc, diag::err_objc_parameterized_forward_class_first)
953  << ClassName;
954  Diag(prevTypeParamList->getLAngleLoc(), diag::note_previous_decl)
955  << ClassName;
956 
957  // Clone the type parameter list.
958  SmallVector<ObjCTypeParamDecl *, 4> clonedTypeParams;
959  for (auto typeParam : *prevTypeParamList) {
960  clonedTypeParams.push_back(
962  Context,
963  CurContext,
964  typeParam->getVariance(),
965  SourceLocation(),
966  typeParam->getIndex(),
967  SourceLocation(),
968  typeParam->getIdentifier(),
969  SourceLocation(),
970  Context.getTrivialTypeSourceInfo(typeParam->getUnderlyingType())));
971  }
972 
973  typeParamList = ObjCTypeParamList::create(Context,
974  SourceLocation(),
975  clonedTypeParams,
976  SourceLocation());
977  }
978  }
979  }
980 
981  ObjCInterfaceDecl *IDecl
982  = ObjCInterfaceDecl::Create(Context, CurContext, AtInterfaceLoc, ClassName,
983  typeParamList, PrevIDecl, ClassLoc);
984  if (PrevIDecl) {
985  // Class already seen. Was it a definition?
986  if (ObjCInterfaceDecl *Def = PrevIDecl->getDefinition()) {
987  Diag(AtInterfaceLoc, diag::err_duplicate_class_def)
988  << PrevIDecl->getDeclName();
989  Diag(Def->getLocation(), diag::note_previous_definition);
990  IDecl->setInvalidDecl();
991  }
992  }
993 
994  if (AttrList)
995  ProcessDeclAttributeList(TUScope, IDecl, AttrList);
996  PushOnScopeChains(IDecl, TUScope);
997 
998  // Start the definition of this class. If we're in a redefinition case, there
999  // may already be a definition, so we'll end up adding to it.
1000  if (!IDecl->hasDefinition())
1001  IDecl->startDefinition();
1002 
1003  if (SuperName) {
1004  // Diagnose availability in the context of the @interface.
1005  ContextRAII SavedContext(*this, IDecl);
1006 
1007  ActOnSuperClassOfClassInterface(S, AtInterfaceLoc, IDecl,
1008  ClassName, ClassLoc,
1009  SuperName, SuperLoc, SuperTypeArgs,
1010  SuperTypeArgsRange);
1011  } else { // we have a root class.
1012  IDecl->setEndOfDefinitionLoc(ClassLoc);
1013  }
1014 
1015  // Check then save referenced protocols.
1016  if (NumProtoRefs) {
1017  diagnoseUseOfProtocols(*this, IDecl, (ObjCProtocolDecl*const*)ProtoRefs,
1018  NumProtoRefs, ProtoLocs);
1019  IDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
1020  ProtoLocs, Context);
1021  IDecl->setEndOfDefinitionLoc(EndProtoLoc);
1022  }
1023 
1024  CheckObjCDeclScope(IDecl);
1025  return ActOnObjCContainerStartDefinition(IDecl);
1026 }
1027 
1028 /// ActOnTypedefedProtocols - this action finds protocol list as part of the
1029 /// typedef'ed use for a qualified super class and adds them to the list
1030 /// of the protocols.
1032  IdentifierInfo *SuperName,
1033  SourceLocation SuperLoc) {
1034  if (!SuperName)
1035  return;
1036  NamedDecl* IDecl = LookupSingleName(TUScope, SuperName, SuperLoc,
1038  if (!IDecl)
1039  return;
1040 
1041  if (const TypedefNameDecl *TDecl = dyn_cast_or_null<TypedefNameDecl>(IDecl)) {
1042  QualType T = TDecl->getUnderlyingType();
1043  if (T->isObjCObjectType())
1044  if (const ObjCObjectType *OPT = T->getAs<ObjCObjectType>())
1045  ProtocolRefs.append(OPT->qual_begin(), OPT->qual_end());
1046  }
1047 }
1048 
1049 /// ActOnCompatibilityAlias - this action is called after complete parsing of
1050 /// a \@compatibility_alias declaration. It sets up the alias relationships.
1052  IdentifierInfo *AliasName,
1053  SourceLocation AliasLocation,
1054  IdentifierInfo *ClassName,
1055  SourceLocation ClassLocation) {
1056  // Look for previous declaration of alias name
1057  NamedDecl *ADecl = LookupSingleName(TUScope, AliasName, AliasLocation,
1059  if (ADecl) {
1060  Diag(AliasLocation, diag::err_conflicting_aliasing_type) << AliasName;
1061  Diag(ADecl->getLocation(), diag::note_previous_declaration);
1062  return nullptr;
1063  }
1064  // Check for class declaration
1065  NamedDecl *CDeclU = LookupSingleName(TUScope, ClassName, ClassLocation,
1067  if (const TypedefNameDecl *TDecl =
1068  dyn_cast_or_null<TypedefNameDecl>(CDeclU)) {
1069  QualType T = TDecl->getUnderlyingType();
1070  if (T->isObjCObjectType()) {
1071  if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface()) {
1072  ClassName = IDecl->getIdentifier();
1073  CDeclU = LookupSingleName(TUScope, ClassName, ClassLocation,
1075  }
1076  }
1077  }
1078  ObjCInterfaceDecl *CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDeclU);
1079  if (!CDecl) {
1080  Diag(ClassLocation, diag::warn_undef_interface) << ClassName;
1081  if (CDeclU)
1082  Diag(CDeclU->getLocation(), diag::note_previous_declaration);
1083  return nullptr;
1084  }
1085 
1086  // Everything checked out, instantiate a new alias declaration AST.
1087  ObjCCompatibleAliasDecl *AliasDecl =
1088  ObjCCompatibleAliasDecl::Create(Context, CurContext, AtLoc, AliasName, CDecl);
1089 
1090  if (!CheckObjCDeclScope(AliasDecl))
1091  PushOnScopeChains(AliasDecl, TUScope);
1092 
1093  return AliasDecl;
1094 }
1095 
1097  IdentifierInfo *PName,
1098  SourceLocation &Ploc, SourceLocation PrevLoc,
1099  const ObjCList<ObjCProtocolDecl> &PList) {
1100 
1101  bool res = false;
1103  E = PList.end(); I != E; ++I) {
1104  if (ObjCProtocolDecl *PDecl = LookupProtocol((*I)->getIdentifier(),
1105  Ploc)) {
1106  if (PDecl->getIdentifier() == PName) {
1107  Diag(Ploc, diag::err_protocol_has_circular_dependency);
1108  Diag(PrevLoc, diag::note_previous_definition);
1109  res = true;
1110  }
1111 
1112  if (!PDecl->hasDefinition())
1113  continue;
1114 
1116  PDecl->getLocation(), PDecl->getReferencedProtocols()))
1117  res = true;
1118  }
1119  }
1120  return res;
1121 }
1122 
1123 Decl *
1125  IdentifierInfo *ProtocolName,
1126  SourceLocation ProtocolLoc,
1127  Decl * const *ProtoRefs,
1128  unsigned NumProtoRefs,
1129  const SourceLocation *ProtoLocs,
1130  SourceLocation EndProtoLoc,
1131  AttributeList *AttrList) {
1132  bool err = false;
1133  // FIXME: Deal with AttrList.
1134  assert(ProtocolName && "Missing protocol identifier");
1135  ObjCProtocolDecl *PrevDecl = LookupProtocol(ProtocolName, ProtocolLoc,
1137  ObjCProtocolDecl *PDecl = nullptr;
1138  if (ObjCProtocolDecl *Def = PrevDecl? PrevDecl->getDefinition() : nullptr) {
1139  // If we already have a definition, complain.
1140  Diag(ProtocolLoc, diag::warn_duplicate_protocol_def) << ProtocolName;
1141  Diag(Def->getLocation(), diag::note_previous_definition);
1142 
1143  // Create a new protocol that is completely distinct from previous
1144  // declarations, and do not make this protocol available for name lookup.
1145  // That way, we'll end up completely ignoring the duplicate.
1146  // FIXME: Can we turn this into an error?
1147  PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
1148  ProtocolLoc, AtProtoInterfaceLoc,
1149  /*PrevDecl=*/nullptr);
1150  PDecl->startDefinition();
1151  } else {
1152  if (PrevDecl) {
1153  // Check for circular dependencies among protocol declarations. This can
1154  // only happen if this protocol was forward-declared.
1156  PList.set((ObjCProtocolDecl *const*)ProtoRefs, NumProtoRefs, Context);
1158  ProtocolName, ProtocolLoc, PrevDecl->getLocation(), PList);
1159  }
1160 
1161  // Create the new declaration.
1162  PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
1163  ProtocolLoc, AtProtoInterfaceLoc,
1164  /*PrevDecl=*/PrevDecl);
1165 
1166  PushOnScopeChains(PDecl, TUScope);
1167  PDecl->startDefinition();
1168  }
1169 
1170  if (AttrList)
1171  ProcessDeclAttributeList(TUScope, PDecl, AttrList);
1172 
1173  // Merge attributes from previous declarations.
1174  if (PrevDecl)
1175  mergeDeclAttributes(PDecl, PrevDecl);
1176 
1177  if (!err && NumProtoRefs ) {
1178  /// Check then save referenced protocols.
1179  diagnoseUseOfProtocols(*this, PDecl, (ObjCProtocolDecl*const*)ProtoRefs,
1180  NumProtoRefs, ProtoLocs);
1181  PDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
1182  ProtoLocs, Context);
1183  }
1184 
1185  CheckObjCDeclScope(PDecl);
1186  return ActOnObjCContainerStartDefinition(PDecl);
1187 }
1188 
1190  ObjCProtocolDecl *&UndefinedProtocol) {
1191  if (!PDecl->hasDefinition() || PDecl->getDefinition()->isHidden()) {
1192  UndefinedProtocol = PDecl;
1193  return true;
1194  }
1195 
1196  for (auto *PI : PDecl->protocols())
1197  if (NestedProtocolHasNoDefinition(PI, UndefinedProtocol)) {
1198  UndefinedProtocol = PI;
1199  return true;
1200  }
1201  return false;
1202 }
1203 
1204 /// FindProtocolDeclaration - This routine looks up protocols and
1205 /// issues an error if they are not declared. It returns list of
1206 /// protocol declarations in its 'Protocols' argument.
1207 void
1208 Sema::FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,
1209  ArrayRef<IdentifierLocPair> ProtocolId,
1210  SmallVectorImpl<Decl *> &Protocols) {
1211  for (const IdentifierLocPair &Pair : ProtocolId) {
1212  ObjCProtocolDecl *PDecl = LookupProtocol(Pair.first, Pair.second);
1213  if (!PDecl) {
1214  TypoCorrection Corrected = CorrectTypo(
1215  DeclarationNameInfo(Pair.first, Pair.second),
1216  LookupObjCProtocolName, TUScope, nullptr,
1217  llvm::make_unique<DeclFilterCCC<ObjCProtocolDecl>>(),
1219  if ((PDecl = Corrected.getCorrectionDeclAs<ObjCProtocolDecl>()))
1220  diagnoseTypo(Corrected, PDiag(diag::err_undeclared_protocol_suggest)
1221  << Pair.first);
1222  }
1223 
1224  if (!PDecl) {
1225  Diag(Pair.second, diag::err_undeclared_protocol) << Pair.first;
1226  continue;
1227  }
1228  // If this is a forward protocol declaration, get its definition.
1229  if (!PDecl->isThisDeclarationADefinition() && PDecl->getDefinition())
1230  PDecl = PDecl->getDefinition();
1231 
1232  // For an objc container, delay protocol reference checking until after we
1233  // can set the objc decl as the availability context, otherwise check now.
1234  if (!ForObjCContainer) {
1235  (void)DiagnoseUseOfDecl(PDecl, Pair.second);
1236  }
1237 
1238  // If this is a forward declaration and we are supposed to warn in this
1239  // case, do it.
1240  // FIXME: Recover nicely in the hidden case.
1241  ObjCProtocolDecl *UndefinedProtocol;
1242 
1243  if (WarnOnDeclarations &&
1244  NestedProtocolHasNoDefinition(PDecl, UndefinedProtocol)) {
1245  Diag(Pair.second, diag::warn_undef_protocolref) << Pair.first;
1246  Diag(UndefinedProtocol->getLocation(), diag::note_protocol_decl_undefined)
1247  << UndefinedProtocol;
1248  }
1249  Protocols.push_back(PDecl);
1250  }
1251 }
1252 
1253 namespace {
1254 // Callback to only accept typo corrections that are either
1255 // Objective-C protocols or valid Objective-C type arguments.
1256 class ObjCTypeArgOrProtocolValidatorCCC : public CorrectionCandidateCallback {
1258  Sema::LookupNameKind LookupKind;
1259  public:
1260  ObjCTypeArgOrProtocolValidatorCCC(ASTContext &context,
1261  Sema::LookupNameKind lookupKind)
1262  : Context(context), LookupKind(lookupKind) { }
1263 
1264  bool ValidateCandidate(const TypoCorrection &candidate) override {
1265  // If we're allowed to find protocols and we have a protocol, accept it.
1266  if (LookupKind != Sema::LookupOrdinaryName) {
1267  if (candidate.getCorrectionDeclAs<ObjCProtocolDecl>())
1268  return true;
1269  }
1270 
1271  // If we're allowed to find type names and we have one, accept it.
1272  if (LookupKind != Sema::LookupObjCProtocolName) {
1273  // If we have a type declaration, we might accept this result.
1274  if (auto typeDecl = candidate.getCorrectionDeclAs<TypeDecl>()) {
1275  // If we found a tag declaration outside of C++, skip it. This
1276  // can happy because we look for any name when there is no
1277  // bias to protocol or type names.
1278  if (isa<RecordDecl>(typeDecl) && !Context.getLangOpts().CPlusPlus)
1279  return false;
1280 
1281  // Make sure the type is something we would accept as a type
1282  // argument.
1283  auto type = Context.getTypeDeclType(typeDecl);
1284  if (type->isObjCObjectPointerType() ||
1285  type->isBlockPointerType() ||
1286  type->isDependentType() ||
1287  type->isObjCObjectType())
1288  return true;
1289 
1290  return false;
1291  }
1292 
1293  // If we have an Objective-C class type, accept it; there will
1294  // be another fix to add the '*'.
1295  if (candidate.getCorrectionDeclAs<ObjCInterfaceDecl>())
1296  return true;
1297 
1298  return false;
1299  }
1300 
1301  return false;
1302  }
1303 };
1304 } // end anonymous namespace
1305 
1307  Scope *S,
1308  ParsedType baseType,
1309  SourceLocation lAngleLoc,
1310  ArrayRef<IdentifierInfo *> identifiers,
1311  ArrayRef<SourceLocation> identifierLocs,
1312  SourceLocation rAngleLoc,
1313  SourceLocation &typeArgsLAngleLoc,
1314  SmallVectorImpl<ParsedType> &typeArgs,
1315  SourceLocation &typeArgsRAngleLoc,
1316  SourceLocation &protocolLAngleLoc,
1317  SmallVectorImpl<Decl *> &protocols,
1318  SourceLocation &protocolRAngleLoc,
1319  bool warnOnIncompleteProtocols) {
1320  // Local function that updates the declaration specifiers with
1321  // protocol information.
1322  unsigned numProtocolsResolved = 0;
1323  auto resolvedAsProtocols = [&] {
1324  assert(numProtocolsResolved == identifiers.size() && "Unresolved protocols");
1325 
1326  // Determine whether the base type is a parameterized class, in
1327  // which case we want to warn about typos such as
1328  // "NSArray<NSObject>" (that should be NSArray<NSObject *>).
1329  ObjCInterfaceDecl *baseClass = nullptr;
1330  QualType base = GetTypeFromParser(baseType, nullptr);
1331  bool allAreTypeNames = false;
1332  SourceLocation firstClassNameLoc;
1333  if (!base.isNull()) {
1334  if (const auto *objcObjectType = base->getAs<ObjCObjectType>()) {
1335  baseClass = objcObjectType->getInterface();
1336  if (baseClass) {
1337  if (auto typeParams = baseClass->getTypeParamList()) {
1338  if (typeParams->size() == numProtocolsResolved) {
1339  // Note that we should be looking for type names, too.
1340  allAreTypeNames = true;
1341  }
1342  }
1343  }
1344  }
1345  }
1346 
1347  for (unsigned i = 0, n = protocols.size(); i != n; ++i) {
1348  ObjCProtocolDecl *&proto
1349  = reinterpret_cast<ObjCProtocolDecl *&>(protocols[i]);
1350  // For an objc container, delay protocol reference checking until after we
1351  // can set the objc decl as the availability context, otherwise check now.
1352  if (!warnOnIncompleteProtocols) {
1353  (void)DiagnoseUseOfDecl(proto, identifierLocs[i]);
1354  }
1355 
1356  // If this is a forward protocol declaration, get its definition.
1357  if (!proto->isThisDeclarationADefinition() && proto->getDefinition())
1358  proto = proto->getDefinition();
1359 
1360  // If this is a forward declaration and we are supposed to warn in this
1361  // case, do it.
1362  // FIXME: Recover nicely in the hidden case.
1363  ObjCProtocolDecl *forwardDecl = nullptr;
1364  if (warnOnIncompleteProtocols &&
1365  NestedProtocolHasNoDefinition(proto, forwardDecl)) {
1366  Diag(identifierLocs[i], diag::warn_undef_protocolref)
1367  << proto->getDeclName();
1368  Diag(forwardDecl->getLocation(), diag::note_protocol_decl_undefined)
1369  << forwardDecl;
1370  }
1371 
1372  // If everything this far has been a type name (and we care
1373  // about such things), check whether this name refers to a type
1374  // as well.
1375  if (allAreTypeNames) {
1376  if (auto *decl = LookupSingleName(S, identifiers[i], identifierLocs[i],
1377  LookupOrdinaryName)) {
1378  if (isa<ObjCInterfaceDecl>(decl)) {
1379  if (firstClassNameLoc.isInvalid())
1380  firstClassNameLoc = identifierLocs[i];
1381  } else if (!isa<TypeDecl>(decl)) {
1382  // Not a type.
1383  allAreTypeNames = false;
1384  }
1385  } else {
1386  allAreTypeNames = false;
1387  }
1388  }
1389  }
1390 
1391  // All of the protocols listed also have type names, and at least
1392  // one is an Objective-C class name. Check whether all of the
1393  // protocol conformances are declared by the base class itself, in
1394  // which case we warn.
1395  if (allAreTypeNames && firstClassNameLoc.isValid()) {
1396  llvm::SmallPtrSet<ObjCProtocolDecl*, 8> knownProtocols;
1397  Context.CollectInheritedProtocols(baseClass, knownProtocols);
1398  bool allProtocolsDeclared = true;
1399  for (auto proto : protocols) {
1400  if (knownProtocols.count(static_cast<ObjCProtocolDecl *>(proto)) == 0) {
1401  allProtocolsDeclared = false;
1402  break;
1403  }
1404  }
1405 
1406  if (allProtocolsDeclared) {
1407  Diag(firstClassNameLoc, diag::warn_objc_redundant_qualified_class_type)
1408  << baseClass->getDeclName() << SourceRange(lAngleLoc, rAngleLoc)
1409  << FixItHint::CreateInsertion(getLocForEndOfToken(firstClassNameLoc),
1410  " *");
1411  }
1412  }
1413 
1414  protocolLAngleLoc = lAngleLoc;
1415  protocolRAngleLoc = rAngleLoc;
1416  assert(protocols.size() == identifierLocs.size());
1417  };
1418 
1419  // Attempt to resolve all of the identifiers as protocols.
1420  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1421  ObjCProtocolDecl *proto = LookupProtocol(identifiers[i], identifierLocs[i]);
1422  protocols.push_back(proto);
1423  if (proto)
1424  ++numProtocolsResolved;
1425  }
1426 
1427  // If all of the names were protocols, these were protocol qualifiers.
1428  if (numProtocolsResolved == identifiers.size())
1429  return resolvedAsProtocols();
1430 
1431  // Attempt to resolve all of the identifiers as type names or
1432  // Objective-C class names. The latter is technically ill-formed,
1433  // but is probably something like \c NSArray<NSView *> missing the
1434  // \c*.
1435  typedef llvm::PointerUnion<TypeDecl *, ObjCInterfaceDecl *> TypeOrClassDecl;
1437  unsigned numTypeDeclsResolved = 0;
1438  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1439  NamedDecl *decl = LookupSingleName(S, identifiers[i], identifierLocs[i],
1441  if (!decl) {
1442  typeDecls.push_back(TypeOrClassDecl());
1443  continue;
1444  }
1445 
1446  if (auto typeDecl = dyn_cast<TypeDecl>(decl)) {
1447  typeDecls.push_back(typeDecl);
1448  ++numTypeDeclsResolved;
1449  continue;
1450  }
1451 
1452  if (auto objcClass = dyn_cast<ObjCInterfaceDecl>(decl)) {
1453  typeDecls.push_back(objcClass);
1454  ++numTypeDeclsResolved;
1455  continue;
1456  }
1457 
1458  typeDecls.push_back(TypeOrClassDecl());
1459  }
1460 
1461  AttributeFactory attrFactory;
1462 
1463  // Local function that forms a reference to the given type or
1464  // Objective-C class declaration.
1465  auto resolveTypeReference = [&](TypeOrClassDecl typeDecl, SourceLocation loc)
1466  -> TypeResult {
1467  // Form declaration specifiers. They simply refer to the type.
1468  DeclSpec DS(attrFactory);
1469  const char* prevSpec; // unused
1470  unsigned diagID; // unused
1471  QualType type;
1472  if (auto *actualTypeDecl = typeDecl.dyn_cast<TypeDecl *>())
1473  type = Context.getTypeDeclType(actualTypeDecl);
1474  else
1475  type = Context.getObjCInterfaceType(typeDecl.get<ObjCInterfaceDecl *>());
1476  TypeSourceInfo *parsedTSInfo = Context.getTrivialTypeSourceInfo(type, loc);
1477  ParsedType parsedType = CreateParsedType(type, parsedTSInfo);
1478  DS.SetTypeSpecType(DeclSpec::TST_typename, loc, prevSpec, diagID,
1479  parsedType, Context.getPrintingPolicy());
1480  // Use the identifier location for the type source range.
1481  DS.SetRangeStart(loc);
1482  DS.SetRangeEnd(loc);
1483 
1484  // Form the declarator.
1486 
1487  // If we have a typedef of an Objective-C class type that is missing a '*',
1488  // add the '*'.
1489  if (type->getAs<ObjCInterfaceType>()) {
1490  SourceLocation starLoc = getLocForEndOfToken(loc);
1491  ParsedAttributes parsedAttrs(attrFactory);
1492  D.AddTypeInfo(DeclaratorChunk::getPointer(/*typeQuals=*/0, starLoc,
1493  SourceLocation(),
1494  SourceLocation(),
1495  SourceLocation(),
1496  SourceLocation()),
1497  parsedAttrs,
1498  starLoc);
1499 
1500  // Diagnose the missing '*'.
1501  Diag(loc, diag::err_objc_type_arg_missing_star)
1502  << type
1503  << FixItHint::CreateInsertion(starLoc, " *");
1504  }
1505 
1506  // Convert this to a type.
1507  return ActOnTypeName(S, D);
1508  };
1509 
1510  // Local function that updates the declaration specifiers with
1511  // type argument information.
1512  auto resolvedAsTypeDecls = [&] {
1513  // We did not resolve these as protocols.
1514  protocols.clear();
1515 
1516  assert(numTypeDeclsResolved == identifiers.size() && "Unresolved type decl");
1517  // Map type declarations to type arguments.
1518  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1519  // Map type reference to a type.
1520  TypeResult type = resolveTypeReference(typeDecls[i], identifierLocs[i]);
1521  if (!type.isUsable()) {
1522  typeArgs.clear();
1523  return;
1524  }
1525 
1526  typeArgs.push_back(type.get());
1527  }
1528 
1529  typeArgsLAngleLoc = lAngleLoc;
1530  typeArgsRAngleLoc = rAngleLoc;
1531  };
1532 
1533  // If all of the identifiers can be resolved as type names or
1534  // Objective-C class names, we have type arguments.
1535  if (numTypeDeclsResolved == identifiers.size())
1536  return resolvedAsTypeDecls();
1537 
1538  // Error recovery: some names weren't found, or we have a mix of
1539  // type and protocol names. Go resolve all of the unresolved names
1540  // and complain if we can't find a consistent answer.
1541  LookupNameKind lookupKind = LookupAnyName;
1542  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1543  // If we already have a protocol or type. Check whether it is the
1544  // right thing.
1545  if (protocols[i] || typeDecls[i]) {
1546  // If we haven't figured out whether we want types or protocols
1547  // yet, try to figure it out from this name.
1548  if (lookupKind == LookupAnyName) {
1549  // If this name refers to both a protocol and a type (e.g., \c
1550  // NSObject), don't conclude anything yet.
1551  if (protocols[i] && typeDecls[i])
1552  continue;
1553 
1554  // Otherwise, let this name decide whether we'll be correcting
1555  // toward types or protocols.
1556  lookupKind = protocols[i] ? LookupObjCProtocolName
1558  continue;
1559  }
1560 
1561  // If we want protocols and we have a protocol, there's nothing
1562  // more to do.
1563  if (lookupKind == LookupObjCProtocolName && protocols[i])
1564  continue;
1565 
1566  // If we want types and we have a type declaration, there's
1567  // nothing more to do.
1568  if (lookupKind == LookupOrdinaryName && typeDecls[i])
1569  continue;
1570 
1571  // We have a conflict: some names refer to protocols and others
1572  // refer to types.
1573  Diag(identifierLocs[i], diag::err_objc_type_args_and_protocols)
1574  << (protocols[i] != nullptr)
1575  << identifiers[i]
1576  << identifiers[0]
1577  << SourceRange(identifierLocs[0]);
1578 
1579  protocols.clear();
1580  typeArgs.clear();
1581  return;
1582  }
1583 
1584  // Perform typo correction on the name.
1585  TypoCorrection corrected = CorrectTypo(
1586  DeclarationNameInfo(identifiers[i], identifierLocs[i]), lookupKind, S,
1587  nullptr,
1588  llvm::make_unique<ObjCTypeArgOrProtocolValidatorCCC>(Context,
1589  lookupKind),
1591  if (corrected) {
1592  // Did we find a protocol?
1593  if (auto proto = corrected.getCorrectionDeclAs<ObjCProtocolDecl>()) {
1594  diagnoseTypo(corrected,
1595  PDiag(diag::err_undeclared_protocol_suggest)
1596  << identifiers[i]);
1597  lookupKind = LookupObjCProtocolName;
1598  protocols[i] = proto;
1599  ++numProtocolsResolved;
1600  continue;
1601  }
1602 
1603  // Did we find a type?
1604  if (auto typeDecl = corrected.getCorrectionDeclAs<TypeDecl>()) {
1605  diagnoseTypo(corrected,
1606  PDiag(diag::err_unknown_typename_suggest)
1607  << identifiers[i]);
1608  lookupKind = LookupOrdinaryName;
1609  typeDecls[i] = typeDecl;
1610  ++numTypeDeclsResolved;
1611  continue;
1612  }
1613 
1614  // Did we find an Objective-C class?
1615  if (auto objcClass = corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
1616  diagnoseTypo(corrected,
1617  PDiag(diag::err_unknown_type_or_class_name_suggest)
1618  << identifiers[i] << true);
1619  lookupKind = LookupOrdinaryName;
1620  typeDecls[i] = objcClass;
1621  ++numTypeDeclsResolved;
1622  continue;
1623  }
1624  }
1625 
1626  // We couldn't find anything.
1627  Diag(identifierLocs[i],
1628  (lookupKind == LookupAnyName ? diag::err_objc_type_arg_missing
1629  : lookupKind == LookupObjCProtocolName ? diag::err_undeclared_protocol
1630  : diag::err_unknown_typename))
1631  << identifiers[i];
1632  protocols.clear();
1633  typeArgs.clear();
1634  return;
1635  }
1636 
1637  // If all of the names were (corrected to) protocols, these were
1638  // protocol qualifiers.
1639  if (numProtocolsResolved == identifiers.size())
1640  return resolvedAsProtocols();
1641 
1642  // Otherwise, all of the names were (corrected to) types.
1643  assert(numTypeDeclsResolved == identifiers.size() && "Not all types?");
1644  return resolvedAsTypeDecls();
1645 }
1646 
1647 /// DiagnoseClassExtensionDupMethods - Check for duplicate declaration of
1648 /// a class method in its extension.
1649 ///
1651  ObjCInterfaceDecl *ID) {
1652  if (!ID)
1653  return; // Possibly due to previous error
1654 
1655  llvm::DenseMap<Selector, const ObjCMethodDecl*> MethodMap;
1656  for (auto *MD : ID->methods())
1657  MethodMap[MD->getSelector()] = MD;
1658 
1659  if (MethodMap.empty())
1660  return;
1661  for (const auto *Method : CAT->methods()) {
1662  const ObjCMethodDecl *&PrevMethod = MethodMap[Method->getSelector()];
1663  if (PrevMethod &&
1664  (PrevMethod->isInstanceMethod() == Method->isInstanceMethod()) &&
1665  !MatchTwoMethodDeclarations(Method, PrevMethod)) {
1666  Diag(Method->getLocation(), diag::err_duplicate_method_decl)
1667  << Method->getDeclName();
1668  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
1669  }
1670  }
1671 }
1672 
1673 /// ActOnForwardProtocolDeclaration - Handle \@protocol foo;
1676  ArrayRef<IdentifierLocPair> IdentList,
1677  AttributeList *attrList) {
1678  SmallVector<Decl *, 8> DeclsInGroup;
1679  for (const IdentifierLocPair &IdentPair : IdentList) {
1680  IdentifierInfo *Ident = IdentPair.first;
1681  ObjCProtocolDecl *PrevDecl = LookupProtocol(Ident, IdentPair.second,
1683  ObjCProtocolDecl *PDecl
1685  IdentPair.second, AtProtocolLoc,
1686  PrevDecl);
1687 
1688  PushOnScopeChains(PDecl, TUScope);
1689  CheckObjCDeclScope(PDecl);
1690 
1691  if (attrList)
1692  ProcessDeclAttributeList(TUScope, PDecl, attrList);
1693 
1694  if (PrevDecl)
1695  mergeDeclAttributes(PDecl, PrevDecl);
1696 
1697  DeclsInGroup.push_back(PDecl);
1698  }
1699 
1700  return BuildDeclaratorGroup(DeclsInGroup, false);
1701 }
1702 
1703 Decl *Sema::
1705  IdentifierInfo *ClassName, SourceLocation ClassLoc,
1706  ObjCTypeParamList *typeParamList,
1707  IdentifierInfo *CategoryName,
1708  SourceLocation CategoryLoc,
1709  Decl * const *ProtoRefs,
1710  unsigned NumProtoRefs,
1711  const SourceLocation *ProtoLocs,
1712  SourceLocation EndProtoLoc) {
1713  ObjCCategoryDecl *CDecl;
1714  ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);
1715 
1716  /// Check that class of this category is already completely declared.
1717 
1718  if (!IDecl
1719  || RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
1720  diag::err_category_forward_interface,
1721  CategoryName == nullptr)) {
1722  // Create an invalid ObjCCategoryDecl to serve as context for
1723  // the enclosing method declarations. We mark the decl invalid
1724  // to make it clear that this isn't a valid AST.
1725  CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
1726  ClassLoc, CategoryLoc, CategoryName,
1727  IDecl, typeParamList);
1728  CDecl->setInvalidDecl();
1729  CurContext->addDecl(CDecl);
1730 
1731  if (!IDecl)
1732  Diag(ClassLoc, diag::err_undef_interface) << ClassName;
1733  return ActOnObjCContainerStartDefinition(CDecl);
1734  }
1735 
1736  if (!CategoryName && IDecl->getImplementation()) {
1737  Diag(ClassLoc, diag::err_class_extension_after_impl) << ClassName;
1738  Diag(IDecl->getImplementation()->getLocation(),
1739  diag::note_implementation_declared);
1740  }
1741 
1742  if (CategoryName) {
1743  /// Check for duplicate interface declaration for this category
1745  = IDecl->FindCategoryDeclaration(CategoryName)) {
1746  // Class extensions can be declared multiple times, categories cannot.
1747  Diag(CategoryLoc, diag::warn_dup_category_def)
1748  << ClassName << CategoryName;
1749  Diag(Previous->getLocation(), diag::note_previous_definition);
1750  }
1751  }
1752 
1753  // If we have a type parameter list, check it.
1754  if (typeParamList) {
1755  if (auto prevTypeParamList = IDecl->getTypeParamList()) {
1756  if (checkTypeParamListConsistency(*this, prevTypeParamList, typeParamList,
1757  CategoryName
1759  : TypeParamListContext::Extension))
1760  typeParamList = nullptr;
1761  } else {
1762  Diag(typeParamList->getLAngleLoc(),
1763  diag::err_objc_parameterized_category_nonclass)
1764  << (CategoryName != nullptr)
1765  << ClassName
1766  << typeParamList->getSourceRange();
1767 
1768  typeParamList = nullptr;
1769  }
1770  }
1771 
1772  CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
1773  ClassLoc, CategoryLoc, CategoryName, IDecl,
1774  typeParamList);
1775  // FIXME: PushOnScopeChains?
1776  CurContext->addDecl(CDecl);
1777 
1778  if (NumProtoRefs) {
1779  diagnoseUseOfProtocols(*this, CDecl, (ObjCProtocolDecl*const*)ProtoRefs,
1780  NumProtoRefs, ProtoLocs);
1781  CDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
1782  ProtoLocs, Context);
1783  // Protocols in the class extension belong to the class.
1784  if (CDecl->IsClassExtension())
1785  IDecl->mergeClassExtensionProtocolList((ObjCProtocolDecl*const*)ProtoRefs,
1786  NumProtoRefs, Context);
1787  }
1788 
1789  CheckObjCDeclScope(CDecl);
1790  return ActOnObjCContainerStartDefinition(CDecl);
1791 }
1792 
1793 /// ActOnStartCategoryImplementation - Perform semantic checks on the
1794 /// category implementation declaration and build an ObjCCategoryImplDecl
1795 /// object.
1797  SourceLocation AtCatImplLoc,
1798  IdentifierInfo *ClassName, SourceLocation ClassLoc,
1799  IdentifierInfo *CatName, SourceLocation CatLoc) {
1800  ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);
1801  ObjCCategoryDecl *CatIDecl = nullptr;
1802  if (IDecl && IDecl->hasDefinition()) {
1803  CatIDecl = IDecl->FindCategoryDeclaration(CatName);
1804  if (!CatIDecl) {
1805  // Category @implementation with no corresponding @interface.
1806  // Create and install one.
1807  CatIDecl = ObjCCategoryDecl::Create(Context, CurContext, AtCatImplLoc,
1808  ClassLoc, CatLoc,
1809  CatName, IDecl,
1810  /*typeParamList=*/nullptr);
1811  CatIDecl->setImplicit();
1812  }
1813  }
1814 
1815  ObjCCategoryImplDecl *CDecl =
1817  ClassLoc, AtCatImplLoc, CatLoc);
1818  /// Check that class of this category is already completely declared.
1819  if (!IDecl) {
1820  Diag(ClassLoc, diag::err_undef_interface) << ClassName;
1821  CDecl->setInvalidDecl();
1822  } else if (RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
1823  diag::err_undef_interface)) {
1824  CDecl->setInvalidDecl();
1825  }
1826 
1827  // FIXME: PushOnScopeChains?
1828  CurContext->addDecl(CDecl);
1829 
1830  // If the interface is deprecated/unavailable, warn/error about it.
1831  if (IDecl)
1832  DiagnoseUseOfDecl(IDecl, ClassLoc);
1833 
1834  /// Check that CatName, category name, is not used in another implementation.
1835  if (CatIDecl) {
1836  if (CatIDecl->getImplementation()) {
1837  Diag(ClassLoc, diag::err_dup_implementation_category) << ClassName
1838  << CatName;
1839  Diag(CatIDecl->getImplementation()->getLocation(),
1840  diag::note_previous_definition);
1841  CDecl->setInvalidDecl();
1842  } else {
1843  CatIDecl->setImplementation(CDecl);
1844  // Warn on implementating category of deprecated class under
1845  // -Wdeprecated-implementations flag.
1847  dyn_cast<NamedDecl>(IDecl),
1848  CDecl->getLocation(), 2);
1849  }
1850  }
1851 
1852  CheckObjCDeclScope(CDecl);
1853  return ActOnObjCContainerStartDefinition(CDecl);
1854 }
1855 
1857  SourceLocation AtClassImplLoc,
1858  IdentifierInfo *ClassName, SourceLocation ClassLoc,
1859  IdentifierInfo *SuperClassname,
1860  SourceLocation SuperClassLoc) {
1861  ObjCInterfaceDecl *IDecl = nullptr;
1862  // Check for another declaration kind with the same name.
1863  NamedDecl *PrevDecl
1864  = LookupSingleName(TUScope, ClassName, ClassLoc, LookupOrdinaryName,
1866  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
1867  Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
1868  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1869  } else if ((IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl))) {
1870  // FIXME: This will produce an error if the definition of the interface has
1871  // been imported from a module but is not visible.
1873  diag::warn_undef_interface);
1874  } else {
1875  // We did not find anything with the name ClassName; try to correct for
1876  // typos in the class name.
1877  TypoCorrection Corrected = CorrectTypo(
1878  DeclarationNameInfo(ClassName, ClassLoc), LookupOrdinaryName, TUScope,
1879  nullptr, llvm::make_unique<ObjCInterfaceValidatorCCC>(), CTK_NonError);
1880  if (Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
1881  // Suggest the (potentially) correct interface name. Don't provide a
1882  // code-modification hint or use the typo name for recovery, because
1883  // this is just a warning. The program may actually be correct.
1884  diagnoseTypo(Corrected,
1885  PDiag(diag::warn_undef_interface_suggest) << ClassName,
1886  /*ErrorRecovery*/false);
1887  } else {
1888  Diag(ClassLoc, diag::warn_undef_interface) << ClassName;
1889  }
1890  }
1891 
1892  // Check that super class name is valid class name
1893  ObjCInterfaceDecl *SDecl = nullptr;
1894  if (SuperClassname) {
1895  // Check if a different kind of symbol declared in this scope.
1896  PrevDecl = LookupSingleName(TUScope, SuperClassname, SuperClassLoc,
1898  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
1899  Diag(SuperClassLoc, diag::err_redefinition_different_kind)
1900  << SuperClassname;
1901  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1902  } else {
1903  SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
1904  if (SDecl && !SDecl->hasDefinition())
1905  SDecl = nullptr;
1906  if (!SDecl)
1907  Diag(SuperClassLoc, diag::err_undef_superclass)
1908  << SuperClassname << ClassName;
1909  else if (IDecl && !declaresSameEntity(IDecl->getSuperClass(), SDecl)) {
1910  // This implementation and its interface do not have the same
1911  // super class.
1912  Diag(SuperClassLoc, diag::err_conflicting_super_class)
1913  << SDecl->getDeclName();
1914  Diag(SDecl->getLocation(), diag::note_previous_definition);
1915  }
1916  }
1917  }
1918 
1919  if (!IDecl) {
1920  // Legacy case of @implementation with no corresponding @interface.
1921  // Build, chain & install the interface decl into the identifier.
1922 
1923  // FIXME: Do we support attributes on the @implementation? If so we should
1924  // copy them over.
1925  IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassImplLoc,
1926  ClassName, /*typeParamList=*/nullptr,
1927  /*PrevDecl=*/nullptr, ClassLoc,
1928  true);
1929  IDecl->startDefinition();
1930  if (SDecl) {
1933  SuperClassLoc));
1934  IDecl->setEndOfDefinitionLoc(SuperClassLoc);
1935  } else {
1936  IDecl->setEndOfDefinitionLoc(ClassLoc);
1937  }
1938 
1939  PushOnScopeChains(IDecl, TUScope);
1940  } else {
1941  // Mark the interface as being completed, even if it was just as
1942  // @class ....;
1943  // declaration; the user cannot reopen it.
1944  if (!IDecl->hasDefinition())
1945  IDecl->startDefinition();
1946  }
1947 
1948  ObjCImplementationDecl* IMPDecl =
1950  ClassLoc, AtClassImplLoc, SuperClassLoc);
1951 
1952  if (CheckObjCDeclScope(IMPDecl))
1953  return ActOnObjCContainerStartDefinition(IMPDecl);
1954 
1955  // Check that there is no duplicate implementation of this class.
1956  if (IDecl->getImplementation()) {
1957  // FIXME: Don't leak everything!
1958  Diag(ClassLoc, diag::err_dup_implementation_class) << ClassName;
1959  Diag(IDecl->getImplementation()->getLocation(),
1960  diag::note_previous_definition);
1961  IMPDecl->setInvalidDecl();
1962  } else { // add it to the list.
1963  IDecl->setImplementation(IMPDecl);
1964  PushOnScopeChains(IMPDecl, TUScope);
1965  // Warn on implementating deprecated class under
1966  // -Wdeprecated-implementations flag.
1968  dyn_cast<NamedDecl>(IDecl),
1969  IMPDecl->getLocation(), 1);
1970  }
1971  return ActOnObjCContainerStartDefinition(IMPDecl);
1972 }
1973 
1976  SmallVector<Decl *, 64> DeclsInGroup;
1977  DeclsInGroup.reserve(Decls.size() + 1);
1978 
1979  for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
1980  Decl *Dcl = Decls[i];
1981  if (!Dcl)
1982  continue;
1983  if (Dcl->getDeclContext()->isFileContext())
1985  DeclsInGroup.push_back(Dcl);
1986  }
1987 
1988  DeclsInGroup.push_back(ObjCImpDecl);
1989 
1990  return BuildDeclaratorGroup(DeclsInGroup, false);
1991 }
1992 
1994  ObjCIvarDecl **ivars, unsigned numIvars,
1995  SourceLocation RBrace) {
1996  assert(ImpDecl && "missing implementation decl");
1997  ObjCInterfaceDecl* IDecl = ImpDecl->getClassInterface();
1998  if (!IDecl)
1999  return;
2000  /// Check case of non-existing \@interface decl.
2001  /// (legacy objective-c \@implementation decl without an \@interface decl).
2002  /// Add implementations's ivar to the synthesize class's ivar list.
2003  if (IDecl->isImplicitInterfaceDecl()) {
2004  IDecl->setEndOfDefinitionLoc(RBrace);
2005  // Add ivar's to class's DeclContext.
2006  for (unsigned i = 0, e = numIvars; i != e; ++i) {
2007  ivars[i]->setLexicalDeclContext(ImpDecl);
2008  IDecl->makeDeclVisibleInContext(ivars[i]);
2009  ImpDecl->addDecl(ivars[i]);
2010  }
2011 
2012  return;
2013  }
2014  // If implementation has empty ivar list, just return.
2015  if (numIvars == 0)
2016  return;
2017 
2018  assert(ivars && "missing @implementation ivars");
2020  if (ImpDecl->getSuperClass())
2021  Diag(ImpDecl->getLocation(), diag::warn_on_superclass_use);
2022  for (unsigned i = 0; i < numIvars; i++) {
2023  ObjCIvarDecl* ImplIvar = ivars[i];
2024  if (const ObjCIvarDecl *ClsIvar =
2025  IDecl->getIvarDecl(ImplIvar->getIdentifier())) {
2026  Diag(ImplIvar->getLocation(), diag::err_duplicate_ivar_declaration);
2027  Diag(ClsIvar->getLocation(), diag::note_previous_definition);
2028  continue;
2029  }
2030  // Check class extensions (unnamed categories) for duplicate ivars.
2031  for (const auto *CDecl : IDecl->visible_extensions()) {
2032  if (const ObjCIvarDecl *ClsExtIvar =
2033  CDecl->getIvarDecl(ImplIvar->getIdentifier())) {
2034  Diag(ImplIvar->getLocation(), diag::err_duplicate_ivar_declaration);
2035  Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
2036  continue;
2037  }
2038  }
2039  // Instance ivar to Implementation's DeclContext.
2040  ImplIvar->setLexicalDeclContext(ImpDecl);
2041  IDecl->makeDeclVisibleInContext(ImplIvar);
2042  ImpDecl->addDecl(ImplIvar);
2043  }
2044  return;
2045  }
2046  // Check interface's Ivar list against those in the implementation.
2047  // names and types must match.
2048  //
2049  unsigned j = 0;
2051  IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end();
2052  for (; numIvars > 0 && IVI != IVE; ++IVI) {
2053  ObjCIvarDecl* ImplIvar = ivars[j++];
2054  ObjCIvarDecl* ClsIvar = *IVI;
2055  assert (ImplIvar && "missing implementation ivar");
2056  assert (ClsIvar && "missing class ivar");
2057 
2058  // First, make sure the types match.
2059  if (!Context.hasSameType(ImplIvar->getType(), ClsIvar->getType())) {
2060  Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type)
2061  << ImplIvar->getIdentifier()
2062  << ImplIvar->getType() << ClsIvar->getType();
2063  Diag(ClsIvar->getLocation(), diag::note_previous_definition);
2064  } else if (ImplIvar->isBitField() && ClsIvar->isBitField() &&
2065  ImplIvar->getBitWidthValue(Context) !=
2066  ClsIvar->getBitWidthValue(Context)) {
2067  Diag(ImplIvar->getBitWidth()->getLocStart(),
2068  diag::err_conflicting_ivar_bitwidth) << ImplIvar->getIdentifier();
2069  Diag(ClsIvar->getBitWidth()->getLocStart(),
2070  diag::note_previous_definition);
2071  }
2072  // Make sure the names are identical.
2073  if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) {
2074  Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name)
2075  << ImplIvar->getIdentifier() << ClsIvar->getIdentifier();
2076  Diag(ClsIvar->getLocation(), diag::note_previous_definition);
2077  }
2078  --numIvars;
2079  }
2080 
2081  if (numIvars > 0)
2082  Diag(ivars[j]->getLocation(), diag::err_inconsistent_ivar_count);
2083  else if (IVI != IVE)
2084  Diag(IVI->getLocation(), diag::err_inconsistent_ivar_count);
2085 }
2086 
2088  ObjCMethodDecl *method,
2089  bool &IncompleteImpl,
2090  unsigned DiagID,
2091  NamedDecl *NeededFor = nullptr) {
2092  // No point warning no definition of method which is 'unavailable'.
2093  switch (method->getAvailability()) {
2094  case AR_Available:
2095  case AR_Deprecated:
2096  break;
2097 
2098  // Don't warn about unavailable or not-yet-introduced methods.
2099  case AR_NotYetIntroduced:
2100  case AR_Unavailable:
2101  return;
2102  }
2103 
2104  // FIXME: For now ignore 'IncompleteImpl'.
2105  // Previously we grouped all unimplemented methods under a single
2106  // warning, but some users strongly voiced that they would prefer
2107  // separate warnings. We will give that approach a try, as that
2108  // matches what we do with protocols.
2109  {
2110  const Sema::SemaDiagnosticBuilder &B = S.Diag(ImpLoc, DiagID);
2111  B << method;
2112  if (NeededFor)
2113  B << NeededFor;
2114  }
2115 
2116  // Issue a note to the original declaration.
2117  SourceLocation MethodLoc = method->getLocStart();
2118  if (MethodLoc.isValid())
2119  S.Diag(MethodLoc, diag::note_method_declared_at) << method;
2120 }
2121 
2122 /// Determines if type B can be substituted for type A. Returns true if we can
2123 /// guarantee that anything that the user will do to an object of type A can
2124 /// also be done to an object of type B. This is trivially true if the two
2125 /// types are the same, or if B is a subclass of A. It becomes more complex
2126 /// in cases where protocols are involved.
2127 ///
2128 /// Object types in Objective-C describe the minimum requirements for an
2129 /// object, rather than providing a complete description of a type. For
2130 /// example, if A is a subclass of B, then B* may refer to an instance of A.
2131 /// The principle of substitutability means that we may use an instance of A
2132 /// anywhere that we may use an instance of B - it will implement all of the
2133 /// ivars of B and all of the methods of B.
2134 ///
2135 /// This substitutability is important when type checking methods, because
2136 /// the implementation may have stricter type definitions than the interface.
2137 /// The interface specifies minimum requirements, but the implementation may
2138 /// have more accurate ones. For example, a method may privately accept
2139 /// instances of B, but only publish that it accepts instances of A. Any
2140 /// object passed to it will be type checked against B, and so will implicitly
2141 /// by a valid A*. Similarly, a method may return a subclass of the class that
2142 /// it is declared as returning.
2143 ///
2144 /// This is most important when considering subclassing. A method in a
2145 /// subclass must accept any object as an argument that its superclass's
2146 /// implementation accepts. It may, however, accept a more general type
2147 /// without breaking substitutability (i.e. you can still use the subclass
2148 /// anywhere that you can use the superclass, but not vice versa). The
2149 /// converse requirement applies to return types: the return type for a
2150 /// subclass method must be a valid object of the kind that the superclass
2151 /// advertises, but it may be specified more accurately. This avoids the need
2152 /// for explicit down-casting by callers.
2153 ///
2154 /// Note: This is a stricter requirement than for assignment.
2156  const ObjCObjectPointerType *A,
2157  const ObjCObjectPointerType *B,
2158  bool rejectId) {
2159  // Reject a protocol-unqualified id.
2160  if (rejectId && B->isObjCIdType()) return false;
2161 
2162  // If B is a qualified id, then A must also be a qualified id and it must
2163  // implement all of the protocols in B. It may not be a qualified class.
2164  // For example, MyClass<A> can be assigned to id<A>, but MyClass<A> is a
2165  // stricter definition so it is not substitutable for id<A>.
2166  if (B->isObjCQualifiedIdType()) {
2167  return A->isObjCQualifiedIdType() &&
2169  QualType(B,0),
2170  false);
2171  }
2172 
2173  /*
2174  // id is a special type that bypasses type checking completely. We want a
2175  // warning when it is used in one place but not another.
2176  if (C.isObjCIdType(A) || C.isObjCIdType(B)) return false;
2177 
2178 
2179  // If B is a qualified id, then A must also be a qualified id (which it isn't
2180  // if we've got this far)
2181  if (B->isObjCQualifiedIdType()) return false;
2182  */
2183 
2184  // Now we know that A and B are (potentially-qualified) class types. The
2185  // normal rules for assignment apply.
2186  return Context.canAssignObjCInterfaces(A, B);
2187 }
2188 
2190  return (TSI ? TSI->getTypeLoc().getSourceRange() : SourceRange());
2191 }
2192 
2193 /// Determine whether two set of Objective-C declaration qualifiers conflict.
2196  return (x & ~Decl::OBJC_TQ_CSNullability) !=
2197  (y & ~Decl::OBJC_TQ_CSNullability);
2198 }
2199 
2201  ObjCMethodDecl *MethodImpl,
2202  ObjCMethodDecl *MethodDecl,
2203  bool IsProtocolMethodDecl,
2204  bool IsOverridingMode,
2205  bool Warn) {
2206  if (IsProtocolMethodDecl &&
2208  MethodImpl->getObjCDeclQualifier())) {
2209  if (Warn) {
2210  S.Diag(MethodImpl->getLocation(),
2211  (IsOverridingMode
2212  ? diag::warn_conflicting_overriding_ret_type_modifiers
2213  : diag::warn_conflicting_ret_type_modifiers))
2214  << MethodImpl->getDeclName()
2215  << MethodImpl->getReturnTypeSourceRange();
2216  S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration)
2217  << MethodDecl->getReturnTypeSourceRange();
2218  }
2219  else
2220  return false;
2221  }
2222  if (Warn && IsOverridingMode &&
2223  !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) &&
2225  MethodDecl->getReturnType(),
2226  false)) {
2227  auto nullabilityMethodImpl =
2228  *MethodImpl->getReturnType()->getNullability(S.Context);
2229  auto nullabilityMethodDecl =
2230  *MethodDecl->getReturnType()->getNullability(S.Context);
2231  S.Diag(MethodImpl->getLocation(),
2232  diag::warn_conflicting_nullability_attr_overriding_ret_types)
2234  nullabilityMethodImpl,
2236  != 0))
2238  nullabilityMethodDecl,
2240  != 0));
2241  S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
2242  }
2243 
2244  if (S.Context.hasSameUnqualifiedType(MethodImpl->getReturnType(),
2245  MethodDecl->getReturnType()))
2246  return true;
2247  if (!Warn)
2248  return false;
2249 
2250  unsigned DiagID =
2251  IsOverridingMode ? diag::warn_conflicting_overriding_ret_types
2252  : diag::warn_conflicting_ret_types;
2253 
2254  // Mismatches between ObjC pointers go into a different warning
2255  // category, and sometimes they're even completely whitelisted.
2256  if (const ObjCObjectPointerType *ImplPtrTy =
2257  MethodImpl->getReturnType()->getAs<ObjCObjectPointerType>()) {
2258  if (const ObjCObjectPointerType *IfacePtrTy =
2259  MethodDecl->getReturnType()->getAs<ObjCObjectPointerType>()) {
2260  // Allow non-matching return types as long as they don't violate
2261  // the principle of substitutability. Specifically, we permit
2262  // return types that are subclasses of the declared return type,
2263  // or that are more-qualified versions of the declared type.
2264  if (isObjCTypeSubstitutable(S.Context, IfacePtrTy, ImplPtrTy, false))
2265  return false;
2266 
2267  DiagID =
2268  IsOverridingMode ? diag::warn_non_covariant_overriding_ret_types
2269  : diag::warn_non_covariant_ret_types;
2270  }
2271  }
2272 
2273  S.Diag(MethodImpl->getLocation(), DiagID)
2274  << MethodImpl->getDeclName() << MethodDecl->getReturnType()
2275  << MethodImpl->getReturnType()
2276  << MethodImpl->getReturnTypeSourceRange();
2277  S.Diag(MethodDecl->getLocation(), IsOverridingMode
2278  ? diag::note_previous_declaration
2279  : diag::note_previous_definition)
2280  << MethodDecl->getReturnTypeSourceRange();
2281  return false;
2282 }
2283 
2285  ObjCMethodDecl *MethodImpl,
2286  ObjCMethodDecl *MethodDecl,
2287  ParmVarDecl *ImplVar,
2288  ParmVarDecl *IfaceVar,
2289  bool IsProtocolMethodDecl,
2290  bool IsOverridingMode,
2291  bool Warn) {
2292  if (IsProtocolMethodDecl &&
2294  IfaceVar->getObjCDeclQualifier())) {
2295  if (Warn) {
2296  if (IsOverridingMode)
2297  S.Diag(ImplVar->getLocation(),
2298  diag::warn_conflicting_overriding_param_modifiers)
2299  << getTypeRange(ImplVar->getTypeSourceInfo())
2300  << MethodImpl->getDeclName();
2301  else S.Diag(ImplVar->getLocation(),
2302  diag::warn_conflicting_param_modifiers)
2303  << getTypeRange(ImplVar->getTypeSourceInfo())
2304  << MethodImpl->getDeclName();
2305  S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration)
2306  << getTypeRange(IfaceVar->getTypeSourceInfo());
2307  }
2308  else
2309  return false;
2310  }
2311 
2312  QualType ImplTy = ImplVar->getType();
2313  QualType IfaceTy = IfaceVar->getType();
2314  if (Warn && IsOverridingMode &&
2315  !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) &&
2316  !S.Context.hasSameNullabilityTypeQualifier(ImplTy, IfaceTy, true)) {
2317  S.Diag(ImplVar->getLocation(),
2318  diag::warn_conflicting_nullability_attr_overriding_param_types)
2320  *ImplTy->getNullability(S.Context),
2322  != 0))
2324  *IfaceTy->getNullability(S.Context),
2326  != 0));
2327  S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration);
2328  }
2329  if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy))
2330  return true;
2331 
2332  if (!Warn)
2333  return false;
2334  unsigned DiagID =
2335  IsOverridingMode ? diag::warn_conflicting_overriding_param_types
2336  : diag::warn_conflicting_param_types;
2337 
2338  // Mismatches between ObjC pointers go into a different warning
2339  // category, and sometimes they're even completely whitelisted.
2340  if (const ObjCObjectPointerType *ImplPtrTy =
2341  ImplTy->getAs<ObjCObjectPointerType>()) {
2342  if (const ObjCObjectPointerType *IfacePtrTy =
2343  IfaceTy->getAs<ObjCObjectPointerType>()) {
2344  // Allow non-matching argument types as long as they don't
2345  // violate the principle of substitutability. Specifically, the
2346  // implementation must accept any objects that the superclass
2347  // accepts, however it may also accept others.
2348  if (isObjCTypeSubstitutable(S.Context, ImplPtrTy, IfacePtrTy, true))
2349  return false;
2350 
2351  DiagID =
2352  IsOverridingMode ? diag::warn_non_contravariant_overriding_param_types
2353  : diag::warn_non_contravariant_param_types;
2354  }
2355  }
2356 
2357  S.Diag(ImplVar->getLocation(), DiagID)
2358  << getTypeRange(ImplVar->getTypeSourceInfo())
2359  << MethodImpl->getDeclName() << IfaceTy << ImplTy;
2360  S.Diag(IfaceVar->getLocation(),
2361  (IsOverridingMode ? diag::note_previous_declaration
2362  : diag::note_previous_definition))
2363  << getTypeRange(IfaceVar->getTypeSourceInfo());
2364  return false;
2365 }
2366 
2367 /// In ARC, check whether the conventional meanings of the two methods
2368 /// match. If they don't, it's a hard error.
2370  ObjCMethodDecl *decl) {
2371  ObjCMethodFamily implFamily = impl->getMethodFamily();
2372  ObjCMethodFamily declFamily = decl->getMethodFamily();
2373  if (implFamily == declFamily) return false;
2374 
2375  // Since conventions are sorted by selector, the only possibility is
2376  // that the types differ enough to cause one selector or the other
2377  // to fall out of the family.
2378  assert(implFamily == OMF_None || declFamily == OMF_None);
2379 
2380  // No further diagnostics required on invalid declarations.
2381  if (impl->isInvalidDecl() || decl->isInvalidDecl()) return true;
2382 
2383  const ObjCMethodDecl *unmatched = impl;
2384  ObjCMethodFamily family = declFamily;
2385  unsigned errorID = diag::err_arc_lost_method_convention;
2386  unsigned noteID = diag::note_arc_lost_method_convention;
2387  if (declFamily == OMF_None) {
2388  unmatched = decl;
2389  family = implFamily;
2390  errorID = diag::err_arc_gained_method_convention;
2391  noteID = diag::note_arc_gained_method_convention;
2392  }
2393 
2394  // Indexes into a %select clause in the diagnostic.
2395  enum FamilySelector {
2396  F_alloc, F_copy, F_mutableCopy = F_copy, F_init, F_new
2397  };
2398  FamilySelector familySelector = FamilySelector();
2399 
2400  switch (family) {
2401  case OMF_None: llvm_unreachable("logic error, no method convention");
2402  case OMF_retain:
2403  case OMF_release:
2404  case OMF_autorelease:
2405  case OMF_dealloc:
2406  case OMF_finalize:
2407  case OMF_retainCount:
2408  case OMF_self:
2409  case OMF_initialize:
2410  case OMF_performSelector:
2411  // Mismatches for these methods don't change ownership
2412  // conventions, so we don't care.
2413  return false;
2414 
2415  case OMF_init: familySelector = F_init; break;
2416  case OMF_alloc: familySelector = F_alloc; break;
2417  case OMF_copy: familySelector = F_copy; break;
2418  case OMF_mutableCopy: familySelector = F_mutableCopy; break;
2419  case OMF_new: familySelector = F_new; break;
2420  }
2421 
2422  enum ReasonSelector { R_NonObjectReturn, R_UnrelatedReturn };
2423  ReasonSelector reasonSelector;
2424 
2425  // The only reason these methods don't fall within their families is
2426  // due to unusual result types.
2427  if (unmatched->getReturnType()->isObjCObjectPointerType()) {
2428  reasonSelector = R_UnrelatedReturn;
2429  } else {
2430  reasonSelector = R_NonObjectReturn;
2431  }
2432 
2433  S.Diag(impl->getLocation(), errorID) << int(familySelector) << int(reasonSelector);
2434  S.Diag(decl->getLocation(), noteID) << int(familySelector) << int(reasonSelector);
2435 
2436  return true;
2437 }
2438 
2440  ObjCMethodDecl *MethodDecl,
2441  bool IsProtocolMethodDecl) {
2442  if (getLangOpts().ObjCAutoRefCount &&
2443  checkMethodFamilyMismatch(*this, ImpMethodDecl, MethodDecl))
2444  return;
2445 
2446  CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl,
2447  IsProtocolMethodDecl, false,
2448  true);
2449 
2450  for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
2451  IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
2452  EF = MethodDecl->param_end();
2453  IM != EM && IF != EF; ++IM, ++IF) {
2454  CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl, *IM, *IF,
2455  IsProtocolMethodDecl, false, true);
2456  }
2457 
2458  if (ImpMethodDecl->isVariadic() != MethodDecl->isVariadic()) {
2459  Diag(ImpMethodDecl->getLocation(),
2460  diag::warn_conflicting_variadic);
2461  Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
2462  }
2463 }
2464 
2466  ObjCMethodDecl *Overridden,
2467  bool IsProtocolMethodDecl) {
2468 
2469  CheckMethodOverrideReturn(*this, Method, Overridden,
2470  IsProtocolMethodDecl, true,
2471  true);
2472 
2473  for (ObjCMethodDecl::param_iterator IM = Method->param_begin(),
2474  IF = Overridden->param_begin(), EM = Method->param_end(),
2475  EF = Overridden->param_end();
2476  IM != EM && IF != EF; ++IM, ++IF) {
2477  CheckMethodOverrideParam(*this, Method, Overridden, *IM, *IF,
2478  IsProtocolMethodDecl, true, true);
2479  }
2480 
2481  if (Method->isVariadic() != Overridden->isVariadic()) {
2482  Diag(Method->getLocation(),
2483  diag::warn_conflicting_overriding_variadic);
2484  Diag(Overridden->getLocation(), diag::note_previous_declaration);
2485  }
2486 }
2487 
2488 /// WarnExactTypedMethods - This routine issues a warning if method
2489 /// implementation declaration matches exactly that of its declaration.
2491  ObjCMethodDecl *MethodDecl,
2492  bool IsProtocolMethodDecl) {
2493  // don't issue warning when protocol method is optional because primary
2494  // class is not required to implement it and it is safe for protocol
2495  // to implement it.
2497  return;
2498  // don't issue warning when primary class's method is
2499  // depecated/unavailable.
2500  if (MethodDecl->hasAttr<UnavailableAttr>() ||
2501  MethodDecl->hasAttr<DeprecatedAttr>())
2502  return;
2503 
2504  bool match = CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl,
2505  IsProtocolMethodDecl, false, false);
2506  if (match)
2507  for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
2508  IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
2509  EF = MethodDecl->param_end();
2510  IM != EM && IF != EF; ++IM, ++IF) {
2511  match = CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl,
2512  *IM, *IF,
2513  IsProtocolMethodDecl, false, false);
2514  if (!match)
2515  break;
2516  }
2517  if (match)
2518  match = (ImpMethodDecl->isVariadic() == MethodDecl->isVariadic());
2519  if (match)
2520  match = !(MethodDecl->isClassMethod() &&
2521  MethodDecl->getSelector() == GetNullarySelector("load", Context));
2522 
2523  if (match) {
2524  Diag(ImpMethodDecl->getLocation(),
2525  diag::warn_category_method_impl_match);
2526  Diag(MethodDecl->getLocation(), diag::note_method_declared_at)
2527  << MethodDecl->getDeclName();
2528  }
2529 }
2530 
2531 /// FIXME: Type hierarchies in Objective-C can be deep. We could most likely
2532 /// improve the efficiency of selector lookups and type checking by associating
2533 /// with each protocol / interface / category the flattened instance tables. If
2534 /// we used an immutable set to keep the table then it wouldn't add significant
2535 /// memory cost and it would be handy for lookups.
2536 
2538 typedef std::unique_ptr<ProtocolNameSet> LazyProtocolNameSet;
2539 
2541  ProtocolNameSet &PNS) {
2542  if (PDecl->hasAttr<ObjCExplicitProtocolImplAttr>())
2543  PNS.insert(PDecl->getIdentifier());
2544  for (const auto *PI : PDecl->protocols())
2546 }
2547 
2548 /// Recursively populates a set with all conformed protocols in a class
2549 /// hierarchy that have the 'objc_protocol_requires_explicit_implementation'
2550 /// attribute.
2552  ProtocolNameSet &PNS) {
2553  if (!Super)
2554  return;
2555 
2556  for (const auto *I : Super->all_referenced_protocols())
2558 
2560 }
2561 
2562 /// CheckProtocolMethodDefs - This routine checks unimplemented methods
2563 /// Declared in protocol, and those referenced by it.
2565  SourceLocation ImpLoc,
2566  ObjCProtocolDecl *PDecl,
2567  bool& IncompleteImpl,
2568  const Sema::SelectorSet &InsMap,
2569  const Sema::SelectorSet &ClsMap,
2570  ObjCContainerDecl *CDecl,
2571  LazyProtocolNameSet &ProtocolsExplictImpl) {
2572  ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl);
2573  ObjCInterfaceDecl *IDecl = C ? C->getClassInterface()
2574  : dyn_cast<ObjCInterfaceDecl>(CDecl);
2575  assert (IDecl && "CheckProtocolMethodDefs - IDecl is null");
2576 
2577  ObjCInterfaceDecl *Super = IDecl->getSuperClass();
2578  ObjCInterfaceDecl *NSIDecl = nullptr;
2579 
2580  // If this protocol is marked 'objc_protocol_requires_explicit_implementation'
2581  // then we should check if any class in the super class hierarchy also
2582  // conforms to this protocol, either directly or via protocol inheritance.
2583  // If so, we can skip checking this protocol completely because we
2584  // know that a parent class already satisfies this protocol.
2585  //
2586  // Note: we could generalize this logic for all protocols, and merely
2587  // add the limit on looking at the super class chain for just
2588  // specially marked protocols. This may be a good optimization. This
2589  // change is restricted to 'objc_protocol_requires_explicit_implementation'
2590  // protocols for now for controlled evaluation.
2591  if (PDecl->hasAttr<ObjCExplicitProtocolImplAttr>()) {
2592  if (!ProtocolsExplictImpl) {
2593  ProtocolsExplictImpl.reset(new ProtocolNameSet);
2594  findProtocolsWithExplicitImpls(Super, *ProtocolsExplictImpl);
2595  }
2596  if (ProtocolsExplictImpl->find(PDecl->getIdentifier()) !=
2597  ProtocolsExplictImpl->end())
2598  return;
2599 
2600  // If no super class conforms to the protocol, we should not search
2601  // for methods in the super class to implicitly satisfy the protocol.
2602  Super = nullptr;
2603  }
2604 
2605  if (S.getLangOpts().ObjCRuntime.isNeXTFamily()) {
2606  // check to see if class implements forwardInvocation method and objects
2607  // of this class are derived from 'NSProxy' so that to forward requests
2608  // from one object to another.
2609  // Under such conditions, which means that every method possible is
2610  // implemented in the class, we should not issue "Method definition not
2611  // found" warnings.
2612  // FIXME: Use a general GetUnarySelector method for this.
2613  IdentifierInfo* II = &S.Context.Idents.get("forwardInvocation");
2614  Selector fISelector = S.Context.Selectors.getSelector(1, &II);
2615  if (InsMap.count(fISelector))
2616  // Is IDecl derived from 'NSProxy'? If so, no instance methods
2617  // need be implemented in the implementation.
2618  NSIDecl = IDecl->lookupInheritedClass(&S.Context.Idents.get("NSProxy"));
2619  }
2620 
2621  // If this is a forward protocol declaration, get its definition.
2622  if (!PDecl->isThisDeclarationADefinition() &&
2623  PDecl->getDefinition())
2624  PDecl = PDecl->getDefinition();
2625 
2626  // If a method lookup fails locally we still need to look and see if
2627  // the method was implemented by a base class or an inherited
2628  // protocol. This lookup is slow, but occurs rarely in correct code
2629  // and otherwise would terminate in a warning.
2630 
2631  // check unimplemented instance methods.
2632  if (!NSIDecl)
2633  for (auto *method : PDecl->instance_methods()) {
2634  if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
2635  !method->isPropertyAccessor() &&
2636  !InsMap.count(method->getSelector()) &&
2637  (!Super || !Super->lookupMethod(method->getSelector(),
2638  true /* instance */,
2639  false /* shallowCategory */,
2640  true /* followsSuper */,
2641  nullptr /* category */))) {
2642  // If a method is not implemented in the category implementation but
2643  // has been declared in its primary class, superclass,
2644  // or in one of their protocols, no need to issue the warning.
2645  // This is because method will be implemented in the primary class
2646  // or one of its super class implementation.
2647 
2648  // Ugly, but necessary. Method declared in protcol might have
2649  // have been synthesized due to a property declared in the class which
2650  // uses the protocol.
2651  if (ObjCMethodDecl *MethodInClass =
2652  IDecl->lookupMethod(method->getSelector(),
2653  true /* instance */,
2654  true /* shallowCategoryLookup */,
2655  false /* followSuper */))
2656  if (C || MethodInClass->isPropertyAccessor())
2657  continue;
2658  unsigned DIAG = diag::warn_unimplemented_protocol_method;
2659  if (!S.Diags.isIgnored(DIAG, ImpLoc)) {
2660  WarnUndefinedMethod(S, ImpLoc, method, IncompleteImpl, DIAG,
2661  PDecl);
2662  }
2663  }
2664  }
2665  // check unimplemented class methods
2666  for (auto *method : PDecl->class_methods()) {
2667  if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
2668  !ClsMap.count(method->getSelector()) &&
2669  (!Super || !Super->lookupMethod(method->getSelector(),
2670  false /* class method */,
2671  false /* shallowCategoryLookup */,
2672  true /* followSuper */,
2673  nullptr /* category */))) {
2674  // See above comment for instance method lookups.
2675  if (C && IDecl->lookupMethod(method->getSelector(),
2676  false /* class */,
2677  true /* shallowCategoryLookup */,
2678  false /* followSuper */))
2679  continue;
2680 
2681  unsigned DIAG = diag::warn_unimplemented_protocol_method;
2682  if (!S.Diags.isIgnored(DIAG, ImpLoc)) {
2683  WarnUndefinedMethod(S, ImpLoc, method, IncompleteImpl, DIAG, PDecl);
2684  }
2685  }
2686  }
2687  // Check on this protocols's referenced protocols, recursively.
2688  for (auto *PI : PDecl->protocols())
2689  CheckProtocolMethodDefs(S, ImpLoc, PI, IncompleteImpl, InsMap, ClsMap,
2690  CDecl, ProtocolsExplictImpl);
2691 }
2692 
2693 /// MatchAllMethodDeclarations - Check methods declared in interface
2694 /// or protocol against those declared in their implementations.
2695 ///
2697  const SelectorSet &ClsMap,
2698  SelectorSet &InsMapSeen,
2699  SelectorSet &ClsMapSeen,
2700  ObjCImplDecl* IMPDecl,
2701  ObjCContainerDecl* CDecl,
2702  bool &IncompleteImpl,
2703  bool ImmediateClass,
2704  bool WarnCategoryMethodImpl) {
2705  // Check and see if instance methods in class interface have been
2706  // implemented in the implementation class. If so, their types match.
2707  for (auto *I : CDecl->instance_methods()) {
2708  if (!InsMapSeen.insert(I->getSelector()).second)
2709  continue;
2710  if (!I->isPropertyAccessor() &&
2711  !InsMap.count(I->getSelector())) {
2712  if (ImmediateClass)
2713  WarnUndefinedMethod(*this, IMPDecl->getLocation(), I, IncompleteImpl,
2714  diag::warn_undef_method_impl);
2715  continue;
2716  } else {
2717  ObjCMethodDecl *ImpMethodDecl =
2718  IMPDecl->getInstanceMethod(I->getSelector());
2719  assert(CDecl->getInstanceMethod(I->getSelector()) &&
2720  "Expected to find the method through lookup as well");
2721  // ImpMethodDecl may be null as in a @dynamic property.
2722  if (ImpMethodDecl) {
2723  if (!WarnCategoryMethodImpl)
2724  WarnConflictingTypedMethods(ImpMethodDecl, I,
2725  isa<ObjCProtocolDecl>(CDecl));
2726  else if (!I->isPropertyAccessor())
2727  WarnExactTypedMethods(ImpMethodDecl, I, isa<ObjCProtocolDecl>(CDecl));
2728  }
2729  }
2730  }
2731 
2732  // Check and see if class methods in class interface have been
2733  // implemented in the implementation class. If so, their types match.
2734  for (auto *I : CDecl->class_methods()) {
2735  if (!ClsMapSeen.insert(I->getSelector()).second)
2736  continue;
2737  if (!ClsMap.count(I->getSelector())) {
2738  if (ImmediateClass)
2739  WarnUndefinedMethod(*this, IMPDecl->getLocation(), I, IncompleteImpl,
2740  diag::warn_undef_method_impl);
2741  } else {
2742  ObjCMethodDecl *ImpMethodDecl =
2743  IMPDecl->getClassMethod(I->getSelector());
2744  assert(CDecl->getClassMethod(I->getSelector()) &&
2745  "Expected to find the method through lookup as well");
2746  if (!WarnCategoryMethodImpl)
2747  WarnConflictingTypedMethods(ImpMethodDecl, I,
2748  isa<ObjCProtocolDecl>(CDecl));
2749  else
2750  WarnExactTypedMethods(ImpMethodDecl, I,
2751  isa<ObjCProtocolDecl>(CDecl));
2752  }
2753  }
2754 
2755  if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl> (CDecl)) {
2756  // Also, check for methods declared in protocols inherited by
2757  // this protocol.
2758  for (auto *PI : PD->protocols())
2759  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2760  IMPDecl, PI, IncompleteImpl, false,
2761  WarnCategoryMethodImpl);
2762  }
2763 
2764  if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
2765  // when checking that methods in implementation match their declaration,
2766  // i.e. when WarnCategoryMethodImpl is false, check declarations in class
2767  // extension; as well as those in categories.
2768  if (!WarnCategoryMethodImpl) {
2769  for (auto *Cat : I->visible_categories())
2770  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2771  IMPDecl, Cat, IncompleteImpl,
2772  ImmediateClass && Cat->IsClassExtension(),
2773  WarnCategoryMethodImpl);
2774  } else {
2775  // Also methods in class extensions need be looked at next.
2776  for (auto *Ext : I->visible_extensions())
2777  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2778  IMPDecl, Ext, IncompleteImpl, false,
2779  WarnCategoryMethodImpl);
2780  }
2781 
2782  // Check for any implementation of a methods declared in protocol.
2783  for (auto *PI : I->all_referenced_protocols())
2784  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2785  IMPDecl, PI, IncompleteImpl, false,
2786  WarnCategoryMethodImpl);
2787 
2788  // FIXME. For now, we are not checking for extact match of methods
2789  // in category implementation and its primary class's super class.
2790  if (!WarnCategoryMethodImpl && I->getSuperClass())
2791  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2792  IMPDecl,
2793  I->getSuperClass(), IncompleteImpl, false);
2794  }
2795 }
2796 
2797 /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
2798 /// category matches with those implemented in its primary class and
2799 /// warns each time an exact match is found.
2801  ObjCCategoryImplDecl *CatIMPDecl) {
2802  // Get category's primary class.
2803  ObjCCategoryDecl *CatDecl = CatIMPDecl->getCategoryDecl();
2804  if (!CatDecl)
2805  return;
2806  ObjCInterfaceDecl *IDecl = CatDecl->getClassInterface();
2807  if (!IDecl)
2808  return;
2809  ObjCInterfaceDecl *SuperIDecl = IDecl->getSuperClass();
2810  SelectorSet InsMap, ClsMap;
2811 
2812  for (const auto *I : CatIMPDecl->instance_methods()) {
2813  Selector Sel = I->getSelector();
2814  // When checking for methods implemented in the category, skip over
2815  // those declared in category class's super class. This is because
2816  // the super class must implement the method.
2817  if (SuperIDecl && SuperIDecl->lookupMethod(Sel, true))
2818  continue;
2819  InsMap.insert(Sel);
2820  }
2821 
2822  for (const auto *I : CatIMPDecl->class_methods()) {
2823  Selector Sel = I->getSelector();
2824  if (SuperIDecl && SuperIDecl->lookupMethod(Sel, false))
2825  continue;
2826  ClsMap.insert(Sel);
2827  }
2828  if (InsMap.empty() && ClsMap.empty())
2829  return;
2830 
2831  SelectorSet InsMapSeen, ClsMapSeen;
2832  bool IncompleteImpl = false;
2833  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2834  CatIMPDecl, IDecl,
2835  IncompleteImpl, false,
2836  true /*WarnCategoryMethodImpl*/);
2837 }
2838 
2840  ObjCContainerDecl* CDecl,
2841  bool IncompleteImpl) {
2842  SelectorSet InsMap;
2843  // Check and see if instance methods in class interface have been
2844  // implemented in the implementation class.
2845  for (const auto *I : IMPDecl->instance_methods())
2846  InsMap.insert(I->getSelector());
2847 
2848  // Add the selectors for getters/setters of @dynamic properties.
2849  for (const auto *PImpl : IMPDecl->property_impls()) {
2850  // We only care about @dynamic implementations.
2851  if (PImpl->getPropertyImplementation() != ObjCPropertyImplDecl::Dynamic)
2852  continue;
2853 
2854  const auto *P = PImpl->getPropertyDecl();
2855  if (!P) continue;
2856 
2857  InsMap.insert(P->getGetterName());
2858  if (!P->getSetterName().isNull())
2859  InsMap.insert(P->getSetterName());
2860  }
2861 
2862  // Check and see if properties declared in the interface have either 1)
2863  // an implementation or 2) there is a @synthesize/@dynamic implementation
2864  // of the property in the @implementation.
2865  if (const ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2866  bool SynthesizeProperties = LangOpts.ObjCDefaultSynthProperties &&
2868  !IDecl->isObjCRequiresPropertyDefs();
2869  DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, SynthesizeProperties);
2870  }
2871 
2872  // Diagnose null-resettable synthesized setters.
2874 
2875  SelectorSet ClsMap;
2876  for (const auto *I : IMPDecl->class_methods())
2877  ClsMap.insert(I->getSelector());
2878 
2879  // Check for type conflict of methods declared in a class/protocol and
2880  // its implementation; if any.
2881  SelectorSet InsMapSeen, ClsMapSeen;
2882  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2883  IMPDecl, CDecl,
2884  IncompleteImpl, true);
2885 
2886  // check all methods implemented in category against those declared
2887  // in its primary class.
2888  if (ObjCCategoryImplDecl *CatDecl =
2889  dyn_cast<ObjCCategoryImplDecl>(IMPDecl))
2891 
2892  // Check the protocol list for unimplemented methods in the @implementation
2893  // class.
2894  // Check and see if class methods in class interface have been
2895  // implemented in the implementation class.
2896 
2897  LazyProtocolNameSet ExplicitImplProtocols;
2898 
2899  if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
2900  for (auto *PI : I->all_referenced_protocols())
2901  CheckProtocolMethodDefs(*this, IMPDecl->getLocation(), PI, IncompleteImpl,
2902  InsMap, ClsMap, I, ExplicitImplProtocols);
2903  } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2904  // For extended class, unimplemented methods in its protocols will
2905  // be reported in the primary class.
2906  if (!C->IsClassExtension()) {
2907  for (auto *P : C->protocols())
2908  CheckProtocolMethodDefs(*this, IMPDecl->getLocation(), P,
2909  IncompleteImpl, InsMap, ClsMap, CDecl,
2910  ExplicitImplProtocols);
2911  DiagnoseUnimplementedProperties(S, IMPDecl, CDecl,
2912  /*SynthesizeProperties=*/false);
2913  }
2914  } else
2915  llvm_unreachable("invalid ObjCContainerDecl type.");
2916 }
2917 
2920  IdentifierInfo **IdentList,
2921  SourceLocation *IdentLocs,
2922  ArrayRef<ObjCTypeParamList *> TypeParamLists,
2923  unsigned NumElts) {
2924  SmallVector<Decl *, 8> DeclsInGroup;
2925  for (unsigned i = 0; i != NumElts; ++i) {
2926  // Check for another declaration kind with the same name.
2927  NamedDecl *PrevDecl
2928  = LookupSingleName(TUScope, IdentList[i], IdentLocs[i],
2930  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
2931  // GCC apparently allows the following idiom:
2932  //
2933  // typedef NSObject < XCElementTogglerP > XCElementToggler;
2934  // @class XCElementToggler;
2935  //
2936  // Here we have chosen to ignore the forward class declaration
2937  // with a warning. Since this is the implied behavior.
2938  TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(PrevDecl);
2939  if (!TDD || !TDD->getUnderlyingType()->isObjCObjectType()) {
2940  Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];
2941  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
2942  } else {
2943  // a forward class declaration matching a typedef name of a class refers
2944  // to the underlying class. Just ignore the forward class with a warning
2945  // as this will force the intended behavior which is to lookup the
2946  // typedef name.
2947  if (isa<ObjCObjectType>(TDD->getUnderlyingType())) {
2948  Diag(AtClassLoc, diag::warn_forward_class_redefinition)
2949  << IdentList[i];
2950  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
2951  continue;
2952  }
2953  }
2954  }
2955 
2956  // Create a declaration to describe this forward declaration.
2957  ObjCInterfaceDecl *PrevIDecl
2958  = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
2959 
2960  IdentifierInfo *ClassName = IdentList[i];
2961  if (PrevIDecl && PrevIDecl->getIdentifier() != ClassName) {
2962  // A previous decl with a different name is because of
2963  // @compatibility_alias, for example:
2964  // \code
2965  // @class NewImage;
2966  // @compatibility_alias OldImage NewImage;
2967  // \endcode
2968  // A lookup for 'OldImage' will return the 'NewImage' decl.
2969  //
2970  // In such a case use the real declaration name, instead of the alias one,
2971  // otherwise we will break IdentifierResolver and redecls-chain invariants.
2972  // FIXME: If necessary, add a bit to indicate that this ObjCInterfaceDecl
2973  // has been aliased.
2974  ClassName = PrevIDecl->getIdentifier();
2975  }
2976 
2977  // If this forward declaration has type parameters, compare them with the
2978  // type parameters of the previous declaration.
2979  ObjCTypeParamList *TypeParams = TypeParamLists[i];
2980  if (PrevIDecl && TypeParams) {
2981  if (ObjCTypeParamList *PrevTypeParams = PrevIDecl->getTypeParamList()) {
2982  // Check for consistency with the previous declaration.
2984  *this, PrevTypeParams, TypeParams,
2985  TypeParamListContext::ForwardDeclaration)) {
2986  TypeParams = nullptr;
2987  }
2988  } else if (ObjCInterfaceDecl *Def = PrevIDecl->getDefinition()) {
2989  // The @interface does not have type parameters. Complain.
2990  Diag(IdentLocs[i], diag::err_objc_parameterized_forward_class)
2991  << ClassName
2992  << TypeParams->getSourceRange();
2993  Diag(Def->getLocation(), diag::note_defined_here)
2994  << ClassName;
2995 
2996  TypeParams = nullptr;
2997  }
2998  }
2999 
3000  ObjCInterfaceDecl *IDecl
3002  ClassName, TypeParams, PrevIDecl,
3003  IdentLocs[i]);
3004  IDecl->setAtEndRange(IdentLocs[i]);
3005 
3006  PushOnScopeChains(IDecl, TUScope);
3007  CheckObjCDeclScope(IDecl);
3008  DeclsInGroup.push_back(IDecl);
3009  }
3010 
3011  return BuildDeclaratorGroup(DeclsInGroup, false);
3012 }
3013 
3015  Sema::MethodMatchStrategy strategy,
3016  const Type *left, const Type *right);
3017 
3019  QualType leftQT, QualType rightQT) {
3020  const Type *left =
3021  Context.getCanonicalType(leftQT).getUnqualifiedType().getTypePtr();
3022  const Type *right =
3023  Context.getCanonicalType(rightQT).getUnqualifiedType().getTypePtr();
3024 
3025  if (left == right) return true;
3026 
3027  // If we're doing a strict match, the types have to match exactly.
3028  if (strategy == Sema::MMS_strict) return false;
3029 
3030  if (left->isIncompleteType() || right->isIncompleteType()) return false;
3031 
3032  // Otherwise, use this absurdly complicated algorithm to try to
3033  // validate the basic, low-level compatibility of the two types.
3034 
3035  // As a minimum, require the sizes and alignments to match.
3036  TypeInfo LeftTI = Context.getTypeInfo(left);
3037  TypeInfo RightTI = Context.getTypeInfo(right);
3038  if (LeftTI.Width != RightTI.Width)
3039  return false;
3040 
3041  if (LeftTI.Align != RightTI.Align)
3042  return false;
3043 
3044  // Consider all the kinds of non-dependent canonical types:
3045  // - functions and arrays aren't possible as return and parameter types
3046 
3047  // - vector types of equal size can be arbitrarily mixed
3048  if (isa<VectorType>(left)) return isa<VectorType>(right);
3049  if (isa<VectorType>(right)) return false;
3050 
3051  // - references should only match references of identical type
3052  // - structs, unions, and Objective-C objects must match more-or-less
3053  // exactly
3054  // - everything else should be a scalar
3055  if (!left->isScalarType() || !right->isScalarType())
3056  return tryMatchRecordTypes(Context, strategy, left, right);
3057 
3058  // Make scalars agree in kind, except count bools as chars, and group
3059  // all non-member pointers together.
3060  Type::ScalarTypeKind leftSK = left->getScalarTypeKind();
3061  Type::ScalarTypeKind rightSK = right->getScalarTypeKind();
3062  if (leftSK == Type::STK_Bool) leftSK = Type::STK_Integral;
3063  if (rightSK == Type::STK_Bool) rightSK = Type::STK_Integral;
3064  if (leftSK == Type::STK_CPointer || leftSK == Type::STK_BlockPointer)
3065  leftSK = Type::STK_ObjCObjectPointer;
3066  if (rightSK == Type::STK_CPointer || rightSK == Type::STK_BlockPointer)
3067  rightSK = Type::STK_ObjCObjectPointer;
3068 
3069  // Note that data member pointers and function member pointers don't
3070  // intermix because of the size differences.
3071 
3072  return (leftSK == rightSK);
3073 }
3074 
3076  Sema::MethodMatchStrategy strategy,
3077  const Type *lt, const Type *rt) {
3078  assert(lt && rt && lt != rt);
3079 
3080  if (!isa<RecordType>(lt) || !isa<RecordType>(rt)) return false;
3081  RecordDecl *left = cast<RecordType>(lt)->getDecl();
3082  RecordDecl *right = cast<RecordType>(rt)->getDecl();
3083 
3084  // Require union-hood to match.
3085  if (left->isUnion() != right->isUnion()) return false;
3086 
3087  // Require an exact match if either is non-POD.
3088  if ((isa<CXXRecordDecl>(left) && !cast<CXXRecordDecl>(left)->isPOD()) ||
3089  (isa<CXXRecordDecl>(right) && !cast<CXXRecordDecl>(right)->isPOD()))
3090  return false;
3091 
3092  // Require size and alignment to match.
3093  TypeInfo LeftTI = Context.getTypeInfo(lt);
3094  TypeInfo RightTI = Context.getTypeInfo(rt);
3095  if (LeftTI.Width != RightTI.Width)
3096  return false;
3097 
3098  if (LeftTI.Align != RightTI.Align)
3099  return false;
3100 
3101  // Require fields to match.
3102  RecordDecl::field_iterator li = left->field_begin(), le = left->field_end();
3103  RecordDecl::field_iterator ri = right->field_begin(), re = right->field_end();
3104  for (; li != le && ri != re; ++li, ++ri) {
3105  if (!matchTypes(Context, strategy, li->getType(), ri->getType()))
3106  return false;
3107  }
3108  return (li == le && ri == re);
3109 }
3110 
3111 /// MatchTwoMethodDeclarations - Checks that two methods have matching type and
3112 /// returns true, or false, accordingly.
3113 /// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
3115  const ObjCMethodDecl *right,
3116  MethodMatchStrategy strategy) {
3117  if (!matchTypes(Context, strategy, left->getReturnType(),
3118  right->getReturnType()))
3119  return false;
3120 
3121  // If either is hidden, it is not considered to match.
3122  if (left->isHidden() || right->isHidden())
3123  return false;
3124 
3125  if (getLangOpts().ObjCAutoRefCount &&
3126  (left->hasAttr<NSReturnsRetainedAttr>()
3127  != right->hasAttr<NSReturnsRetainedAttr>() ||
3128  left->hasAttr<NSConsumesSelfAttr>()
3129  != right->hasAttr<NSConsumesSelfAttr>()))
3130  return false;
3131 
3133  li = left->param_begin(), le = left->param_end(), ri = right->param_begin(),
3134  re = right->param_end();
3135 
3136  for (; li != le && ri != re; ++li, ++ri) {
3137  assert(ri != right->param_end() && "Param mismatch");
3138  const ParmVarDecl *lparm = *li, *rparm = *ri;
3139 
3140  if (!matchTypes(Context, strategy, lparm->getType(), rparm->getType()))
3141  return false;
3142 
3143  if (getLangOpts().ObjCAutoRefCount &&
3144  lparm->hasAttr<NSConsumedAttr>() != rparm->hasAttr<NSConsumedAttr>())
3145  return false;
3146  }
3147  return true;
3148 }
3149 
3151  ObjCMethodDecl *Method) {
3152  // Record at the head of the list whether there were 0, 1, or >= 2 methods
3153  // inside categories.
3154  if (ObjCCategoryDecl *CD =
3155  dyn_cast<ObjCCategoryDecl>(Method->getDeclContext()))
3156  if (!CD->IsClassExtension() && List->getBits() < 2)
3157  List->setBits(List->getBits() + 1);
3158 
3159  // If the list is empty, make it a singleton list.
3160  if (List->getMethod() == nullptr) {
3161  List->setMethod(Method);
3162  List->setNext(nullptr);
3163  return;
3164  }
3165 
3166  // We've seen a method with this name, see if we have already seen this type
3167  // signature.
3168  ObjCMethodList *Previous = List;
3169  for (; List; Previous = List, List = List->getNext()) {
3170  // If we are building a module, keep all of the methods.
3171  if (getLangOpts().Modules && !getLangOpts().CurrentModule.empty())
3172  continue;
3173 
3174  if (!MatchTwoMethodDeclarations(Method, List->getMethod())) {
3175  // Even if two method types do not match, we would like to say
3176  // there is more than one declaration so unavailability/deprecated
3177  // warning is not too noisy.
3178  if (!Method->isDefined())
3179  List->setHasMoreThanOneDecl(true);
3180  continue;
3181  }
3182 
3183  ObjCMethodDecl *PrevObjCMethod = List->getMethod();
3184 
3185  // Propagate the 'defined' bit.
3186  if (Method->isDefined())
3187  PrevObjCMethod->setDefined(true);
3188  else {
3189  // Objective-C doesn't allow an @interface for a class after its
3190  // @implementation. So if Method is not defined and there already is
3191  // an entry for this type signature, Method has to be for a different
3192  // class than PrevObjCMethod.
3193  List->setHasMoreThanOneDecl(true);
3194  }
3195 
3196  // If a method is deprecated, push it in the global pool.
3197  // This is used for better diagnostics.
3198  if (Method->isDeprecated()) {
3199  if (!PrevObjCMethod->isDeprecated())
3200  List->setMethod(Method);
3201  }
3202  // If the new method is unavailable, push it into global pool
3203  // unless previous one is deprecated.
3204  if (Method->isUnavailable()) {
3205  if (PrevObjCMethod->getAvailability() < AR_Deprecated)
3206  List->setMethod(Method);
3207  }
3208 
3209  return;
3210  }
3211 
3212  // We have a new signature for an existing method - add it.
3213  // This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
3214  ObjCMethodList *Mem = BumpAlloc.Allocate<ObjCMethodList>();
3215  Previous->setNext(new (Mem) ObjCMethodList(Method));
3216 }
3217 
3218 /// \brief Read the contents of the method pool for a given selector from
3219 /// external storage.
3221  assert(ExternalSource && "We need an external AST source");
3222  ExternalSource->ReadMethodPool(Sel);
3223 }
3224 
3225 void Sema::AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl,
3226  bool instance) {
3227  // Ignore methods of invalid containers.
3228  if (cast<Decl>(Method->getDeclContext())->isInvalidDecl())
3229  return;
3230 
3231  if (ExternalSource)
3232  ReadMethodPool(Method->getSelector());
3233 
3234  GlobalMethodPool::iterator Pos = MethodPool.find(Method->getSelector());
3235  if (Pos == MethodPool.end())
3236  Pos = MethodPool.insert(std::make_pair(Method->getSelector(),
3237  GlobalMethods())).first;
3238 
3239  Method->setDefined(impl);
3240 
3241  ObjCMethodList &Entry = instance ? Pos->second.first : Pos->second.second;
3242  addMethodToGlobalList(&Entry, Method);
3243 }
3244 
3245 /// Determines if this is an "acceptable" loose mismatch in the global
3246 /// method pool. This exists mostly as a hack to get around certain
3247 /// global mismatches which we can't afford to make warnings / errors.
3248 /// Really, what we want is a way to take a method out of the global
3249 /// method pool.
3251  ObjCMethodDecl *other) {
3252  if (!chosen->isInstanceMethod())
3253  return false;
3254 
3255  Selector sel = chosen->getSelector();
3256  if (!sel.isUnarySelector() || sel.getNameForSlot(0) != "length")
3257  return false;
3258 
3259  // Don't complain about mismatches for -length if the method we
3260  // chose has an integral result type.
3261  return (chosen->getReturnType()->isIntegerType());
3262 }
3263 
3265  Selector Sel, SmallVectorImpl<ObjCMethodDecl *> &Methods, bool instance) {
3266  if (ExternalSource)
3267  ReadMethodPool(Sel);
3268 
3269  GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
3270  if (Pos == MethodPool.end())
3271  return false;
3272  // Gather the non-hidden methods.
3273  ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
3274  for (ObjCMethodList *M = &MethList; M; M = M->getNext())
3275  if (M->getMethod() && !M->getMethod()->isHidden())
3276  Methods.push_back(M->getMethod());
3277  return Methods.size() > 1;
3278 }
3279 
3281  SourceRange R,
3282  bool receiverIdOrClass) {
3283  GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
3284  // Test for no method in the pool which should not trigger any warning by
3285  // caller.
3286  if (Pos == MethodPool.end())
3287  return true;
3288  ObjCMethodList &MethList =
3289  BestMethod->isInstanceMethod() ? Pos->second.first : Pos->second.second;
3290 
3291  // Diagnose finding more than one method in global pool
3293  Methods.push_back(BestMethod);
3294  for (ObjCMethodList *ML = &MethList; ML; ML = ML->getNext())
3295  if (ObjCMethodDecl *M = ML->getMethod())
3296  if (!M->isHidden() && M != BestMethod && !M->hasAttr<UnavailableAttr>())
3297  Methods.push_back(M);
3298  if (Methods.size() > 1)
3299  DiagnoseMultipleMethodInGlobalPool(Methods, Sel, R, receiverIdOrClass);
3300 
3301  return MethList.hasMoreThanOneDecl();
3302 }
3303 
3304 ObjCMethodDecl *Sema::LookupMethodInGlobalPool(Selector Sel, SourceRange R,
3305  bool receiverIdOrClass,
3306  bool instance) {
3307  if (ExternalSource)
3308  ReadMethodPool(Sel);
3309 
3310  GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
3311  if (Pos == MethodPool.end())
3312  return nullptr;
3313 
3314  // Gather the non-hidden methods.
3315  ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
3317  for (ObjCMethodList *M = &MethList; M; M = M->getNext()) {
3318  if (M->getMethod() && !M->getMethod()->isHidden())
3319  return M->getMethod();
3320  }
3321  return nullptr;
3322 }
3323 
3325  Selector Sel, SourceRange R,
3326  bool receiverIdOrClass) {
3327  // We found multiple methods, so we may have to complain.
3328  bool issueDiagnostic = false, issueError = false;
3329 
3330  // We support a warning which complains about *any* difference in
3331  // method signature.
3332  bool strictSelectorMatch =
3333  receiverIdOrClass &&
3334  !Diags.isIgnored(diag::warn_strict_multiple_method_decl, R.getBegin());
3335  if (strictSelectorMatch) {
3336  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
3337  if (!MatchTwoMethodDeclarations(Methods[0], Methods[I], MMS_strict)) {
3338  issueDiagnostic = true;
3339  break;
3340  }
3341  }
3342  }
3343 
3344  // If we didn't see any strict differences, we won't see any loose
3345  // differences. In ARC, however, we also need to check for loose
3346  // mismatches, because most of them are errors.
3347  if (!strictSelectorMatch ||
3348  (issueDiagnostic && getLangOpts().ObjCAutoRefCount))
3349  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
3350  // This checks if the methods differ in type mismatch.
3351  if (!MatchTwoMethodDeclarations(Methods[0], Methods[I], MMS_loose) &&
3352  !isAcceptableMethodMismatch(Methods[0], Methods[I])) {
3353  issueDiagnostic = true;
3354  if (getLangOpts().ObjCAutoRefCount)
3355  issueError = true;
3356  break;
3357  }
3358  }
3359 
3360  if (issueDiagnostic) {
3361  if (issueError)
3362  Diag(R.getBegin(), diag::err_arc_multiple_method_decl) << Sel << R;
3363  else if (strictSelectorMatch)
3364  Diag(R.getBegin(), diag::warn_strict_multiple_method_decl) << Sel << R;
3365  else
3366  Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R;
3367 
3368  Diag(Methods[0]->getLocStart(),
3369  issueError ? diag::note_possibility : diag::note_using)
3370  << Methods[0]->getSourceRange();
3371  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
3372  Diag(Methods[I]->getLocStart(), diag::note_also_found)
3373  << Methods[I]->getSourceRange();
3374  }
3375  }
3376 }
3377 
3379  GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
3380  if (Pos == MethodPool.end())
3381  return nullptr;
3382 
3383  GlobalMethods &Methods = Pos->second;
3384  for (const ObjCMethodList *Method = &Methods.first; Method;
3385  Method = Method->getNext())
3386  if (Method->getMethod() &&
3387  (Method->getMethod()->isDefined() ||
3388  Method->getMethod()->isPropertyAccessor()))
3389  return Method->getMethod();
3390 
3391  for (const ObjCMethodList *Method = &Methods.second; Method;
3392  Method = Method->getNext())
3393  if (Method->getMethod() &&
3394  (Method->getMethod()->isDefined() ||
3395  Method->getMethod()->isPropertyAccessor()))
3396  return Method->getMethod();
3397  return nullptr;
3398 }
3399 
3400 static void
3403  StringRef Typo, const ObjCMethodDecl * Method) {
3404  const unsigned MaxEditDistance = 1;
3405  unsigned BestEditDistance = MaxEditDistance + 1;
3406  std::string MethodName = Method->getSelector().getAsString();
3407 
3408  unsigned MinPossibleEditDistance = abs((int)MethodName.size() - (int)Typo.size());
3409  if (MinPossibleEditDistance > 0 &&
3410  Typo.size() / MinPossibleEditDistance < 1)
3411  return;
3412  unsigned EditDistance = Typo.edit_distance(MethodName, true, MaxEditDistance);
3413  if (EditDistance > MaxEditDistance)
3414  return;
3415  if (EditDistance == BestEditDistance)
3416  BestMethod.push_back(Method);
3417  else if (EditDistance < BestEditDistance) {
3418  BestMethod.clear();
3419  BestMethod.push_back(Method);
3420  }
3421 }
3422 
3424  QualType ObjectType) {
3425  if (ObjectType.isNull())
3426  return true;
3427  if (S.LookupMethodInObjectType(Sel, ObjectType, true/*Instance method*/))
3428  return true;
3429  return S.LookupMethodInObjectType(Sel, ObjectType, false/*Class method*/) !=
3430  nullptr;
3431 }
3432 
3433 const ObjCMethodDecl *
3435  QualType ObjectType) {
3436  unsigned NumArgs = Sel.getNumArgs();
3438  bool ObjectIsId = true, ObjectIsClass = true;
3439  if (ObjectType.isNull())
3440  ObjectIsId = ObjectIsClass = false;
3441  else if (!ObjectType->isObjCObjectPointerType())
3442  return nullptr;
3443  else if (const ObjCObjectPointerType *ObjCPtr =
3444  ObjectType->getAsObjCInterfacePointerType()) {
3445  ObjectType = QualType(ObjCPtr->getInterfaceType(), 0);
3446  ObjectIsId = ObjectIsClass = false;
3447  }
3448  else if (ObjectType->isObjCIdType() || ObjectType->isObjCQualifiedIdType())
3449  ObjectIsClass = false;
3450  else if (ObjectType->isObjCClassType() || ObjectType->isObjCQualifiedClassType())
3451  ObjectIsId = false;
3452  else
3453  return nullptr;
3454 
3455  for (GlobalMethodPool::iterator b = MethodPool.begin(),
3456  e = MethodPool.end(); b != e; b++) {
3457  // instance methods
3458  for (ObjCMethodList *M = &b->second.first; M; M=M->getNext())
3459  if (M->getMethod() &&
3460  (M->getMethod()->getSelector().getNumArgs() == NumArgs) &&
3461  (M->getMethod()->getSelector() != Sel)) {
3462  if (ObjectIsId)
3463  Methods.push_back(M->getMethod());
3464  else if (!ObjectIsClass &&
3465  HelperIsMethodInObjCType(*this, M->getMethod()->getSelector(),
3466  ObjectType))
3467  Methods.push_back(M->getMethod());
3468  }
3469  // class methods
3470  for (ObjCMethodList *M = &b->second.second; M; M=M->getNext())
3471  if (M->getMethod() &&
3472  (M->getMethod()->getSelector().getNumArgs() == NumArgs) &&
3473  (M->getMethod()->getSelector() != Sel)) {
3474  if (ObjectIsClass)
3475  Methods.push_back(M->getMethod());
3476  else if (!ObjectIsId &&
3477  HelperIsMethodInObjCType(*this, M->getMethod()->getSelector(),
3478  ObjectType))
3479  Methods.push_back(M->getMethod());
3480  }
3481  }
3482 
3484  for (unsigned i = 0, e = Methods.size(); i < e; i++) {
3485  HelperSelectorsForTypoCorrection(SelectedMethods,
3486  Sel.getAsString(), Methods[i]);
3487  }
3488  return (SelectedMethods.size() == 1) ? SelectedMethods[0] : nullptr;
3489 }
3490 
3491 /// DiagnoseDuplicateIvars -
3492 /// Check for duplicate ivars in the entire class at the start of
3493 /// \@implementation. This becomes necesssary because class extension can
3494 /// add ivars to a class in random order which will not be known until
3495 /// class's \@implementation is seen.
3497  ObjCInterfaceDecl *SID) {
3498  for (auto *Ivar : ID->ivars()) {
3499  if (Ivar->isInvalidDecl())
3500  continue;
3501  if (IdentifierInfo *II = Ivar->getIdentifier()) {
3502  ObjCIvarDecl* prevIvar = SID->lookupInstanceVariable(II);
3503  if (prevIvar) {
3504  Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
3505  Diag(prevIvar->getLocation(), diag::note_previous_declaration);
3506  Ivar->setInvalidDecl();
3507  }
3508  }
3509  }
3510 }
3511 
3512 /// Diagnose attempts to define ARC-__weak ivars when __weak is disabled.
3514  if (S.getLangOpts().ObjCWeak) return;
3515 
3516  for (auto ivar = ID->getClassInterface()->all_declared_ivar_begin();
3517  ivar; ivar = ivar->getNextIvar()) {
3518  if (ivar->isInvalidDecl()) continue;
3519  if (ivar->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
3520  if (S.getLangOpts().ObjCWeakRuntime) {
3521  S.Diag(ivar->getLocation(), diag::err_arc_weak_disabled);
3522  } else {
3523  S.Diag(ivar->getLocation(), diag::err_arc_weak_no_runtime);
3524  }
3525  }
3526  }
3527 }
3528 
3530  switch (CurContext->getDeclKind()) {
3531  case Decl::ObjCInterface:
3532  return Sema::OCK_Interface;
3533  case Decl::ObjCProtocol:
3534  return Sema::OCK_Protocol;
3535  case Decl::ObjCCategory:
3536  if (cast<ObjCCategoryDecl>(CurContext)->IsClassExtension())
3537  return Sema::OCK_ClassExtension;
3538  return Sema::OCK_Category;
3539  case Decl::ObjCImplementation:
3540  return Sema::OCK_Implementation;
3541  case Decl::ObjCCategoryImpl:
3543 
3544  default:
3545  return Sema::OCK_None;
3546  }
3547 }
3548 
3549 // Note: For class/category implementations, allMethods is always null.
3551  ArrayRef<DeclGroupPtrTy> allTUVars) {
3553  return nullptr;
3554 
3555  assert(AtEnd.isValid() && "Invalid location for '@end'");
3556 
3558  Decl *ClassDecl = cast<Decl>(OCD);
3559 
3560  bool isInterfaceDeclKind =
3561  isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
3562  || isa<ObjCProtocolDecl>(ClassDecl);
3563  bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
3564 
3565  // FIXME: Remove these and use the ObjCContainerDecl/DeclContext.
3566  llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
3567  llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
3568 
3569  for (unsigned i = 0, e = allMethods.size(); i != e; i++ ) {
3570  ObjCMethodDecl *Method =
3571  cast_or_null<ObjCMethodDecl>(allMethods[i]);
3572 
3573  if (!Method) continue; // Already issued a diagnostic.
3574  if (Method->isInstanceMethod()) {
3575  /// Check for instance method of the same name with incompatible types
3576  const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()];
3577  bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
3578  : false;
3579  if ((isInterfaceDeclKind && PrevMethod && !match)
3580  || (checkIdenticalMethods && match)) {
3581  Diag(Method->getLocation(), diag::err_duplicate_method_decl)
3582  << Method->getDeclName();
3583  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
3584  Method->setInvalidDecl();
3585  } else {
3586  if (PrevMethod) {
3587  Method->setAsRedeclaration(PrevMethod);
3589  Method->getLocation()))
3590  Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
3591  << Method->getDeclName();
3592  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
3593  }
3594  InsMap[Method->getSelector()] = Method;
3595  /// The following allows us to typecheck messages to "id".
3597  }
3598  } else {
3599  /// Check for class method of the same name with incompatible types
3600  const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()];
3601  bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
3602  : false;
3603  if ((isInterfaceDeclKind && PrevMethod && !match)
3604  || (checkIdenticalMethods && match)) {
3605  Diag(Method->getLocation(), diag::err_duplicate_method_decl)
3606  << Method->getDeclName();
3607  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
3608  Method->setInvalidDecl();
3609  } else {
3610  if (PrevMethod) {
3611  Method->setAsRedeclaration(PrevMethod);
3613  Method->getLocation()))
3614  Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
3615  << Method->getDeclName();
3616  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
3617  }
3618  ClsMap[Method->getSelector()] = Method;
3620  }
3621  }
3622  }
3623  if (isa<ObjCInterfaceDecl>(ClassDecl)) {
3624  // Nothing to do here.
3625  } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
3626  // Categories are used to extend the class by declaring new methods.
3627  // By the same token, they are also used to add new properties. No
3628  // need to compare the added property to those in the class.
3629 
3630  if (C->IsClassExtension()) {
3631  ObjCInterfaceDecl *CCPrimary = C->getClassInterface();
3632  DiagnoseClassExtensionDupMethods(C, CCPrimary);
3633  }
3634  }
3635  if (ObjCContainerDecl *CDecl = dyn_cast<ObjCContainerDecl>(ClassDecl)) {
3636  if (CDecl->getIdentifier())
3637  // ProcessPropertyDecl is responsible for diagnosing conflicts with any
3638  // user-defined setter/getter. It also synthesizes setter/getter methods
3639  // and adds them to the DeclContext and global method pools.
3640  for (auto *I : CDecl->properties())
3642  CDecl->setAtEndRange(AtEnd);
3643  }
3644  if (ObjCImplementationDecl *IC=dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
3645  IC->setAtEndRange(AtEnd);
3646  if (ObjCInterfaceDecl* IDecl = IC->getClassInterface()) {
3647  // Any property declared in a class extension might have user
3648  // declared setter or getter in current class extension or one
3649  // of the other class extensions. Mark them as synthesized as
3650  // property will be synthesized when property with same name is
3651  // seen in the @implementation.
3652  for (const auto *Ext : IDecl->visible_extensions()) {
3653  for (const auto *Property : Ext->properties()) {
3654  // Skip over properties declared @dynamic
3655  if (const ObjCPropertyImplDecl *PIDecl
3656  = IC->FindPropertyImplDecl(Property->getIdentifier()))
3657  if (PIDecl->getPropertyImplementation()
3659  continue;
3660 
3661  for (const auto *Ext : IDecl->visible_extensions()) {
3662  if (ObjCMethodDecl *GetterMethod
3663  = Ext->getInstanceMethod(Property->getGetterName()))
3664  GetterMethod->setPropertyAccessor(true);
3665  if (!Property->isReadOnly())
3666  if (ObjCMethodDecl *SetterMethod
3667  = Ext->getInstanceMethod(Property->getSetterName()))
3668  SetterMethod->setPropertyAccessor(true);
3669  }
3670  }
3671  }
3672  ImplMethodsVsClassMethods(S, IC, IDecl);
3676  if (IDecl->hasDesignatedInitializers())
3678  DiagnoseWeakIvars(*this, IC);
3679 
3680  bool HasRootClassAttr = IDecl->hasAttr<ObjCRootClassAttr>();
3681  if (IDecl->getSuperClass() == nullptr) {
3682  // This class has no superclass, so check that it has been marked with
3683  // __attribute((objc_root_class)).
3684  if (!HasRootClassAttr) {
3685  SourceLocation DeclLoc(IDecl->getLocation());
3686  SourceLocation SuperClassLoc(getLocForEndOfToken(DeclLoc));
3687  Diag(DeclLoc, diag::warn_objc_root_class_missing)
3688  << IDecl->getIdentifier();
3689  // See if NSObject is in the current scope, and if it is, suggest
3690  // adding " : NSObject " to the class declaration.
3692  NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject),
3693  DeclLoc, LookupOrdinaryName);
3694  ObjCInterfaceDecl *NSObjectDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
3695  if (NSObjectDecl && NSObjectDecl->getDefinition()) {
3696  Diag(SuperClassLoc, diag::note_objc_needs_superclass)
3697  << FixItHint::CreateInsertion(SuperClassLoc, " : NSObject ");
3698  } else {
3699  Diag(SuperClassLoc, diag::note_objc_needs_superclass);
3700  }
3701  }
3702  } else if (HasRootClassAttr) {
3703  // Complain that only root classes may have this attribute.
3704  Diag(IDecl->getLocation(), diag::err_objc_root_class_subclass);
3705  }
3706 
3708  while (IDecl->getSuperClass()) {
3709  DiagnoseDuplicateIvars(IDecl, IDecl->getSuperClass());
3710  IDecl = IDecl->getSuperClass();
3711  }
3712  }
3713  }
3714  SetIvarInitializers(IC);
3715  } else if (ObjCCategoryImplDecl* CatImplClass =
3716  dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
3717  CatImplClass->setAtEndRange(AtEnd);
3718 
3719  // Find category interface decl and then check that all methods declared
3720  // in this interface are implemented in the category @implementation.
3721  if (ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface()) {
3722  if (ObjCCategoryDecl *Cat
3723  = IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier())) {
3724  ImplMethodsVsClassMethods(S, CatImplClass, Cat);
3725  }
3726  }
3727  }
3728  if (isInterfaceDeclKind) {
3729  // Reject invalid vardecls.
3730  for (unsigned i = 0, e = allTUVars.size(); i != e; i++) {
3731  DeclGroupRef DG = allTUVars[i].get();
3732  for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
3733  if (VarDecl *VDecl = dyn_cast<VarDecl>(*I)) {
3734  if (!VDecl->hasExternalStorage())
3735  Diag(VDecl->getLocation(), diag::err_objc_var_decl_inclass);
3736  }
3737  }
3738  }
3740 
3741  for (unsigned i = 0, e = allTUVars.size(); i != e; i++) {
3742  DeclGroupRef DG = allTUVars[i].get();
3743  for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
3744  (*I)->setTopLevelDeclInObjCContainer();
3746  }
3747 
3748  ActOnDocumentableDecl(ClassDecl);
3749  return ClassDecl;
3750 }
3751 
3752 /// CvtQTToAstBitMask - utility routine to produce an AST bitmask for
3753 /// objective-c's type qualifier from the parser version of the same info.
3756  return (Decl::ObjCDeclQualifier) (unsigned) PQTVal;
3757 }
3758 
3759 /// \brief Check whether the declared result type of the given Objective-C
3760 /// method declaration is compatible with the method's class.
3761 ///
3764  ObjCInterfaceDecl *CurrentClass) {
3765  QualType ResultType = Method->getReturnType();
3766 
3767  // If an Objective-C method inherits its related result type, then its
3768  // declared result type must be compatible with its own class type. The
3769  // declared result type is compatible if:
3770  if (const ObjCObjectPointerType *ResultObjectType
3771  = ResultType->getAs<ObjCObjectPointerType>()) {
3772  // - it is id or qualified id, or
3773  if (ResultObjectType->isObjCIdType() ||
3774  ResultObjectType->isObjCQualifiedIdType())
3775  return Sema::RTC_Compatible;
3776 
3777  if (CurrentClass) {
3778  if (ObjCInterfaceDecl *ResultClass
3779  = ResultObjectType->getInterfaceDecl()) {
3780  // - it is the same as the method's class type, or
3781  if (declaresSameEntity(CurrentClass, ResultClass))
3782  return Sema::RTC_Compatible;
3783 
3784  // - it is a superclass of the method's class type
3785  if (ResultClass->isSuperClassOf(CurrentClass))
3786  return Sema::RTC_Compatible;
3787  }
3788  } else {
3789  // Any Objective-C pointer type might be acceptable for a protocol
3790  // method; we just don't know.
3791  return Sema::RTC_Unknown;
3792  }
3793  }
3794 
3795  return Sema::RTC_Incompatible;
3796 }
3797 
3798 namespace {
3799 /// A helper class for searching for methods which a particular method
3800 /// overrides.
3801 class OverrideSearch {
3802 public:
3803  Sema &S;
3804  ObjCMethodDecl *Method;
3805  llvm::SmallPtrSet<ObjCMethodDecl*, 4> Overridden;
3806  bool Recursive;
3807 
3808 public:
3809  OverrideSearch(Sema &S, ObjCMethodDecl *method) : S(S), Method(method) {
3810  Selector selector = method->getSelector();
3811 
3812  // Bypass this search if we've never seen an instance/class method
3813  // with this selector before.
3814  Sema::GlobalMethodPool::iterator it = S.MethodPool.find(selector);
3815  if (it == S.MethodPool.end()) {
3816  if (!S.getExternalSource()) return;
3817  S.ReadMethodPool(selector);
3818 
3819  it = S.MethodPool.find(selector);
3820  if (it == S.MethodPool.end())
3821  return;
3822  }
3823  ObjCMethodList &list =
3824  method->isInstanceMethod() ? it->second.first : it->second.second;
3825  if (!list.getMethod()) return;
3826 
3827  ObjCContainerDecl *container
3828  = cast<ObjCContainerDecl>(method->getDeclContext());
3829 
3830  // Prevent the search from reaching this container again. This is
3831  // important with categories, which override methods from the
3832  // interface and each other.
3833  if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(container)) {
3834  searchFromContainer(container);
3835  if (ObjCInterfaceDecl *Interface = Category->getClassInterface())
3836  searchFromContainer(Interface);
3837  } else {
3838  searchFromContainer(container);
3839  }
3840  }
3841 
3843  iterator begin() const { return Overridden.begin(); }
3844  iterator end() const { return Overridden.end(); }
3845 
3846 private:
3847  void searchFromContainer(ObjCContainerDecl *container) {
3848  if (container->isInvalidDecl()) return;
3849 
3850  switch (container->getDeclKind()) {
3851 #define OBJCCONTAINER(type, base) \
3852  case Decl::type: \
3853  searchFrom(cast<type##Decl>(container)); \
3854  break;
3855 #define ABSTRACT_DECL(expansion)
3856 #define DECL(type, base) \
3857  case Decl::type:
3858 #include "clang/AST/DeclNodes.inc"
3859  llvm_unreachable("not an ObjC container!");
3860  }
3861  }
3862 
3863  void searchFrom(ObjCProtocolDecl *protocol) {
3864  if (!protocol->hasDefinition())
3865  return;
3866 
3867  // A method in a protocol declaration overrides declarations from
3868  // referenced ("parent") protocols.
3869  search(protocol->getReferencedProtocols());
3870  }
3871 
3872  void searchFrom(ObjCCategoryDecl *category) {
3873  // A method in a category declaration overrides declarations from
3874  // the main class and from protocols the category references.
3875  // The main class is handled in the constructor.
3876  search(category->getReferencedProtocols());
3877  }
3878 
3879  void searchFrom(ObjCCategoryImplDecl *impl) {
3880  // A method in a category definition that has a category
3881  // declaration overrides declarations from the category
3882  // declaration.
3883  if (ObjCCategoryDecl *category = impl->getCategoryDecl()) {
3884  search(category);
3885  if (ObjCInterfaceDecl *Interface = category->getClassInterface())
3886  search(Interface);
3887 
3888  // Otherwise it overrides declarations from the class.
3889  } else if (ObjCInterfaceDecl *Interface = impl->getClassInterface()) {
3890  search(Interface);
3891  }
3892  }
3893 
3894  void searchFrom(ObjCInterfaceDecl *iface) {
3895  // A method in a class declaration overrides declarations from
3896  if (!iface->hasDefinition())
3897  return;
3898 
3899  // - categories,
3900  for (auto *Cat : iface->known_categories())
3901  search(Cat);
3902 
3903  // - the super class, and
3904  if (ObjCInterfaceDecl *super = iface->getSuperClass())
3905  search(super);
3906 
3907  // - any referenced protocols.
3908  search(iface->getReferencedProtocols());
3909  }
3910 
3911  void searchFrom(ObjCImplementationDecl *impl) {
3912  // A method in a class implementation overrides declarations from
3913  // the class interface.
3914  if (ObjCInterfaceDecl *Interface = impl->getClassInterface())
3915  search(Interface);
3916  }
3917 
3918  void search(const ObjCProtocolList &protocols) {
3919  for (ObjCProtocolList::iterator i = protocols.begin(), e = protocols.end();
3920  i != e; ++i)
3921  search(*i);
3922  }
3923 
3924  void search(ObjCContainerDecl *container) {
3925  // Check for a method in this container which matches this selector.
3926  ObjCMethodDecl *meth = container->getMethod(Method->getSelector(),
3927  Method->isInstanceMethod(),
3928  /*AllowHidden=*/true);
3929 
3930  // If we find one, record it and bail out.
3931  if (meth) {
3932  Overridden.insert(meth);
3933  return;
3934  }
3935 
3936  // Otherwise, search for methods that a hypothetical method here
3937  // would have overridden.
3938 
3939  // Note that we're now in a recursive case.
3940  Recursive = true;
3941 
3942  searchFromContainer(container);
3943  }
3944 };
3945 } // end anonymous namespace
3946 
3948  ObjCInterfaceDecl *CurrentClass,
3950  // Search for overridden methods and merge information down from them.
3951  OverrideSearch overrides(*this, ObjCMethod);
3952  // Keep track if the method overrides any method in the class's base classes,
3953  // its protocols, or its categories' protocols; we will keep that info
3954  // in the ObjCMethodDecl.
3955  // For this info, a method in an implementation is not considered as
3956  // overriding the same method in the interface or its categories.
3957  bool hasOverriddenMethodsInBaseOrProtocol = false;
3958  for (OverrideSearch::iterator
3959  i = overrides.begin(), e = overrides.end(); i != e; ++i) {
3960  ObjCMethodDecl *overridden = *i;
3961 
3962  if (!hasOverriddenMethodsInBaseOrProtocol) {
3963  if (isa<ObjCProtocolDecl>(overridden->getDeclContext()) ||
3964  CurrentClass != overridden->getClassInterface() ||
3965  overridden->isOverriding()) {
3966  hasOverriddenMethodsInBaseOrProtocol = true;
3967 
3968  } else if (isa<ObjCImplDecl>(ObjCMethod->getDeclContext())) {
3969  // OverrideSearch will return as "overridden" the same method in the
3970  // interface. For hasOverriddenMethodsInBaseOrProtocol, we need to
3971  // check whether a category of a base class introduced a method with the
3972  // same selector, after the interface method declaration.
3973  // To avoid unnecessary lookups in the majority of cases, we use the
3974  // extra info bits in GlobalMethodPool to check whether there were any
3975  // category methods with this selector.
3977  MethodPool.find(ObjCMethod->getSelector());
3978  if (It != MethodPool.end()) {
3979  ObjCMethodList &List =
3980  ObjCMethod->isInstanceMethod()? It->second.first: It->second.second;
3981  unsigned CategCount = List.getBits();
3982  if (CategCount > 0) {
3983  // If the method is in a category we'll do lookup if there were at
3984  // least 2 category methods recorded, otherwise only one will do.
3985  if (CategCount > 1 ||
3986  !isa<ObjCCategoryImplDecl>(overridden->getDeclContext())) {
3987  OverrideSearch overrides(*this, overridden);
3988  for (OverrideSearch::iterator
3989  OI= overrides.begin(), OE= overrides.end(); OI!=OE; ++OI) {
3990  ObjCMethodDecl *SuperOverridden = *OI;
3991  if (isa<ObjCProtocolDecl>(SuperOverridden->getDeclContext()) ||
3992  CurrentClass != SuperOverridden->getClassInterface()) {
3993  hasOverriddenMethodsInBaseOrProtocol = true;
3994  overridden->setOverriding(true);
3995  break;
3996  }
3997  }
3998  }
3999  }
4000  }
4001  }
4002  }
4003 
4004  // Propagate down the 'related result type' bit from overridden methods.
4005  if (RTC != Sema::RTC_Incompatible && overridden->hasRelatedResultType())
4006  ObjCMethod->SetRelatedResultType();
4007 
4008  // Then merge the declarations.
4009  mergeObjCMethodDecls(ObjCMethod, overridden);
4010 
4011  if (ObjCMethod->isImplicit() && overridden->isImplicit())
4012  continue; // Conflicting properties are detected elsewhere.
4013 
4014  // Check for overriding methods
4015  if (isa<ObjCInterfaceDecl>(ObjCMethod->getDeclContext()) ||
4016  isa<ObjCImplementationDecl>(ObjCMethod->getDeclContext()))
4017  CheckConflictingOverridingMethod(ObjCMethod, overridden,
4018  isa<ObjCProtocolDecl>(overridden->getDeclContext()));
4019 
4020  if (CurrentClass && overridden->getDeclContext() != CurrentClass &&
4021  isa<ObjCInterfaceDecl>(overridden->getDeclContext()) &&
4022  !overridden->isImplicit() /* not meant for properties */) {
4023  ObjCMethodDecl::param_iterator ParamI = ObjCMethod->param_begin(),
4024  E = ObjCMethod->param_end();
4025  ObjCMethodDecl::param_iterator PrevI = overridden->param_begin(),
4026  PrevE = overridden->param_end();
4027  for (; ParamI != E && PrevI != PrevE; ++ParamI, ++PrevI) {
4028  assert(PrevI != overridden->param_end() && "Param mismatch");
4029  QualType T1 = Context.getCanonicalType((*ParamI)->getType());
4030  QualType T2 = Context.getCanonicalType((*PrevI)->getType());
4031  // If type of argument of method in this class does not match its
4032  // respective argument type in the super class method, issue warning;
4033  if (!Context.typesAreCompatible(T1, T2)) {
4034  Diag((*ParamI)->getLocation(), diag::ext_typecheck_base_super)
4035  << T1 << T2;
4036  Diag(overridden->getLocation(), diag::note_previous_declaration);
4037  break;
4038  }
4039  }
4040  }
4041  }
4042 
4043  ObjCMethod->setOverriding(hasOverriddenMethodsInBaseOrProtocol);
4044 }
4045 
4046 /// Merge type nullability from for a redeclaration of the same entity,
4047 /// producing the updated type of the redeclared entity.
4049  QualType type,
4050  bool usesCSKeyword,
4051  SourceLocation prevLoc,
4052  QualType prevType,
4053  bool prevUsesCSKeyword) {
4054  // Determine the nullability of both types.
4055  auto nullability = type->getNullability(S.Context);
4056  auto prevNullability = prevType->getNullability(S.Context);
4057 
4058  // Easy case: both have nullability.
4059  if (nullability.hasValue() == prevNullability.hasValue()) {
4060  // Neither has nullability; continue.
4061  if (!nullability)
4062  return type;
4063 
4064  // The nullabilities are equivalent; do nothing.
4065  if (*nullability == *prevNullability)
4066  return type;
4067 
4068  // Complain about mismatched nullability.
4069  S.Diag(loc, diag::err_nullability_conflicting)
4070  << DiagNullabilityKind(*nullability, usesCSKeyword)
4071  << DiagNullabilityKind(*prevNullability, prevUsesCSKeyword);
4072  return type;
4073  }
4074 
4075  // If it's the redeclaration that has nullability, don't change anything.
4076  if (nullability)
4077  return type;
4078 
4079  // Otherwise, provide the result with the same nullability.
4080  return S.Context.getAttributedType(
4081  AttributedType::getNullabilityAttrKind(*prevNullability),
4082  type, type);
4083 }
4084 
4085 /// Merge information from the declaration of a method in the \@interface
4086 /// (or a category/extension) into the corresponding method in the
4087 /// @implementation (for a class or category).
4089  ObjCMethodDecl *method,
4090  ObjCMethodDecl *prevMethod) {
4091  // Merge the objc_requires_super attribute.
4092  if (prevMethod->hasAttr<ObjCRequiresSuperAttr>() &&
4093  !method->hasAttr<ObjCRequiresSuperAttr>()) {
4094  // merge the attribute into implementation.
4095  method->addAttr(
4096  ObjCRequiresSuperAttr::CreateImplicit(S.Context,
4097  method->getLocation()));
4098  }
4099 
4100  // Merge nullability of the result type.
4101  QualType newReturnType
4103  S, method->getReturnTypeSourceRange().getBegin(),
4104  method->getReturnType(),
4106  prevMethod->getReturnTypeSourceRange().getBegin(),
4107  prevMethod->getReturnType(),
4109  method->setReturnType(newReturnType);
4110 
4111  // Handle each of the parameters.
4112  unsigned numParams = method->param_size();
4113  unsigned numPrevParams = prevMethod->param_size();
4114  for (unsigned i = 0, n = std::min(numParams, numPrevParams); i != n; ++i) {
4115  ParmVarDecl *param = method->param_begin()[i];
4116  ParmVarDecl *prevParam = prevMethod->param_begin()[i];
4117 
4118  // Merge nullability.
4119  QualType newParamType
4121  S, param->getLocation(), param->getType(),
4123  prevParam->getLocation(), prevParam->getType(),
4125  param->setType(newParamType);
4126  }
4127 }
4128 
4130  Scope *S,
4131  SourceLocation MethodLoc, SourceLocation EndLoc,
4132  tok::TokenKind MethodType,
4133  ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
4134  ArrayRef<SourceLocation> SelectorLocs,
4135  Selector Sel,
4136  // optional arguments. The number of types/arguments is obtained
4137  // from the Sel.getNumArgs().
4138  ObjCArgInfo *ArgInfo,
4139  DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, // c-style args
4140  AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind,
4141  bool isVariadic, bool MethodDefinition) {
4142  // Make sure we can establish a context for the method.
4143  if (!CurContext->isObjCContainer()) {
4144  Diag(MethodLoc, diag::error_missing_method_context);
4145  return nullptr;
4146  }
4148  Decl *ClassDecl = cast<Decl>(OCD);
4149  QualType resultDeclType;
4150 
4151  bool HasRelatedResultType = false;
4152  TypeSourceInfo *ReturnTInfo = nullptr;
4153  if (ReturnType) {
4154  resultDeclType = GetTypeFromParser(ReturnType, &ReturnTInfo);
4155 
4156  if (CheckFunctionReturnType(resultDeclType, MethodLoc))
4157  return nullptr;
4158 
4159  QualType bareResultType = resultDeclType;
4160  (void)AttributedType::stripOuterNullability(bareResultType);
4161  HasRelatedResultType = (bareResultType == Context.getObjCInstanceType());
4162  } else { // get the type for "id".
4163  resultDeclType = Context.getObjCIdType();
4164  Diag(MethodLoc, diag::warn_missing_method_return_type)
4165  << FixItHint::CreateInsertion(SelectorLocs.front(), "(id)");
4166  }
4167 
4168  ObjCMethodDecl *ObjCMethod = ObjCMethodDecl::Create(
4169  Context, MethodLoc, EndLoc, Sel, resultDeclType, ReturnTInfo, CurContext,
4170  MethodType == tok::minus, isVariadic,
4171  /*isPropertyAccessor=*/false,
4172  /*isImplicitlyDeclared=*/false, /*isDefined=*/false,
4173  MethodDeclKind == tok::objc_optional ? ObjCMethodDecl::Optional
4175  HasRelatedResultType);
4176 
4178 
4179  for (unsigned i = 0, e = Sel.getNumArgs(); i != e; ++i) {
4180  QualType ArgType;
4181  TypeSourceInfo *DI;
4182 
4183  if (!ArgInfo[i].Type) {
4184  ArgType = Context.getObjCIdType();
4185  DI = nullptr;
4186  } else {
4187  ArgType = GetTypeFromParser(ArgInfo[i].Type, &DI);
4188  }
4189 
4190  LookupResult R(*this, ArgInfo[i].Name, ArgInfo[i].NameLoc,
4192  LookupName(R, S);
4193  if (R.isSingleResult()) {
4194  NamedDecl *PrevDecl = R.getFoundDecl();
4195  if (S->isDeclScope(PrevDecl)) {
4196  Diag(ArgInfo[i].NameLoc,
4197  (MethodDefinition ? diag::warn_method_param_redefinition
4198  : diag::warn_method_param_declaration))
4199  << ArgInfo[i].Name;
4200  Diag(PrevDecl->getLocation(),
4201  diag::note_previous_declaration);
4202  }
4203  }
4204 
4205  SourceLocation StartLoc = DI
4206  ? DI->getTypeLoc().getBeginLoc()
4207  : ArgInfo[i].NameLoc;
4208 
4209  ParmVarDecl* Param = CheckParameter(ObjCMethod, StartLoc,
4210  ArgInfo[i].NameLoc, ArgInfo[i].Name,
4211  ArgType, DI, SC_None);
4212 
4213  Param->setObjCMethodScopeInfo(i);
4214 
4215  Param->setObjCDeclQualifier(
4216  CvtQTToAstBitMask(ArgInfo[i].DeclSpec.getObjCDeclQualifier()));
4217 
4218  // Apply the attributes to the parameter.
4219  ProcessDeclAttributeList(TUScope, Param, ArgInfo[i].ArgAttrs);
4220 
4221  if (Param->hasAttr<BlocksAttr>()) {
4222  Diag(Param->getLocation(), diag::err_block_on_nonlocal);
4223  Param->setInvalidDecl();
4224  }
4225  S->AddDecl(Param);
4226  IdResolver.AddDecl(Param);
4227 
4228  Params.push_back(Param);
4229  }
4230 
4231  for (unsigned i = 0, e = CNumArgs; i != e; ++i) {
4232  ParmVarDecl *Param = cast<ParmVarDecl>(CParamInfo[i].Param);
4233  QualType ArgType = Param->getType();
4234  if (ArgType.isNull())
4235  ArgType = Context.getObjCIdType();
4236  else
4237  // Perform the default array/function conversions (C99 6.7.5.3p[7,8]).
4238  ArgType = Context.getAdjustedParameterType(ArgType);
4239 
4240  Param->setDeclContext(ObjCMethod);
4241  Params.push_back(Param);
4242  }
4243 
4244  ObjCMethod->setMethodParams(Context, Params, SelectorLocs);
4245  ObjCMethod->setObjCDeclQualifier(
4247 
4248  if (AttrList)
4249  ProcessDeclAttributeList(TUScope, ObjCMethod, AttrList);
4250 
4251  // Add the method now.
4252  const ObjCMethodDecl *PrevMethod = nullptr;
4253  if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
4254  if (MethodType == tok::minus) {
4255  PrevMethod = ImpDecl->getInstanceMethod(Sel);
4256  ImpDecl->addInstanceMethod(ObjCMethod);
4257  } else {
4258  PrevMethod = ImpDecl->getClassMethod(Sel);
4259  ImpDecl->addClassMethod(ObjCMethod);
4260  }
4261 
4262  // Merge information from the @interface declaration into the
4263  // @implementation.
4264  if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface()) {
4265  if (auto *IMD = IDecl->lookupMethod(ObjCMethod->getSelector(),
4266  ObjCMethod->isInstanceMethod())) {
4267  mergeInterfaceMethodToImpl(*this, ObjCMethod, IMD);
4268 
4269  // Warn about defining -dealloc in a category.
4270  if (isa<ObjCCategoryImplDecl>(ImpDecl) && IMD->isOverriding() &&
4271  ObjCMethod->getSelector().getMethodFamily() == OMF_dealloc) {
4272  Diag(ObjCMethod->getLocation(), diag::warn_dealloc_in_category)
4273  << ObjCMethod->getDeclName();
4274  }
4275  }
4276  }
4277  } else {
4278  cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod);
4279  }
4280 
4281  if (PrevMethod) {
4282  // You can never have two method definitions with the same name.
4283  Diag(ObjCMethod->getLocation(), diag::err_duplicate_method_decl)
4284  << ObjCMethod->getDeclName();
4285  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
4286  ObjCMethod->setInvalidDecl();
4287  return ObjCMethod;
4288  }
4289 
4290  // If this Objective-C method does not have a related result type, but we
4291  // are allowed to infer related result types, try to do so based on the
4292  // method family.
4293  ObjCInterfaceDecl *CurrentClass = dyn_cast<ObjCInterfaceDecl>(ClassDecl);
4294  if (!CurrentClass) {
4295  if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl))
4296  CurrentClass = Cat->getClassInterface();
4297  else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(ClassDecl))
4298  CurrentClass = Impl->getClassInterface();
4299  else if (ObjCCategoryImplDecl *CatImpl
4300  = dyn_cast<ObjCCategoryImplDecl>(ClassDecl))
4301  CurrentClass = CatImpl->getClassInterface();
4302  }
4303 
4305  = CheckRelatedResultTypeCompatibility(*this, ObjCMethod, CurrentClass);
4306 
4307  CheckObjCMethodOverrides(ObjCMethod, CurrentClass, RTC);
4308 
4309  bool ARCError = false;
4310  if (getLangOpts().ObjCAutoRefCount)
4311  ARCError = CheckARCMethodDecl(ObjCMethod);
4312 
4313  // Infer the related result type when possible.
4314  if (!ARCError && RTC == Sema::RTC_Compatible &&
4315  !ObjCMethod->hasRelatedResultType() &&
4316  LangOpts.ObjCInferRelatedResultType) {
4317  bool InferRelatedResultType = false;
4318  switch (ObjCMethod->getMethodFamily()) {
4319  case OMF_None:
4320  case OMF_copy:
4321  case OMF_dealloc:
4322  case OMF_finalize:
4323  case OMF_mutableCopy:
4324  case OMF_release:
4325  case OMF_retainCount:
4326  case OMF_initialize:
4327  case OMF_performSelector:
4328  break;
4329 
4330  case OMF_alloc:
4331  case OMF_new:
4332  InferRelatedResultType = ObjCMethod->isClassMethod();
4333  break;
4334 
4335  case OMF_init:
4336  case OMF_autorelease:
4337  case OMF_retain:
4338  case OMF_self:
4339  InferRelatedResultType = ObjCMethod->isInstanceMethod();
4340  break;
4341  }
4342 
4343  if (InferRelatedResultType &&
4344  !ObjCMethod->getReturnType()->isObjCIndependentClassType())
4345  ObjCMethod->SetRelatedResultType();
4346  }
4347 
4348  ActOnDocumentableDecl(ObjCMethod);
4349 
4350  return ObjCMethod;
4351 }
4352 
4354  // Following is also an error. But it is caused by a missing @end
4355  // and diagnostic is issued elsewhere.
4356  if (isa<ObjCContainerDecl>(CurContext->getRedeclContext()))
4357  return false;
4358 
4359  // If we switched context to translation unit while we are still lexically in
4360  // an objc container, it means the parser missed emitting an error.
4361  if (isa<TranslationUnitDecl>(getCurLexicalContext()->getRedeclContext()))
4362  return false;
4363 
4364  Diag(D->getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope);
4365  D->setInvalidDecl();
4366 
4367  return true;
4368 }
4369 
4370 /// Called whenever \@defs(ClassName) is encountered in the source. Inserts the
4371 /// instance variables of ClassName into Decls.
4372 void Sema::ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
4373  IdentifierInfo *ClassName,
4374  SmallVectorImpl<Decl*> &Decls) {
4375  // Check that ClassName is a valid class
4376  ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName, DeclStart);
4377  if (!Class) {
4378  Diag(DeclStart, diag::err_undef_interface) << ClassName;
4379  return;
4380  }
4382  Diag(DeclStart, diag::err_atdef_nonfragile_interface);
4383  return;
4384  }
4385 
4386  // Collect the instance variables
4388  Context.DeepCollectObjCIvars(Class, true, Ivars);
4389  // For each ivar, create a fresh ObjCAtDefsFieldDecl.
4390  for (unsigned i = 0; i < Ivars.size(); i++) {
4391  const FieldDecl* ID = cast<FieldDecl>(Ivars[i]);
4392  RecordDecl *Record = dyn_cast<RecordDecl>(TagD);
4394  /*FIXME: StartL=*/ID->getLocation(),
4395  ID->getLocation(),
4396  ID->getIdentifier(), ID->getType(),
4397  ID->getBitWidth());
4398  Decls.push_back(FD);
4399  }
4400 
4401  // Introduce all of these fields into the appropriate scope.
4402  for (SmallVectorImpl<Decl*>::iterator D = Decls.begin();
4403  D != Decls.end(); ++D) {
4404  FieldDecl *FD = cast<FieldDecl>(*D);
4405  if (getLangOpts().CPlusPlus)
4406  PushOnScopeChains(cast<FieldDecl>(FD), S);
4407  else if (RecordDecl *Record = dyn_cast<RecordDecl>(TagD))
4408  Record->addDecl(FD);
4409  }
4410 }
4411 
4412 /// \brief Build a type-check a new Objective-C exception variable declaration.
4414  SourceLocation StartLoc,
4415  SourceLocation IdLoc,
4416  IdentifierInfo *Id,
4417  bool Invalid) {
4418  // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
4419  // duration shall not be qualified by an address-space qualifier."
4420  // Since all parameters have automatic store duration, they can not have
4421  // an address space.
4422  if (T.getAddressSpace() != 0) {
4423  Diag(IdLoc, diag::err_arg_with_address_space);
4424  Invalid = true;
4425  }
4426 
4427  // An @catch parameter must be an unqualified object pointer type;
4428  // FIXME: Recover from "NSObject foo" by inserting the * in "NSObject *foo"?
4429  if (Invalid) {
4430  // Don't do any further checking.
4431  } else if (T->isDependentType()) {
4432  // Okay: we don't know what this type will instantiate to.
4433  } else if (!T->isObjCObjectPointerType()) {
4434  Invalid = true;
4435  Diag(IdLoc ,diag::err_catch_param_not_objc_type);
4436  } else if (T->isObjCQualifiedIdType()) {
4437  Invalid = true;
4438  Diag(IdLoc, diag::err_illegal_qualifiers_on_catch_parm);
4439  }
4440 
4441  VarDecl *New = VarDecl::Create(Context, CurContext, StartLoc, IdLoc, Id,
4442  T, TInfo, SC_None);
4443  New->setExceptionVariable(true);
4444 
4445  // In ARC, infer 'retaining' for variables of retainable type.
4446  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(New))
4447  Invalid = true;
4448 
4449  if (Invalid)
4450  New->setInvalidDecl();
4451  return New;
4452 }
4453 
4455  const DeclSpec &DS = D.getDeclSpec();
4456 
4457  // We allow the "register" storage class on exception variables because
4458  // GCC did, but we drop it completely. Any other storage class is an error.
4460  Diag(DS.getStorageClassSpecLoc(), diag::warn_register_objc_catch_parm)
4462  } else if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
4463  Diag(DS.getStorageClassSpecLoc(), diag::err_storage_spec_on_catch_parm)
4465  }
4468  diag::err_invalid_thread)
4469  << DeclSpec::getSpecifierName(TSCS);
4471 
4473 
4474  // Check that there are no default arguments inside the type of this
4475  // exception object (C++ only).
4476  if (getLangOpts().CPlusPlus)
4478 
4479  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
4480  QualType ExceptionType = TInfo->getType();
4481 
4482  VarDecl *New = BuildObjCExceptionDecl(TInfo, ExceptionType,
4483  D.getSourceRange().getBegin(),
4484  D.getIdentifierLoc(),
4485  D.getIdentifier(),
4486  D.isInvalidType());
4487 
4488  // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
4489  if (D.getCXXScopeSpec().isSet()) {
4490  Diag(D.getIdentifierLoc(), diag::err_qualified_objc_catch_parm)
4491  << D.getCXXScopeSpec().getRange();
4492  New->setInvalidDecl();
4493  }
4494 
4495  // Add the parameter declaration into this scope.
4496  S->AddDecl(New);
4497  if (D.getIdentifier())
4498  IdResolver.AddDecl(New);
4499 
4500  ProcessDeclAttributes(S, New, D);
4501 
4502  if (New->hasAttr<BlocksAttr>())
4503  Diag(New->getLocation(), diag::err_block_on_nonlocal);
4504  return New;
4505 }
4506 
4507 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
4508 /// initialization.
4511  for (ObjCIvarDecl *Iv = OI->all_declared_ivar_begin(); Iv;
4512  Iv= Iv->getNextIvar()) {
4513  QualType QT = Context.getBaseElementType(Iv->getType());
4514  if (QT->isRecordType())
4515  Ivars.push_back(Iv);
4516  }
4517 }
4518 
4520  // Load referenced selectors from the external source.
4521  if (ExternalSource) {
4523  ExternalSource->ReadReferencedSelectors(Sels);
4524  for (unsigned I = 0, N = Sels.size(); I != N; ++I)
4525  ReferencedSelectors[Sels[I].first] = Sels[I].second;
4526  }
4527 
4528  // Warning will be issued only when selector table is
4529  // generated (which means there is at lease one implementation
4530  // in the TU). This is to match gcc's behavior.
4531  if (ReferencedSelectors.empty() ||
4533  return;
4534  for (auto &SelectorAndLocation : ReferencedSelectors) {
4535  Selector Sel = SelectorAndLocation.first;
4536  SourceLocation Loc = SelectorAndLocation.second;
4538  Diag(Loc, diag::warn_unimplemented_selector) << Sel;
4539  }
4540 }
4541 
4542 ObjCIvarDecl *
4544  const ObjCPropertyDecl *&PDecl) const {
4545  if (Method->isClassMethod())
4546  return nullptr;
4547  const ObjCInterfaceDecl *IDecl = Method->getClassInterface();
4548  if (!IDecl)
4549  return nullptr;
4550  Method = IDecl->lookupMethod(Method->getSelector(), /*isInstance=*/true,
4551  /*shallowCategoryLookup=*/false,
4552  /*followSuper=*/false);
4553  if (!Method || !Method->isPropertyAccessor())
4554  return nullptr;
4555  if ((PDecl = Method->findPropertyDecl()))
4556  if (ObjCIvarDecl *IV = PDecl->getPropertyIvarDecl()) {
4557  // property backing ivar must belong to property's class
4558  // or be a private ivar in class's implementation.
4559  // FIXME. fix the const-ness issue.
4560  IV = const_cast<ObjCInterfaceDecl *>(IDecl)->lookupInstanceVariable(
4561  IV->getIdentifier());
4562  return IV;
4563  }
4564  return nullptr;
4565 }
4566 
4567 namespace {
4568  /// Used by Sema::DiagnoseUnusedBackingIvarInAccessor to check if a property
4569  /// accessor references the backing ivar.
4570  class UnusedBackingIvarChecker :
4571  public RecursiveASTVisitor<UnusedBackingIvarChecker> {
4572  public:
4573  Sema &S;
4574  const ObjCMethodDecl *Method;
4575  const ObjCIvarDecl *IvarD;
4576  bool AccessedIvar;
4577  bool InvokedSelfMethod;
4578 
4579  UnusedBackingIvarChecker(Sema &S, const ObjCMethodDecl *Method,
4580  const ObjCIvarDecl *IvarD)
4581  : S(S), Method(Method), IvarD(IvarD),
4582  AccessedIvar(false), InvokedSelfMethod(false) {
4583  assert(IvarD);
4584  }
4585 
4586  bool VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
4587  if (E->getDecl() == IvarD) {
4588  AccessedIvar = true;
4589  return false;
4590  }
4591  return true;
4592  }
4593 
4594  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
4596  S.isSelfExpr(E->getInstanceReceiver(), Method)) {
4597  InvokedSelfMethod = true;
4598  }
4599  return true;
4600  }
4601  };
4602 } // end anonymous namespace
4603 
4605  const ObjCImplementationDecl *ImplD) {
4607  return;
4608 
4609  for (const auto *CurMethod : ImplD->instance_methods()) {
4610  unsigned DIAG = diag::warn_unused_property_backing_ivar;
4611  SourceLocation Loc = CurMethod->getLocation();
4612  if (Diags.isIgnored(DIAG, Loc))
4613  continue;
4614 
4615  const ObjCPropertyDecl *PDecl;
4616  const ObjCIvarDecl *IV = GetIvarBackingPropertyAccessor(CurMethod, PDecl);
4617  if (!IV)
4618  continue;
4619 
4620  UnusedBackingIvarChecker Checker(*this, CurMethod, IV);
4621  Checker.TraverseStmt(CurMethod->getBody());
4622  if (Checker.AccessedIvar)
4623  continue;
4624 
4625  // Do not issue this warning if backing ivar is used somewhere and accessor
4626  // implementation makes a self call. This is to prevent false positive in
4627  // cases where the ivar is accessed by another method that the accessor
4628  // delegates to.
4629  if (!IV->isReferenced() || !Checker.InvokedSelfMethod) {
4630  Diag(Loc, DIAG) << IV;
4631  Diag(PDecl->getLocation(), diag::note_property_declare);
4632  }
4633  }
4634 }
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:451
unsigned getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5204
void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer, ArrayRef< IdentifierLocPair > ProtocolId, SmallVectorImpl< Decl * > &Protocols)
FindProtocolDeclaration - This routine looks up protocols and issues an error if they are not declare...
param_const_iterator param_begin() const
Definition: DeclObjC.h:359
void setMethodParams(ASTContext &C, ArrayRef< ParmVarDecl * > Params, ArrayRef< SourceLocation > SelLocs=llvm::None)
Sets the method's parameters and selector source locations.
Definition: DeclObjC.cpp:792
bool hasDefinition() const
Determine whether this class has been defined.
Definition: DeclObjC.h:1202
Defines the clang::ASTContext interface.
SourceLocation getEnd() const
static bool tryMatchRecordTypes(ASTContext &Context, Sema::MethodMatchStrategy strategy, const Type *left, const Type *right)
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:64
void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT, ObjCInterfaceDecl *ID)
DiagnoseClassExtensionDupMethods - Check for duplicate declaration of a class method in its extension...
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:5108
static Selector GetNullarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing a nullary selector.
Definition: ASTContext.h:2571
void setImplicit(bool I=true)
Definition: DeclBase.h:515
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
Definition: SemaType.cpp:4944
bool isSelfExpr(Expr *RExpr)
Private Helper predicate to check for 'self'.
The receiver is an object instance.
Definition: ExprObjC.h:1005
void setEndOfDefinitionLoc(SourceLocation LE)
Definition: DeclObjC.h:1546
const unsigned MaxEditDistance
protocol_range protocols() const
Definition: DeclObjC.h:1785
Smart pointer class that efficiently represents Objective-C method names.
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2147
A (possibly-)qualified type.
Definition: Type.h:575
ASTConsumer & Consumer
Definition: Sema.h:296
bool isObjCContainer() const
Definition: DeclBase.h:1237
ImplementationControl getImplementationControl() const
Definition: DeclObjC.h:468
Simple class containing the result of Sema::CorrectTypo.
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1206
TypeResult actOnObjCTypeArgsAndProtocolQualifiers(Scope *S, SourceLocation Loc, ParsedType BaseType, SourceLocation TypeArgsLAngleLoc, ArrayRef< ParsedType > TypeArgs, SourceLocation TypeArgsRAngleLoc, SourceLocation ProtocolLAngleLoc, ArrayRef< Decl * > Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc)
Build a specialized and/or protocol-qualified Objective-C type.
Definition: SemaType.cpp:1078
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.h:1974
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1043
DeclContext * getCurLexicalContext() const
Definition: Sema.h:9208
void setOverriding(bool isOverriding)
Definition: DeclObjC.h:440
void startDefinition()
Starts the definition of this Objective-C class, taking it from a forward declaration (@class) to a d...
Definition: DeclObjC.cpp:553
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2277
static QualType getObjectType(APValue::LValueBase B)
Retrieves the "underlying object type" of the given expression, as used by __builtin_object_size.
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
Definition: DeclBase.h:613
llvm::DenseSet< IdentifierInfo * > ProtocolNameSet
FIXME: Type hierarchies in Objective-C can be deep.
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2636
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:164
const LangOptions & getLangOpts() const
Definition: Sema.h:1041
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
Look up the name of an Objective-C protocol.
Definition: Sema.h:2670
bool isDefined() const
Definition: DeclObjC.h:429
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
static bool CheckMethodOverrideParam(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, ParmVarDecl *ImplVar, ParmVarDecl *IfaceVar, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn)
Defines the SourceManager interface.
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
Definition: SemaDecl.cpp:10351
bool isRecordType() const
Definition: Type.h:5362
QualType getUnderlyingType() const
Definition: Decl.h:2566
iterator end()
Definition: DeclGroup.h:108
void setHasMoreThanOneDecl(bool B)
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1118
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:77
void DiagnoseMissingDesignatedInitOverrides(const ObjCImplementationDecl *ImplD, const ObjCInterfaceDecl *IFD)
void DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl< ObjCMethodDecl * > &Methods, Selector Sel, SourceRange R, bool receiverIdOrClass)
Captures information about "declaration specifiers" specific to Objective-C.
Definition: DeclSpec.h:768
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function...
Definition: SemaDecl.cpp:5155
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:680
static ObjCProtocolDecl * Create(ASTContext &C, DeclContext *DC, IdentifierInfo *Id, SourceLocation nameLoc, SourceLocation atStartLoc, ObjCProtocolDecl *PrevDecl)
Definition: DeclObjC.cpp:1751
static bool NestedProtocolHasNoDefinition(ObjCProtocolDecl *PDecl, ObjCProtocolDecl *&UndefinedProtocol)
SCS getStorageClassSpec() const
Definition: DeclSpec.h:441
void AddDecl(Decl *D)
Definition: Scope.h:272
std::string getAsString() const
Definition: Type.h:901
bool CheckForwardProtocolDeclarationForCircularDependency(IdentifierInfo *PName, SourceLocation &PLoc, SourceLocation PrevLoc, const ObjCList< ObjCProtocolDecl > &PList)
PtrTy get() const
Definition: Ownership.h:163
DeclGroupPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc, ArrayRef< IdentifierLocPair > IdentList, AttributeList *attrList)
ActOnForwardProtocolDeclaration - Handle @protocol foo;.
The base class of the type hierarchy.
Definition: Type.h:1249
bool isObjCQualifiedClassType() const
Definition: Type.h:5396
void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false)
AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Definition: Sema.h:3187
The parameter is covariant, e.g., X<T> is a subtype of X<U> when the type parameter is covariant and ...
virtual void ReadMethodPool(Selector Sel)
Load the contents of the global method pool for a given selector.
Definition: Sema.cpp:1262
std::pair< IdentifierInfo *, SourceLocation > IdentifierLocPair
A simple pair of identifier info and location.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:46
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
Definition: DeclSpec.cpp:444
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1356
A container of type source information.
Definition: Decl.h:61
void ProcessPropertyDecl(ObjCPropertyDecl *property)
Process the specified property declaration and create decls for the setters and getters as needed...
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:380
static void HelperSelectorsForTypoCorrection(SmallVectorImpl< const ObjCMethodDecl * > &BestMethod, StringRef Typo, const ObjCMethodDecl *Method)
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID)
createImplicitParams - Used to lazily create the self and cmd implict parameters. ...
Definition: DeclObjC.cpp:1022
const ObjCPropertyDecl * findPropertyDecl(bool CheckOverrides=true) const
Returns the property associated with this method's selector.
Definition: DeclObjC.cpp:1203
ObjCMethodDecl * getMethod(Selector Sel, bool isInstance, bool AllowHidden=false) const
Definition: DeclObjC.cpp:68
ObjCTypeParamVariance getVariance() const
Determine the variance of this type parameter.
Definition: DeclObjC.h:577
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group, bool TypeMayContainAuto=true)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
Definition: SemaDecl.cpp:10303
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:699
void setImplementation(ObjCCategoryImplDecl *ImplD)
Definition: DeclObjC.cpp:1923
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1608
DiagnosticsEngine & Diags
Definition: Sema.h:297
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclObjC.h:291
std::string getAsString() const
field_iterator field_begin() const
Definition: Decl.cpp:3746
static void WarnUndefinedMethod(Sema &S, SourceLocation ImpLoc, ObjCMethodDecl *method, bool &IncompleteImpl, unsigned DiagID, NamedDecl *NeededFor=nullptr)
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
SourceRange getReturnTypeSourceRange() const
Definition: DeclObjC.cpp:1055
llvm::MapVector< Selector, SourceLocation > ReferencedSelectors
Method selectors used in a @selector expression.
Definition: Sema.h:966
unsigned param_size() const
Definition: DeclObjC.h:348
unsigned size() const
Determine the number of type parameters in this list.
Definition: DeclObjC.h:653
iterator begin() const
Definition: Type.h:4072
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1299
static void DiagnoseObjCImplementedDeprecations(Sema &S, NamedDecl *ND, SourceLocation ImplLoc, int select)
The collection of all-type qualifiers we support.
Definition: Type.h:116
MethodMatchStrategy
Definition: Sema.h:3104
Decl * ActOnAtEnd(Scope *S, SourceRange AtEnd, ArrayRef< Decl * > allMethods=None, ArrayRef< DeclGroupPtrTy > allTUVars=None)
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3166
One of these records is kept for each identifier that is lexed.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:700
bool isScalarType() const
Definition: Type.h:5581
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc, IdentifierInfo **IdentList, SourceLocation *IdentLocs, ArrayRef< ObjCTypeParamList * > TypeParamLists, unsigned NumElts)
bool hasAttr() const
Definition: DeclBase.h:498
Represents a class type in Objective C.
Definition: Type.h:4557
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:91
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
Definition: DeclSpec.h:1966
ObjCMethodFamily
A family of Objective-C methods.
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1727
ObjCIvarDecl * getIvarDecl(IdentifierInfo *Id) const
getIvarDecl - This method looks up an ivar in this ContextDecl.
Definition: DeclObjC.cpp:56
The parameter is contravariant, e.g., X<T> is a subtype of X<U> when the type parameter is covariant ...
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
void set(T *const *InList, unsigned Elts, ASTContext &Ctx)
Definition: DeclObjC.h:60
bool isOverriding() const
Whether this method overrides any other in the class hierarchy.
Definition: DeclObjC.h:439
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2209
ImplicitParamDecl * getCmdDecl() const
Definition: DeclObjC.h:413
all_protocol_range all_referenced_protocols() const
Definition: DeclObjC.h:1095
void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass, SmallVectorImpl< const ObjCIvarDecl * > &Ivars) const
DeepCollectObjCIvars - This routine first collects all declared, but not synthesized, ivars in super class and then collects all ivars, including those synthesized for current class.
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:353
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:259
void setSuperClass(TypeSourceInfo *superClass)
Definition: DeclObjC.h:1255
ObjCMethodDecl * getClassMethod(Selector Sel, bool AllowHidden=false) const
Definition: DeclObjC.h:776
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1962
param_range params()
Definition: DeclObjC.h:354
method_range methods() const
Definition: DeclObjC.h:729
int Category
Definition: Format.cpp:1726
void ClearStorageClassSpecs()
Definition: DeclSpec.h:455
void setReturnType(QualType T)
Definition: DeclObjC.h:331
void startDefinition()
Starts the definition of this Objective-C protocol.
Definition: DeclObjC.cpp:1811
static bool checkTypeParamListConsistency(Sema &S, ObjCTypeParamList *prevTypeParams, ObjCTypeParamList *newTypeParams, TypeParamListContext newContext)
Check consistency between two Objective-C type parameter lists, e.g., between a category/extension an...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1191
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:1987
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator, which is not a function declaration or definition and therefore is not permitted to have default arguments.
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
Definition: Diagnostic.h:1112
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:919
IdentifierTable & Idents
Definition: ASTContext.h:451
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:170
void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart, IdentifierInfo *ClassName, SmallVectorImpl< Decl * > &Decls)
Called whenever @defs(ClassName) is encountered in the source.
bool IsClassExtension() const
Definition: DeclObjC.h:2034
void MatchAllMethodDeclarations(const SelectorSet &InsMap, const SelectorSet &ClsMap, SelectorSet &InsMapSeen, SelectorSet &ClsMapSeen, ObjCImplDecl *IMPDecl, ObjCContainerDecl *IDecl, bool &IncompleteImpl, bool ImmediateClass, bool WarnCategoryMethodImpl=false)
MatchAllMethodDeclarations - Check methods declaraed in interface or or protocol against those declar...
bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall)
Check whether the given method, which must be in the 'init' family, is a valid member of that family...
void setMethod(ObjCMethodDecl *M)
SourceLocation getSelectorLoc(unsigned Index) const
Definition: DeclObjC.h:302
Represents the results of name lookup.
Definition: Sema/Lookup.h:30
ObjCMethodDecl * LookupImplementedMethodInGlobalPool(Selector Sel)
LookupImplementedMethodInGlobalPool - Returns the method which has an implementation.
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
Definition: SemaDecl.cpp:2370
static ObjCInterfaceDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id, ObjCTypeParamList *typeParamList, ObjCInterfaceDecl *PrevDecl, SourceLocation ClassLoc=SourceLocation(), bool isInternal=false)
Definition: DeclObjC.cpp:1350
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:324
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:696
const LangOptions & getLangOpts() const
Definition: ASTContext.h:596
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:952
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:514
static ObjCCategoryDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation AtLoc, SourceLocation ClassNameLoc, SourceLocation CategoryNameLoc, IdentifierInfo *Id, ObjCInterfaceDecl *IDecl, ObjCTypeParamList *typeParamList, SourceLocation IvarLBraceLoc=SourceLocation(), SourceLocation IvarRBraceLoc=SourceLocation())
Definition: DeclObjC.cpp:1885
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:885
void ActOnTypedefedProtocols(SmallVectorImpl< Decl * > &ProtocolRefs, IdentifierInfo *SuperName, SourceLocation SuperLoc)
ActOnTypedefedProtocols - this action finds protocol list as part of the typedef'ed use for a qualifi...
SCS
storage-class-specifier
Definition: DeclSpec.h:232
Decl * ActOnObjCContainerStartDefinition(Decl *IDecl)
Definition: SemaDecl.cpp:12723
ObjCContainerKind
Definition: Sema.h:7145
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Definition: Sema.h:962
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2486
static ObjCTypeParamList * create(ASTContext &ctx, SourceLocation lAngleLoc, ArrayRef< ObjCTypeParamDecl * > typeParams, SourceLocation rAngleLoc)
Create a new Objective-C type parameter list.
Definition: DeclObjC.cpp:1328
static ObjCAtDefsFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, Expr *BW)
Definition: DeclObjC.cpp:1721
iterator begin()
Definition: DeclGroup.h:102
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:4800
void setExceptionVariable(bool EV)
Definition: Decl.h:1143
bool isDesignatedInitializerForTheInterface(const ObjCMethodDecl **InitMethod=nullptr) const
Returns true if the method selector resolves to a designated initializer in the class's interface...
Definition: DeclObjC.cpp:744
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
Definition: DeclObjC.h:1858
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:38
const ObjCMethodDecl * SelectorsForTypoCorrection(Selector Sel, QualType ObjectType=QualType())
static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn)
unsigned Align
Definition: ASTContext.h:82
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1026
Decl * ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc, Decl *const *ProtoRefNames, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, AttributeList *AttrList)
void setAsRedeclaration(const ObjCMethodDecl *PrevMethod)
Definition: DeclObjC.cpp:760
bool hasUnrecoverableErrorOccurred() const
Definition: Scope.h:315
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:1728
bool isObjCIndependentClassType() const
Definition: Type.cpp:3699
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1886
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1800
iterator end() const
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
Definition: DeclObjC.h:1827
Decl * ActOnObjCExceptionDecl(Scope *S, Declarator &D)
#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, SHOWINSYSHEADER, CATEGORY)
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
A class that does preorder depth-first traversal on the entire Clang AST and visits each node...
Represents an ObjC class declaration.
Definition: DeclObjC.h:853
propimpl_range property_impls() const
Definition: DeclObjC.h:2110
ObjCMethodDecl * getMethod() const
unsigned getBits() const
bool empty() const
Definition: Type.h:359
detail::InMemoryDirectory::const_iterator I
virtual void ReadReferencedSelectors(SmallVectorImpl< std::pair< Selector, SourceLocation > > &Sels)
Read the set of referenced selectors known to the external Sema source.
known_categories_range known_categories() const
Definition: DeclObjC.h:1355
QualType getType() const
Definition: Decl.h:530
bool isInvalid() const
const LangOptions & LangOpts
Definition: Sema.h:293
bool hasExplicitBound() const
Whether this type parameter has an explicitly-written type bound, e.g., "T : NSView".
Definition: DeclObjC.h:594
void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL, bool IncludeCXX11Attributes=true)
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:2685
SourceRange getRange() const
Definition: DeclSpec.h:68
void AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl)
AtomicPropertySetterGetterRules - This routine enforces the rule (via warning) when atomic property h...
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
ObjCIvarDecl * getDecl()
Definition: ExprObjC.h:505
ObjCProtocolDecl *const * iterator
Definition: DeclObjC.h:64
field_iterator field_end() const
Definition: Decl.h:3298
void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false)
AddInstanceMethodToGlobalPool - All instance methods in a translation unit are added to a global pool...
Definition: Sema.h:3182
void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod, ObjCInterfaceDecl *CurrentClass, ResultTypeCompatibilityKind RTC)
static Decl::ObjCDeclQualifier CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal)
CvtQTToAstBitMask - utility routine to produce an AST bitmask for objective-c's type qualifier from t...
static const Decl * getDefinition(const Decl *D)
Definition: SemaDecl.cpp:2261
AnnotatingParser & P
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2605
bool isUnion() const
Definition: Decl.h:2856
static bool isAcceptableMethodMismatch(ObjCMethodDecl *chosen, ObjCMethodDecl *other)
Determines if this is an "acceptable" loose mismatch in the global method pool.
bool isThisDeclarationADefinition() const
Determine whether this particular declaration is also the definition.
Definition: DeclObjC.h:1869
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1719
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:349
AvailabilityResult getAvailability(std::string *Message=nullptr) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:469
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:259
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2510
ResultTypeCompatibilityKind
Describes the compatibility of a result type with its method.
Definition: Sema.h:7536
std::string CurrentModule
The name of the current module.
Definition: LangOptions.h:96
llvm::SmallPtrSet< Selector, 8 > SelectorSet
Definition: Sema.h:3011
bool inferObjCARCLifetime(ValueDecl *decl)
Definition: SemaDecl.cpp:5352
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:599
void AddAnyMethodToGlobalPool(Decl *D)
AddAnyMethodToGlobalPool - Add any method, instance or factory to global pool.
ASTContext * Context
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclObjC.h:269
void ActOnSuperClassOfClassInterface(Scope *S, SourceLocation AtInterfaceLoc, ObjCInterfaceDecl *IDecl, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperName, SourceLocation SuperLoc, ArrayRef< ParsedType > SuperTypeArgs, SourceRange SuperTypeArgsRange)
SourceLocation NameLoc
Definition: Sema.h:7364
ivar_range ivars() const
Definition: DeclObjC.h:1127
void ReadMethodPool(Selector Sel)
Read the contents of the method pool for a given selector from external storage.
bool AnyObjCImplementation()
Return true if there is at least one @implementation in the TU.
Definition: ASTContext.h:2306
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
bool isUnarySelector() const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Definition: ObjCRuntime.h:133
SourceLocation getVarianceLoc() const
Retrieve the location of the variance keyword.
Definition: DeclObjC.h:587
Type source information for an attributed type.
Definition: TypeLoc.h:724
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:2632
static ObjCMethodDecl * Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl, bool isInstance=true, bool isVariadic=false, bool isPropertyAccessor=false, bool isImplicitlyDeclared=false, bool isDefined=false, ImplementationControl impControl=None, bool HasRelatedResultType=false)
Definition: DeclObjC.cpp:722
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
Definition: Scope.h:306
unsigned getNumArgs() const
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Definition: Type.h:3696
bool isObjCClassType() const
Definition: Type.h:5406
StateNode * Previous
bool CollectMultipleMethodsInGlobalPool(Selector Sel, SmallVectorImpl< ObjCMethodDecl * > &Methods, bool instance)
Returns instance or factory methods in global method pool for given selector.
This file defines the classes used to store parsed information about declaration-specifiers and decla...
TypeResult ActOnTypeName(Scope *S, Declarator &D)
Definition: SemaType.cpp:4963
Expr * getBitWidth() const
Definition: Decl.h:2291
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:111
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Sema/Lookup.h:458
void setAtEndRange(SourceRange atEnd)
Definition: DeclObjC.h:805
void ActOnStartOfObjCMethodDef(Scope *S, Decl *D)
ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible and user declared, in the method definition's AST.
static ObjCTypeParamDecl * Create(ASTContext &ctx, DeclContext *dc, ObjCTypeParamVariance variance, SourceLocation varianceLoc, unsigned index, SourceLocation nameLoc, IdentifierInfo *name, SourceLocation colonLoc, TypeSourceInfo *boundInfo)
Definition: DeclObjC.cpp:1281
DeclContext * getDeclContext()
Definition: DeclBase.h:393
void actOnObjCTypeArgsOrProtocolQualifiers(Scope *S, ParsedType baseType, SourceLocation lAngleLoc, ArrayRef< IdentifierInfo * > identifiers, ArrayRef< SourceLocation > identifierLocs, SourceLocation rAngleLoc, SourceLocation &typeArgsLAngleLoc, SmallVectorImpl< ParsedType > &typeArgs, SourceLocation &typeArgsRAngleLoc, SourceLocation &protocolLAngleLoc, SmallVectorImpl< Decl * > &protocols, SourceLocation &protocolRAngleLoc, bool warnOnIncompleteProtocols)
Given a list of identifiers (and their locations), resolve the names to either Objective-C protocol q...
ParmVarDecl *const * param_iterator
Definition: DeclObjC.h:350
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:411
void setDefined(bool isDefined)
Definition: DeclObjC.h:430
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:6518
bool isObjCIdType() const
Definition: Type.h:5401
ObjCTypeParamDecl * back() const
Definition: DeclObjC.h:671
void setImplementation(ObjCImplementationDecl *ImplD)
Definition: DeclObjC.cpp:1460
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
Definition: Type.cpp:3624
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
void mergeClassExtensionProtocolList(ObjCProtocolDecl *const *List, unsigned Num, ASTContext &C)
mergeClassExtensionProtocolList - Merge class extension's protocol list into the protocol list for th...
Definition: DeclObjC.cpp:382
Decl * ActOnStartClassImplementation(SourceLocation AtClassImplLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperClassname, SourceLocation SuperClassLoc)
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
Definition: DeclObjC.cpp:563
bool hasRelatedResultType() const
Determine whether this method has a result type that is related to the message receiver's type...
Definition: DeclObjC.h:276
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1751
static void DiagnoseWeakIvars(Sema &S, ObjCImplementationDecl *ID)
Diagnose attempts to define ARC-__weak ivars when __weak is disabled.
bool isInstanceMethod() const
Definition: DeclObjC.h:419
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:85
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
Definition: Type.h:4899
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1593
ScalarTypeKind
Definition: Type.h:1735
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
void WarnConflictingTypedMethods(ObjCMethodDecl *Method, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl)
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:190
void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method)
Add the given method to the list of globally-known methods.
class LLVM_ALIGNAS(8) TemplateSpecializationType unsigned NumArgs
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:3988
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1203
void CollectInheritedProtocols(const Decl *CDecl, llvm::SmallPtrSet< ObjCProtocolDecl *, 8 > &Protocols)
CollectInheritedProtocols - Collect all protocols in current class and those inherited by it...
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
SourceLocation getLocEnd() const LLVM_READONLY
Definition: TypeLoc.h:131
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:450
void removeCVRQualifiers(unsigned mask)
Definition: Type.h:256
ObjCTypeParamVariance
Describes the variance of a given generic parameter.
Definition: DeclObjC.h:514
DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl, ArrayRef< Decl * > Decls)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:602
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an '@'.
Definition: TokenKinds.h:41
unsigned BestEditDistance
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Definition: DeclBase.cpp:241
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:545
ivar_iterator ivar_begin() const
Definition: DeclObjC.h:1128
bool hasObjCLifetime() const
Definition: Type.h:289
ObjCCategoryDecl * getCategoryDecl() const
Definition: DeclObjC.cpp:1963
param_const_iterator param_end() const
Definition: DeclObjC.h:362
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:207
bool isClassMethod() const
Definition: DeclObjC.h:424
void addAttr(Attr *A)
Definition: DeclBase.h:449
ObjCDeclQualifier
ObjCDeclQualifier - Qualifier used on types in method declarations.
Definition: DeclSpec.h:776
void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID)
DiagnoseDuplicateIvars - Check for duplicate ivars in the entire class at the start of @implementatio...
static ObjCCompatibleAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, ObjCInterfaceDecl *aliasedClass)
Definition: DeclObjC.cpp:2086
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:215
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1540
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:80
#define false
Definition: stdbool.h:33
SelectorTable & Selectors
Definition: ASTContext.h:452
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:145
static void findProtocolsWithExplicitImpls(const ObjCProtocolDecl *PDecl, ProtocolNameSet &PNS)
Encodes a location in the source.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setTopLevelDeclInObjCContainer(bool V=true)
Definition: DeclBase.h:552
void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, ObjCIvarDecl **Fields, unsigned nIvars, SourceLocation Loc)
CheckImplementationIvars - This routine checks if the instance variables listed in the implelementati...
const TemplateArgument * iterator
Definition: Type.h:4070
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3463
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:4766
ivar_iterator ivar_end() const
Definition: DeclObjC.h:1135
bool isValid() const
Return true if this is a valid SourceLocation object.
static void mergeInterfaceMethodToImpl(Sema &S, ObjCMethodDecl *method, ObjCMethodDecl *prevMethod)
Merge information from the declaration of a method in the @interface (or a category/extension) into t...
void setObjCDeclQualifier(ObjCDeclQualifier QV)
Definition: DeclObjC.h:272
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
Definition: DeclBase.h:198
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isValid() const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
static bool objcModifiersConflict(Decl::ObjCDeclQualifier x, Decl::ObjCDeclQualifier y)
Determine whether two set of Objective-C declaration qualifiers conflict.
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
Definition: ScopeInfo.h:117
bool isVariadic() const
Definition: DeclObjC.h:421
void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden)
Check whether the given new method is a valid override of the given overridden method, and set any properties that should be inherited.
ObjCTypeParamList * actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc, ArrayRef< Decl * > typeParams, SourceLocation rAngleLoc)
static QualType mergeTypeNullabilityForRedecl(Sema &S, SourceLocation loc, QualType type, bool usesCSKeyword, SourceLocation prevLoc, QualType prevType, bool prevUsesCSKeyword)
Merge type nullability from for a redeclaration of the same entity, producing the updated type of the...
std::unique_ptr< ProtocolNameSet > LazyProtocolNameSet
void DiagnoseUseOfUnimplementedSelectors()
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
Definition: DeclObjC.h:1159
static bool isObjCTypeSubstitutable(ASTContext &Context, const ObjCObjectPointerType *A, const ObjCObjectPointerType *B, bool rejectId)
Determines if type B can be substituted for type A.
ObjCInterfaceDecl * lookupInheritedClass(const IdentifierInfo *ICName)
lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super class whose name is passe...
Definition: DeclObjC.cpp:594
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:1931
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2085
CanQualType VoidTy
Definition: ASTContext.h:881
bool isPropertyAccessor() const
Definition: DeclObjC.h:426
ObjCIvarDecl * GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method, const ObjCPropertyDecl *&PDecl) const
GetIvarBackingPropertyAccessor - If method is a property setter/getter and it property has a backing ...
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
Look up any declaration with any name.
Definition: Sema.h:2674
void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCContainerDecl *CDecl, bool SynthesizeProperties)
DiagnoseUnimplementedProperties - This routine warns on those properties which must be implemented by...
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:2416
std::string getAsString() const
Derive the full selector name (e.g.
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
Definition: DeclObjC.h:1993
ObjCProtocolDecl * LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc, RedeclarationKind Redecl=NotForRedeclaration)
Find the protocol with the given name, if any.
SourceLocation getBegin() const
QualType getReturnType() const
Definition: DeclObjC.h:330
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5706
QualType getAttributedType(AttributedType::Kind attrKind, QualType modifiedType, QualType equivalentType)
bool isFileContext() const
Definition: DeclBase.h:1265
bool ObjCIsDesignatedInit
True when this is a method marked as a designated initializer.
Definition: ScopeInfo.h:113
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super's implementation, such as -dealloc...
Definition: ScopeInfo.h:110
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1167
void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList)
static bool HelperIsMethodInObjCType(Sema &S, Selector Sel, QualType ObjectType)
SourceLocation getLAngleLoc() const
Definition: DeclObjC.h:676
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:645
bool AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod, SourceRange R, bool receiverIdOrClass)
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:69
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;...
Definition: ASTContext.h:1469
void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D)
static bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl, ObjCMethodDecl *decl)
In ARC, check whether the conventional meanings of the two methods match.
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1155
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1743
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1642
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
Definition: DeclObjC.h:1473
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclSpec.h:810
TypeLoc findExplicitQualifierLoc() const
Find a type with the location of an explicit type qualifier.
Definition: TypeLoc.cpp:379
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2526
Represents a template argument.
Definition: TemplateBase.h:40
void WarnExactTypedMethods(ObjCMethodDecl *Method, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl)
WarnExactTypedMethods - This routine issues a warning if method implementation declaration matches ex...
const ObjCProtocolList & getReferencedProtocols() const
Definition: DeclObjC.h:1778
instmeth_range instance_methods() const
Definition: DeclObjC.h:744
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:442
ObjCCategoryDecl * FindCategoryDeclaration(IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
Definition: DeclObjC.cpp:1559
ObjCCategoryImplDecl * getImplementation() const
Definition: DeclObjC.cpp:1918
void DiagnoseUnusedBackingIvarInAccessor(Scope *S, const ObjCImplementationDecl *ImplD)
DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which backs the property is n...
ObjCContainerKind getObjCContainerKind() const
void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl)
Diagnose any null-resettable synthesized setters.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1121
bool CheckFunctionReturnType(QualType T, SourceLocation Loc)
Definition: SemaType.cpp:2226
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1723
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2582
ObjCMethodDecl * getInstanceMethod(Selector Sel, bool AllowHidden=false) const
Definition: DeclObjC.h:772
SourceLocation getLocStart() const LLVM_READONLY
Definition: TypeLoc.h:130
void CheckConflictingOverridingMethod(ObjCMethodDecl *Method, ObjCMethodDecl *Overridden, bool IsProtocolMethodDecl)
bool isInvalidDecl() const
Definition: DeclBase.h:509
bool ObjCIsSecondaryInit
True when this is an initializer method not marked as a designated initializer within a class that ha...
Definition: ScopeInfo.h:122
Decl * ActOnStartClassInterface(Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, IdentifierInfo *SuperName, SourceLocation SuperLoc, ArrayRef< ParsedType > SuperTypeArgs, SourceRange SuperTypeArgsRange, Decl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, AttributeList *AttrList)
TypeParamListContext
The context in which an Objective-C type parameter list occurs, for use in diagnostics.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:104
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition: DeclObjC.h:1216
bool CheckARCMethodDecl(ObjCMethodDecl *method)
Check a method declaration for compatibility with the Objective-C ARC conventions.
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:537
static void CheckProtocolMethodDefs(Sema &S, SourceLocation ImpLoc, ObjCProtocolDecl *PDecl, bool &IncompleteImpl, const Sema::SelectorSet &InsMap, const Sema::SelectorSet &ClsMap, ObjCContainerDecl *CDecl, LazyProtocolNameSet &ProtocolsExplictImpl)
CheckProtocolMethodDefs - This routine checks unimplemented methods Declared in protocol, and those referenced by it.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
Definition: SemaDecl.cpp:1069
bool hasDefinition() const
Determine whether this protocol has a definition.
Definition: DeclObjC.h:1846
static ObjCImplementationDecl * Create(ASTContext &C, DeclContext *DC, ObjCInterfaceDecl *classInterface, ObjCInterfaceDecl *superDecl, SourceLocation nameLoc, SourceLocation atStartLoc, SourceLocation superLoc=SourceLocation(), SourceLocation IvarLBraceLoc=SourceLocation(), SourceLocation IvarRBraceLoc=SourceLocation())
Definition: DeclObjC.cpp:2034
Selector getSelector() const
Definition: DeclObjC.h:328
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
Definition: ScopeInfo.h:125
detail::InMemoryDirectory::const_iterator E
static bool matchTypes(ASTContext &Context, Sema::MethodMatchStrategy strategy, QualType leftQT, QualType rightQT)
ObjCMethodFamily getMethodFamily() const
Derive the conventional family of this method.
IdentifierResolver IdResolver
Definition: Sema.h:675
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Sema/Lookup.h:249
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1946
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
Definition: SemaDecl.cpp:10574
iterator begin() const
Definition: DeclObjC.h:65
StringRef Typo
DeclClass * getCorrectionDeclAs() const
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1459
Represents a pointer to an Objective C object.
Definition: Type.h:4821
bool hasMoreThanOneDecl() const
static bool HasExplicitOwnershipAttr(Sema &S, ParmVarDecl *Param)
HasExplicitOwnershipAttr - returns true when pointer to ObjC pointer has explicit ownership attribute...
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:127
void RemoveDecl(Decl *D)
Definition: Scope.h:276
bool isObjCObjectType() const
Definition: Type.h:5380
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2220
ObjCMethodDecl * lookupMethod(Selector Sel, bool isInstance, bool shallowCategoryLookup=false, bool followSuper=true, const ObjCCategoryDecl *C=nullptr) const
lookupMethod - This method returns an instance/class method by looking in the class, its categories, and its super classes (using a linear search).
Definition: DeclObjC.cpp:625
SourceManager & getSourceManager() const
Definition: Sema.h:1046
void setNext(ObjCMethodList *L)
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
ExternalSemaSource * getExternalSource() const
Definition: Sema.h:1051
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1194
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
Definition: DeclObjC.cpp:260
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl *IMPDecl, ObjCContainerDecl *IDecl, bool IncompleteImpl=false)
ImplMethodsVsClassMethods - This is main routine to warn if any method remains unimplemented in the c...
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
static __inline__ uint32_t uint32_t y
Definition: arm_acle.h:113
bool isObjCQualifiedIdType() const
Definition: Type.h:5391
static const TST TST_typename
Definition: DeclSpec.h:292
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2287
VarDecl * BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, bool Invalid=false)
Build a type-check a new Objective-C exception variable declaration.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1495
virtual void HandleTopLevelDeclInObjCContainer(DeclGroupRef D)
Handle the specified top-level declaration that occurred inside and ObjC container.
Definition: ASTConsumer.cpp:28
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
A list of Objective-C protocols, along with the source locations at which they were referenced...
Definition: DeclObjC.h:76
const ObjCProtocolList & getReferencedProtocols() const
Definition: DeclObjC.h:1016
Wraps an ObjCPointerType with source location information.
Definition: TypeLoc.h:1198
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1447
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1257
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
bool isInvalid() const
static Sema::ResultTypeCompatibilityKind CheckRelatedResultTypeCompatibility(Sema &S, ObjCMethodDecl *Method, ObjCInterfaceDecl *CurrentClass)
Check whether the declared result type of the given Objective-C method declaration is compatible with...
void setBits(unsigned B)
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2354
bool isUsable() const
Definition: Ownership.h:160
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:479
SourceManager & getSourceManager()
Definition: ASTContext.h:553
void setObjCMethodScopeInfo(unsigned parameterIndex)
Definition: Decl.h:1327
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:1951
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:682
ObjCInterfaceDecl * getObjCInterfaceDecl(IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
Definition: SemaDecl.cpp:1634
Reading or writing from this object requires a barrier call.
Definition: Type.h:147
classmeth_range class_methods() const
Definition: DeclObjC.h:759
No particular method family.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
bool isImplicitInterfaceDecl() const
isImplicitInterfaceDecl - check that this is an implicitly declared ObjCInterfaceDecl node...
Definition: DeclObjC.h:1554
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:185
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:1957
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5169
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D...
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
bool isObjCObjectPointerType() const
Definition: Type.h:5377
ObjCDeclQualifier
ObjCDeclQualifier - 'Qualifiers' written next to the return and parameter types in method declaration...
Definition: DeclBase.h:186
void SetRelatedResultType(bool RRT=true)
Note whether this method has a related result type.
Definition: DeclObjC.h:279
bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method, const ObjCMethodDecl *PrevMethod, MethodMatchStrategy strategy=MMS_strict)
MatchTwoMethodDeclarations - Checks if two methods' type match and returns true, or false...
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1609
bool CheckObjCDeclScope(Decl *D)
Checks that the Objective-C declaration is declared in the global scope.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
bool CheckParmsForFunctionDef(ParmVarDecl *const *Param, ParmVarDecl *const *ParamEnd, bool CheckParameterNames)
Helpers for dealing with blocks and functions.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:615
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:115
Decl * ActOnMethodDeclaration(Scope *S, SourceLocation BeginLoc, SourceLocation EndLoc, tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType, ArrayRef< SourceLocation > SelectorLocs, Selector Sel, ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind, bool isVariadic, bool MethodDefinition)
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:70
static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc, SourceLocation ConstQualLoc, SourceLocation VolatileQualLoc, SourceLocation RestrictQualLoc, SourceLocation AtomicQualLoc)
Return a DeclaratorChunk for a pointer.
Definition: DeclSpec.h:1463
a linked list of methods with the same selector name but different signatures.
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:289
std::pair< ObjCMethodList, ObjCMethodList > GlobalMethods
Definition: Sema.h:953
void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI, SmallVectorImpl< ObjCIvarDecl * > &Ivars)
CollectIvarsToConstructOrDestruct - Collect those ivars which require initialization.
uint64_t Width
Definition: ASTContext.h:81
bool isObjCId() const
Definition: Type.h:4614
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5164
void ActOnObjCContainerFinishDefinition()
Definition: SemaDecl.cpp:12798
void setObjCDeclQualifier(ObjCDeclQualifier QTVal)
Definition: Decl.h:1360
bool isObjCClass() const
Definition: Type.h:4617
ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed...
Definition: DeclSpec.h:1165
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:384
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:245
ASTContext & Context
Definition: Sema.h:295
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, std::unique_ptr< CorrectionCandidateCallback > CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
static SourceRange getTypeRange(TypeSourceInfo *TSI)
NamedDecl - This represents a decl with a name.
Definition: Decl.h:145
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1487
bool isInvalidType() const
Definition: DeclSpec.h:2200
SourceRange getSourceRange() const
Definition: DeclObjC.h:682
static ObjCCategoryImplDecl * Create(ASTContext &C, DeclContext *DC, IdentifierInfo *Id, ObjCInterfaceDecl *classInterface, SourceLocation nameLoc, SourceLocation atStartLoc, SourceLocation CategoryNameLoc)
Definition: DeclObjC.cpp:1944
void setVariance(ObjCTypeParamVariance variance)
Set the variance of this type parameter.
Definition: DeclObjC.h:582
void setTypeSourceInfo(TypeSourceInfo *newType)
Definition: Decl.h:2571
ObjCMethodList * getNext() const
bool hasSameNullabilityTypeQualifier(QualType SubT, QualType SuperT, bool IsParam) const
Definition: ASTContext.h:1992
Decl * ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *CatName, SourceLocation CatLoc)
ActOnStartCategoryImplementation - Perform semantic checks on the category implementation declaration...
bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS, bool ForCompare)
ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an ObjCQualifiedIDType.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:642
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2561
DeclResult actOnObjCTypeParam(Scope *S, ObjCTypeParamVariance variance, SourceLocation varianceLoc, unsigned index, IdentifierInfo *paramName, SourceLocation paramLoc, SourceLocation colonLoc, ParsedType typeBound)
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1499
static void diagnoseUseOfProtocols(Sema &TheSema, ObjCContainerDecl *CD, ObjCProtocolDecl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs)
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
Definition: Type.h:4882
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:600
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
Definition: SemaDecl.cpp:3225
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
void setType(QualType newType)
Definition: Decl.h:531
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3476
ParsedAttributes - A collection of parsed attributes.
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1136
void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP)
CheckCategoryVsClassMethodMatches - Checks that methods implemented in category matches with those im...
void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation)
SetIvarInitializers - This routine builds initialization ASTs for the Objective-C implementation whos...
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2139
The parameter is invariant: must match exactly.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
visible_extensions_range visible_extensions() const
Definition: DeclObjC.h:1391
iterator end() const
Definition: DeclObjC.h:66
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1127
Decl * ActOnCompatibilityAlias(SourceLocation AtCompatibilityAliasLoc, IdentifierInfo *AliasName, SourceLocation AliasLocation, IdentifierInfo *ClassName, SourceLocation ClassLocation)
ActOnCompatibilityAlias - this action is called after complete parsing of a @compatibility_alias decl...
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition: Type.cpp:1823
IdentifierInfo * Name
Definition: Sema.h:7363
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
Definition: SemaType.cpp:4338
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:5568
bool isDeprecated(std::string *Message=nullptr) const
Determine whether this declaration is marked 'deprecated'.
Definition: DeclBase.h:604
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2385
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1071
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1712
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:72
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5116
const ObjCProtocolList & getReferencedProtocols() const
Definition: DeclObjC.h:1998
bool isHidden() const
Determine whether this declaration is hidden from name lookup.
Definition: Decl.h:237
Decl * ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, IdentifierInfo *CategoryName, SourceLocation CategoryLoc, Decl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc)
A RAII object to temporarily push a declaration context.
Definition: Sema.h:601
const ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.h:2346