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