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