clang  9.0.0
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 llvm::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->getAs<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->getAs<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 llvm::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() &&
2279  QualType(B,0),
2280  false);
2281  }
2282 
2283  /*
2284  // id is a special type that bypasses type checking completely. We want a
2285  // warning when it is used in one place but not another.
2286  if (C.isObjCIdType(A) || C.isObjCIdType(B)) return false;
2287 
2288 
2289  // If B is a qualified id, then A must also be a qualified id (which it isn't
2290  // if we've got this far)
2291  if (B->isObjCQualifiedIdType()) return false;
2292  */
2293 
2294  // Now we know that A and B are (potentially-qualified) class types. The
2295  // normal rules for assignment apply.
2296  return Context.canAssignObjCInterfaces(A, B);
2297 }
2298 
2300  return (TSI ? TSI->getTypeLoc().getSourceRange() : SourceRange());
2301 }
2302 
2303 /// Determine whether two set of Objective-C declaration qualifiers conflict.
2306  return (x & ~Decl::OBJC_TQ_CSNullability) !=
2307  (y & ~Decl::OBJC_TQ_CSNullability);
2308 }
2309 
2311  ObjCMethodDecl *MethodImpl,
2312  ObjCMethodDecl *MethodDecl,
2313  bool IsProtocolMethodDecl,
2314  bool IsOverridingMode,
2315  bool Warn) {
2316  if (IsProtocolMethodDecl &&
2318  MethodImpl->getObjCDeclQualifier())) {
2319  if (Warn) {
2320  S.Diag(MethodImpl->getLocation(),
2321  (IsOverridingMode
2322  ? diag::warn_conflicting_overriding_ret_type_modifiers
2323  : diag::warn_conflicting_ret_type_modifiers))
2324  << MethodImpl->getDeclName()
2325  << MethodImpl->getReturnTypeSourceRange();
2326  S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration)
2327  << MethodDecl->getReturnTypeSourceRange();
2328  }
2329  else
2330  return false;
2331  }
2332  if (Warn && IsOverridingMode &&
2333  !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) &&
2335  MethodDecl->getReturnType(),
2336  false)) {
2337  auto nullabilityMethodImpl =
2338  *MethodImpl->getReturnType()->getNullability(S.Context);
2339  auto nullabilityMethodDecl =
2340  *MethodDecl->getReturnType()->getNullability(S.Context);
2341  S.Diag(MethodImpl->getLocation(),
2342  diag::warn_conflicting_nullability_attr_overriding_ret_types)
2344  nullabilityMethodImpl,
2346  != 0))
2348  nullabilityMethodDecl,
2350  != 0));
2351  S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
2352  }
2353 
2354  if (S.Context.hasSameUnqualifiedType(MethodImpl->getReturnType(),
2355  MethodDecl->getReturnType()))
2356  return true;
2357  if (!Warn)
2358  return false;
2359 
2360  unsigned DiagID =
2361  IsOverridingMode ? diag::warn_conflicting_overriding_ret_types
2362  : diag::warn_conflicting_ret_types;
2363 
2364  // Mismatches between ObjC pointers go into a different warning
2365  // category, and sometimes they're even completely whitelisted.
2366  if (const ObjCObjectPointerType *ImplPtrTy =
2367  MethodImpl->getReturnType()->getAs<ObjCObjectPointerType>()) {
2368  if (const ObjCObjectPointerType *IfacePtrTy =
2369  MethodDecl->getReturnType()->getAs<ObjCObjectPointerType>()) {
2370  // Allow non-matching return types as long as they don't violate
2371  // the principle of substitutability. Specifically, we permit
2372  // return types that are subclasses of the declared return type,
2373  // or that are more-qualified versions of the declared type.
2374  if (isObjCTypeSubstitutable(S.Context, IfacePtrTy, ImplPtrTy, false))
2375  return false;
2376 
2377  DiagID =
2378  IsOverridingMode ? diag::warn_non_covariant_overriding_ret_types
2379  : diag::warn_non_covariant_ret_types;
2380  }
2381  }
2382 
2383  S.Diag(MethodImpl->getLocation(), DiagID)
2384  << MethodImpl->getDeclName() << MethodDecl->getReturnType()
2385  << MethodImpl->getReturnType()
2386  << MethodImpl->getReturnTypeSourceRange();
2387  S.Diag(MethodDecl->getLocation(), IsOverridingMode
2388  ? diag::note_previous_declaration
2389  : diag::note_previous_definition)
2390  << MethodDecl->getReturnTypeSourceRange();
2391  return false;
2392 }
2393 
2395  ObjCMethodDecl *MethodImpl,
2396  ObjCMethodDecl *MethodDecl,
2397  ParmVarDecl *ImplVar,
2398  ParmVarDecl *IfaceVar,
2399  bool IsProtocolMethodDecl,
2400  bool IsOverridingMode,
2401  bool Warn) {
2402  if (IsProtocolMethodDecl &&
2404  IfaceVar->getObjCDeclQualifier())) {
2405  if (Warn) {
2406  if (IsOverridingMode)
2407  S.Diag(ImplVar->getLocation(),
2408  diag::warn_conflicting_overriding_param_modifiers)
2409  << getTypeRange(ImplVar->getTypeSourceInfo())
2410  << MethodImpl->getDeclName();
2411  else S.Diag(ImplVar->getLocation(),
2412  diag::warn_conflicting_param_modifiers)
2413  << getTypeRange(ImplVar->getTypeSourceInfo())
2414  << MethodImpl->getDeclName();
2415  S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration)
2416  << getTypeRange(IfaceVar->getTypeSourceInfo());
2417  }
2418  else
2419  return false;
2420  }
2421 
2422  QualType ImplTy = ImplVar->getType();
2423  QualType IfaceTy = IfaceVar->getType();
2424  if (Warn && IsOverridingMode &&
2425  !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) &&
2426  !S.Context.hasSameNullabilityTypeQualifier(ImplTy, IfaceTy, true)) {
2427  S.Diag(ImplVar->getLocation(),
2428  diag::warn_conflicting_nullability_attr_overriding_param_types)
2430  *ImplTy->getNullability(S.Context),
2432  != 0))
2434  *IfaceTy->getNullability(S.Context),
2436  != 0));
2437  S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration);
2438  }
2439  if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy))
2440  return true;
2441 
2442  if (!Warn)
2443  return false;
2444  unsigned DiagID =
2445  IsOverridingMode ? diag::warn_conflicting_overriding_param_types
2446  : diag::warn_conflicting_param_types;
2447 
2448  // Mismatches between ObjC pointers go into a different warning
2449  // category, and sometimes they're even completely whitelisted.
2450  if (const ObjCObjectPointerType *ImplPtrTy =
2451  ImplTy->getAs<ObjCObjectPointerType>()) {
2452  if (const ObjCObjectPointerType *IfacePtrTy =
2453  IfaceTy->getAs<ObjCObjectPointerType>()) {
2454  // Allow non-matching argument types as long as they don't
2455  // violate the principle of substitutability. Specifically, the
2456  // implementation must accept any objects that the superclass
2457  // accepts, however it may also accept others.
2458  if (isObjCTypeSubstitutable(S.Context, ImplPtrTy, IfacePtrTy, true))
2459  return false;
2460 
2461  DiagID =
2462  IsOverridingMode ? diag::warn_non_contravariant_overriding_param_types
2463  : diag::warn_non_contravariant_param_types;
2464  }
2465  }
2466 
2467  S.Diag(ImplVar->getLocation(), DiagID)
2468  << getTypeRange(ImplVar->getTypeSourceInfo())
2469  << MethodImpl->getDeclName() << IfaceTy << ImplTy;
2470  S.Diag(IfaceVar->getLocation(),
2471  (IsOverridingMode ? diag::note_previous_declaration
2472  : diag::note_previous_definition))
2473  << getTypeRange(IfaceVar->getTypeSourceInfo());
2474  return false;
2475 }
2476 
2477 /// In ARC, check whether the conventional meanings of the two methods
2478 /// match. If they don't, it's a hard error.
2480  ObjCMethodDecl *decl) {
2481  ObjCMethodFamily implFamily = impl->getMethodFamily();
2482  ObjCMethodFamily declFamily = decl->getMethodFamily();
2483  if (implFamily == declFamily) return false;
2484 
2485  // Since conventions are sorted by selector, the only possibility is
2486  // that the types differ enough to cause one selector or the other
2487  // to fall out of the family.
2488  assert(implFamily == OMF_None || declFamily == OMF_None);
2489 
2490  // No further diagnostics required on invalid declarations.
2491  if (impl->isInvalidDecl() || decl->isInvalidDecl()) return true;
2492 
2493  const ObjCMethodDecl *unmatched = impl;
2494  ObjCMethodFamily family = declFamily;
2495  unsigned errorID = diag::err_arc_lost_method_convention;
2496  unsigned noteID = diag::note_arc_lost_method_convention;
2497  if (declFamily == OMF_None) {
2498  unmatched = decl;
2499  family = implFamily;
2500  errorID = diag::err_arc_gained_method_convention;
2501  noteID = diag::note_arc_gained_method_convention;
2502  }
2503 
2504  // Indexes into a %select clause in the diagnostic.
2505  enum FamilySelector {
2506  F_alloc, F_copy, F_mutableCopy = F_copy, F_init, F_new
2507  };
2508  FamilySelector familySelector = FamilySelector();
2509 
2510  switch (family) {
2511  case OMF_None: llvm_unreachable("logic error, no method convention");
2512  case OMF_retain:
2513  case OMF_release:
2514  case OMF_autorelease:
2515  case OMF_dealloc:
2516  case OMF_finalize:
2517  case OMF_retainCount:
2518  case OMF_self:
2519  case OMF_initialize:
2520  case OMF_performSelector:
2521  // Mismatches for these methods don't change ownership
2522  // conventions, so we don't care.
2523  return false;
2524 
2525  case OMF_init: familySelector = F_init; break;
2526  case OMF_alloc: familySelector = F_alloc; break;
2527  case OMF_copy: familySelector = F_copy; break;
2528  case OMF_mutableCopy: familySelector = F_mutableCopy; break;
2529  case OMF_new: familySelector = F_new; break;
2530  }
2531 
2532  enum ReasonSelector { R_NonObjectReturn, R_UnrelatedReturn };
2533  ReasonSelector reasonSelector;
2534 
2535  // The only reason these methods don't fall within their families is
2536  // due to unusual result types.
2537  if (unmatched->getReturnType()->isObjCObjectPointerType()) {
2538  reasonSelector = R_UnrelatedReturn;
2539  } else {
2540  reasonSelector = R_NonObjectReturn;
2541  }
2542 
2543  S.Diag(impl->getLocation(), errorID) << int(familySelector) << int(reasonSelector);
2544  S.Diag(decl->getLocation(), noteID) << int(familySelector) << int(reasonSelector);
2545 
2546  return true;
2547 }
2548 
2550  ObjCMethodDecl *MethodDecl,
2551  bool IsProtocolMethodDecl) {
2552  if (getLangOpts().ObjCAutoRefCount &&
2553  checkMethodFamilyMismatch(*this, ImpMethodDecl, MethodDecl))
2554  return;
2555 
2556  CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl,
2557  IsProtocolMethodDecl, false,
2558  true);
2559 
2560  for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
2561  IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
2562  EF = MethodDecl->param_end();
2563  IM != EM && IF != EF; ++IM, ++IF) {
2564  CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl, *IM, *IF,
2565  IsProtocolMethodDecl, false, true);
2566  }
2567 
2568  if (ImpMethodDecl->isVariadic() != MethodDecl->isVariadic()) {
2569  Diag(ImpMethodDecl->getLocation(),
2570  diag::warn_conflicting_variadic);
2571  Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
2572  }
2573 }
2574 
2576  ObjCMethodDecl *Overridden,
2577  bool IsProtocolMethodDecl) {
2578 
2579  CheckMethodOverrideReturn(*this, Method, Overridden,
2580  IsProtocolMethodDecl, true,
2581  true);
2582 
2583  for (ObjCMethodDecl::param_iterator IM = Method->param_begin(),
2584  IF = Overridden->param_begin(), EM = Method->param_end(),
2585  EF = Overridden->param_end();
2586  IM != EM && IF != EF; ++IM, ++IF) {
2587  CheckMethodOverrideParam(*this, Method, Overridden, *IM, *IF,
2588  IsProtocolMethodDecl, true, true);
2589  }
2590 
2591  if (Method->isVariadic() != Overridden->isVariadic()) {
2592  Diag(Method->getLocation(),
2593  diag::warn_conflicting_overriding_variadic);
2594  Diag(Overridden->getLocation(), diag::note_previous_declaration);
2595  }
2596 }
2597 
2598 /// WarnExactTypedMethods - This routine issues a warning if method
2599 /// implementation declaration matches exactly that of its declaration.
2601  ObjCMethodDecl *MethodDecl,
2602  bool IsProtocolMethodDecl) {
2603  // don't issue warning when protocol method is optional because primary
2604  // class is not required to implement it and it is safe for protocol
2605  // to implement it.
2607  return;
2608  // don't issue warning when primary class's method is
2609  // depecated/unavailable.
2610  if (MethodDecl->hasAttr<UnavailableAttr>() ||
2611  MethodDecl->hasAttr<DeprecatedAttr>())
2612  return;
2613 
2614  bool match = CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl,
2615  IsProtocolMethodDecl, false, false);
2616  if (match)
2617  for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
2618  IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
2619  EF = MethodDecl->param_end();
2620  IM != EM && IF != EF; ++IM, ++IF) {
2621  match = CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl,
2622  *IM, *IF,
2623  IsProtocolMethodDecl, false, false);
2624  if (!match)
2625  break;
2626  }
2627  if (match)
2628  match = (ImpMethodDecl->isVariadic() == MethodDecl->isVariadic());
2629  if (match)
2630  match = !(MethodDecl->isClassMethod() &&
2631  MethodDecl->getSelector() == GetNullarySelector("load", Context));
2632 
2633  if (match) {
2634  Diag(ImpMethodDecl->getLocation(),
2635  diag::warn_category_method_impl_match);
2636  Diag(MethodDecl->getLocation(), diag::note_method_declared_at)
2637  << MethodDecl->getDeclName();
2638  }
2639 }
2640 
2641 /// FIXME: Type hierarchies in Objective-C can be deep. We could most likely
2642 /// improve the efficiency of selector lookups and type checking by associating
2643 /// with each protocol / interface / category the flattened instance tables. If
2644 /// we used an immutable set to keep the table then it wouldn't add significant
2645 /// memory cost and it would be handy for lookups.
2646 
2648 typedef std::unique_ptr<ProtocolNameSet> LazyProtocolNameSet;
2649 
2651  ProtocolNameSet &PNS) {
2652  if (PDecl->hasAttr<ObjCExplicitProtocolImplAttr>())
2653  PNS.insert(PDecl->getIdentifier());
2654  for (const auto *PI : PDecl->protocols())
2656 }
2657 
2658 /// Recursively populates a set with all conformed protocols in a class
2659 /// hierarchy that have the 'objc_protocol_requires_explicit_implementation'
2660 /// attribute.
2662  ProtocolNameSet &PNS) {
2663  if (!Super)
2664  return;
2665 
2666  for (const auto *I : Super->all_referenced_protocols())
2668 
2670 }
2671 
2672 /// CheckProtocolMethodDefs - This routine checks unimplemented methods
2673 /// Declared in protocol, and those referenced by it.
2675  SourceLocation ImpLoc,
2676  ObjCProtocolDecl *PDecl,
2677  bool& IncompleteImpl,
2678  const Sema::SelectorSet &InsMap,
2679  const Sema::SelectorSet &ClsMap,
2680  ObjCContainerDecl *CDecl,
2681  LazyProtocolNameSet &ProtocolsExplictImpl) {
2682  ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl);
2683  ObjCInterfaceDecl *IDecl = C ? C->getClassInterface()
2684  : dyn_cast<ObjCInterfaceDecl>(CDecl);
2685  assert (IDecl && "CheckProtocolMethodDefs - IDecl is null");
2686 
2687  ObjCInterfaceDecl *Super = IDecl->getSuperClass();
2688  ObjCInterfaceDecl *NSIDecl = nullptr;
2689 
2690  // If this protocol is marked 'objc_protocol_requires_explicit_implementation'
2691  // then we should check if any class in the super class hierarchy also
2692  // conforms to this protocol, either directly or via protocol inheritance.
2693  // If so, we can skip checking this protocol completely because we
2694  // know that a parent class already satisfies this protocol.
2695  //
2696  // Note: we could generalize this logic for all protocols, and merely
2697  // add the limit on looking at the super class chain for just
2698  // specially marked protocols. This may be a good optimization. This
2699  // change is restricted to 'objc_protocol_requires_explicit_implementation'
2700  // protocols for now for controlled evaluation.
2701  if (PDecl->hasAttr<ObjCExplicitProtocolImplAttr>()) {
2702  if (!ProtocolsExplictImpl) {
2703  ProtocolsExplictImpl.reset(new ProtocolNameSet);
2704  findProtocolsWithExplicitImpls(Super, *ProtocolsExplictImpl);
2705  }
2706  if (ProtocolsExplictImpl->find(PDecl->getIdentifier()) !=
2707  ProtocolsExplictImpl->end())
2708  return;
2709 
2710  // If no super class conforms to the protocol, we should not search
2711  // for methods in the super class to implicitly satisfy the protocol.
2712  Super = nullptr;
2713  }
2714 
2715  if (S.getLangOpts().ObjCRuntime.isNeXTFamily()) {
2716  // check to see if class implements forwardInvocation method and objects
2717  // of this class are derived from 'NSProxy' so that to forward requests
2718  // from one object to another.
2719  // Under such conditions, which means that every method possible is
2720  // implemented in the class, we should not issue "Method definition not
2721  // found" warnings.
2722  // FIXME: Use a general GetUnarySelector method for this.
2723  IdentifierInfo* II = &S.Context.Idents.get("forwardInvocation");
2724  Selector fISelector = S.Context.Selectors.getSelector(1, &II);
2725  if (InsMap.count(fISelector))
2726  // Is IDecl derived from 'NSProxy'? If so, no instance methods
2727  // need be implemented in the implementation.
2728  NSIDecl = IDecl->lookupInheritedClass(&S.Context.Idents.get("NSProxy"));
2729  }
2730 
2731  // If this is a forward protocol declaration, get its definition.
2732  if (!PDecl->isThisDeclarationADefinition() &&
2733  PDecl->getDefinition())
2734  PDecl = PDecl->getDefinition();
2735 
2736  // If a method lookup fails locally we still need to look and see if
2737  // the method was implemented by a base class or an inherited
2738  // protocol. This lookup is slow, but occurs rarely in correct code
2739  // and otherwise would terminate in a warning.
2740 
2741  // check unimplemented instance methods.
2742  if (!NSIDecl)
2743  for (auto *method : PDecl->instance_methods()) {
2744  if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
2745  !method->isPropertyAccessor() &&
2746  !InsMap.count(method->getSelector()) &&
2747  (!Super || !Super->lookupMethod(method->getSelector(),
2748  true /* instance */,
2749  false /* shallowCategory */,
2750  true /* followsSuper */,
2751  nullptr /* category */))) {
2752  // If a method is not implemented in the category implementation but
2753  // has been declared in its primary class, superclass,
2754  // or in one of their protocols, no need to issue the warning.
2755  // This is because method will be implemented in the primary class
2756  // or one of its super class implementation.
2757 
2758  // Ugly, but necessary. Method declared in protocol might have
2759  // have been synthesized due to a property declared in the class which
2760  // uses the protocol.
2761  if (ObjCMethodDecl *MethodInClass =
2762  IDecl->lookupMethod(method->getSelector(),
2763  true /* instance */,
2764  true /* shallowCategoryLookup */,
2765  false /* followSuper */))
2766  if (C || MethodInClass->isPropertyAccessor())
2767  continue;
2768  unsigned DIAG = diag::warn_unimplemented_protocol_method;
2769  if (!S.Diags.isIgnored(DIAG, ImpLoc)) {
2770  WarnUndefinedMethod(S, ImpLoc, method, IncompleteImpl, DIAG,
2771  PDecl);
2772  }
2773  }
2774  }
2775  // check unimplemented class methods
2776  for (auto *method : PDecl->class_methods()) {
2777  if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
2778  !ClsMap.count(method->getSelector()) &&
2779  (!Super || !Super->lookupMethod(method->getSelector(),
2780  false /* class method */,
2781  false /* shallowCategoryLookup */,
2782  true /* followSuper */,
2783  nullptr /* category */))) {
2784  // See above comment for instance method lookups.
2785  if (C && IDecl->lookupMethod(method->getSelector(),
2786  false /* class */,
2787  true /* shallowCategoryLookup */,
2788  false /* followSuper */))
2789  continue;
2790 
2791  unsigned DIAG = diag::warn_unimplemented_protocol_method;
2792  if (!S.Diags.isIgnored(DIAG, ImpLoc)) {
2793  WarnUndefinedMethod(S, ImpLoc, method, IncompleteImpl, DIAG, PDecl);
2794  }
2795  }
2796  }
2797  // Check on this protocols's referenced protocols, recursively.
2798  for (auto *PI : PDecl->protocols())
2799  CheckProtocolMethodDefs(S, ImpLoc, PI, IncompleteImpl, InsMap, ClsMap,
2800  CDecl, ProtocolsExplictImpl);
2801 }
2802 
2803 /// MatchAllMethodDeclarations - Check methods declared in interface
2804 /// or protocol against those declared in their implementations.
2805 ///
2807  const SelectorSet &ClsMap,
2808  SelectorSet &InsMapSeen,
2809  SelectorSet &ClsMapSeen,
2810  ObjCImplDecl* IMPDecl,
2811  ObjCContainerDecl* CDecl,
2812  bool &IncompleteImpl,
2813  bool ImmediateClass,
2814  bool WarnCategoryMethodImpl) {
2815  // Check and see if instance methods in class interface have been
2816  // implemented in the implementation class. If so, their types match.
2817  for (auto *I : CDecl->instance_methods()) {
2818  if (!InsMapSeen.insert(I->getSelector()).second)
2819  continue;
2820  if (!I->isPropertyAccessor() &&
2821  !InsMap.count(I->getSelector())) {
2822  if (ImmediateClass)
2823  WarnUndefinedMethod(*this, IMPDecl->getLocation(), I, IncompleteImpl,
2824  diag::warn_undef_method_impl);
2825  continue;
2826  } else {
2827  ObjCMethodDecl *ImpMethodDecl =
2828  IMPDecl->getInstanceMethod(I->getSelector());
2829  assert(CDecl->getInstanceMethod(I->getSelector(), true/*AllowHidden*/) &&
2830  "Expected to find the method through lookup as well");
2831  // ImpMethodDecl may be null as in a @dynamic property.
2832  if (ImpMethodDecl) {
2833  if (!WarnCategoryMethodImpl)
2834  WarnConflictingTypedMethods(ImpMethodDecl, I,
2835  isa<ObjCProtocolDecl>(CDecl));
2836  else if (!I->isPropertyAccessor())
2837  WarnExactTypedMethods(ImpMethodDecl, I, isa<ObjCProtocolDecl>(CDecl));
2838  }
2839  }
2840  }
2841 
2842  // Check and see if class methods in class interface have been
2843  // implemented in the implementation class. If so, their types match.
2844  for (auto *I : CDecl->class_methods()) {
2845  if (!ClsMapSeen.insert(I->getSelector()).second)
2846  continue;
2847  if (!I->isPropertyAccessor() &&
2848  !ClsMap.count(I->getSelector())) {
2849  if (ImmediateClass)
2850  WarnUndefinedMethod(*this, IMPDecl->getLocation(), I, IncompleteImpl,
2851  diag::warn_undef_method_impl);
2852  } else {
2853  ObjCMethodDecl *ImpMethodDecl =
2854  IMPDecl->getClassMethod(I->getSelector());
2855  assert(CDecl->getClassMethod(I->getSelector(), true/*AllowHidden*/) &&
2856  "Expected to find the method through lookup as well");
2857  // ImpMethodDecl may be null as in a @dynamic property.
2858  if (ImpMethodDecl) {
2859  if (!WarnCategoryMethodImpl)
2860  WarnConflictingTypedMethods(ImpMethodDecl, I,
2861  isa<ObjCProtocolDecl>(CDecl));
2862  else if (!I->isPropertyAccessor())
2863  WarnExactTypedMethods(ImpMethodDecl, I, isa<ObjCProtocolDecl>(CDecl));
2864  }
2865  }
2866  }
2867 
2868  if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl> (CDecl)) {
2869  // Also, check for methods declared in protocols inherited by
2870  // this protocol.
2871  for (auto *PI : PD->protocols())
2872  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2873  IMPDecl, PI, IncompleteImpl, false,
2874  WarnCategoryMethodImpl);
2875  }
2876 
2877  if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
2878  // when checking that methods in implementation match their declaration,
2879  // i.e. when WarnCategoryMethodImpl is false, check declarations in class
2880  // extension; as well as those in categories.
2881  if (!WarnCategoryMethodImpl) {
2882  for (auto *Cat : I->visible_categories())
2883  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2884  IMPDecl, Cat, IncompleteImpl,
2885  ImmediateClass && Cat->IsClassExtension(),
2886  WarnCategoryMethodImpl);
2887  } else {
2888  // Also methods in class extensions need be looked at next.
2889  for (auto *Ext : I->visible_extensions())
2890  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2891  IMPDecl, Ext, IncompleteImpl, false,
2892  WarnCategoryMethodImpl);
2893  }
2894 
2895  // Check for any implementation of a methods declared in protocol.
2896  for (auto *PI : I->all_referenced_protocols())
2897  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2898  IMPDecl, PI, IncompleteImpl, false,
2899  WarnCategoryMethodImpl);
2900 
2901  // FIXME. For now, we are not checking for exact match of methods
2902  // in category implementation and its primary class's super class.
2903  if (!WarnCategoryMethodImpl && I->getSuperClass())
2904  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2905  IMPDecl,
2906  I->getSuperClass(), IncompleteImpl, false);
2907  }
2908 }
2909 
2910 /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
2911 /// category matches with those implemented in its primary class and
2912 /// warns each time an exact match is found.
2914  ObjCCategoryImplDecl *CatIMPDecl) {
2915  // Get category's primary class.
2916  ObjCCategoryDecl *CatDecl = CatIMPDecl->getCategoryDecl();
2917  if (!CatDecl)
2918  return;
2919  ObjCInterfaceDecl *IDecl = CatDecl->getClassInterface();
2920  if (!IDecl)
2921  return;
2922  ObjCInterfaceDecl *SuperIDecl = IDecl->getSuperClass();
2923  SelectorSet InsMap, ClsMap;
2924 
2925  for (const auto *I : CatIMPDecl->instance_methods()) {
2926  Selector Sel = I->getSelector();
2927  // When checking for methods implemented in the category, skip over
2928  // those declared in category class's super class. This is because
2929  // the super class must implement the method.
2930  if (SuperIDecl && SuperIDecl->lookupMethod(Sel, true))
2931  continue;
2932  InsMap.insert(Sel);
2933  }
2934 
2935  for (const auto *I : CatIMPDecl->class_methods()) {
2936  Selector Sel = I->getSelector();
2937  if (SuperIDecl && SuperIDecl->lookupMethod(Sel, false))
2938  continue;
2939  ClsMap.insert(Sel);
2940  }
2941  if (InsMap.empty() && ClsMap.empty())
2942  return;
2943 
2944  SelectorSet InsMapSeen, ClsMapSeen;
2945  bool IncompleteImpl = false;
2946  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2947  CatIMPDecl, IDecl,
2948  IncompleteImpl, false,
2949  true /*WarnCategoryMethodImpl*/);
2950 }
2951 
2953  ObjCContainerDecl* CDecl,
2954  bool IncompleteImpl) {
2955  SelectorSet InsMap;
2956  // Check and see if instance methods in class interface have been
2957  // implemented in the implementation class.
2958  for (const auto *I : IMPDecl->instance_methods())
2959  InsMap.insert(I->getSelector());
2960 
2961  // Add the selectors for getters/setters of @dynamic properties.
2962  for (const auto *PImpl : IMPDecl->property_impls()) {
2963  // We only care about @dynamic implementations.
2964  if (PImpl->getPropertyImplementation() != ObjCPropertyImplDecl::Dynamic)
2965  continue;
2966 
2967  const auto *P = PImpl->getPropertyDecl();
2968  if (!P) continue;
2969 
2970  InsMap.insert(P->getGetterName());
2971  if (!P->getSetterName().isNull())
2972  InsMap.insert(P->getSetterName());
2973  }
2974 
2975  // Check and see if properties declared in the interface have either 1)
2976  // an implementation or 2) there is a @synthesize/@dynamic implementation
2977  // of the property in the @implementation.
2978  if (const ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2979  bool SynthesizeProperties = LangOpts.ObjCDefaultSynthProperties &&
2981  !IDecl->isObjCRequiresPropertyDefs();
2982  DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, SynthesizeProperties);
2983  }
2984 
2985  // Diagnose null-resettable synthesized setters.
2987 
2988  SelectorSet ClsMap;
2989  for (const auto *I : IMPDecl->class_methods())
2990  ClsMap.insert(I->getSelector());
2991 
2992  // Check for type conflict of methods declared in a class/protocol and
2993  // its implementation; if any.
2994  SelectorSet InsMapSeen, ClsMapSeen;
2995  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
2996  IMPDecl, CDecl,
2997  IncompleteImpl, true);
2998 
2999  // check all methods implemented in category against those declared
3000  // in its primary class.
3001  if (ObjCCategoryImplDecl *CatDecl =
3002  dyn_cast<ObjCCategoryImplDecl>(IMPDecl))
3004 
3005  // Check the protocol list for unimplemented methods in the @implementation
3006  // class.
3007  // Check and see if class methods in class interface have been
3008  // implemented in the implementation class.
3009 
3010  LazyProtocolNameSet ExplicitImplProtocols;
3011 
3012  if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
3013  for (auto *PI : I->all_referenced_protocols())
3014  CheckProtocolMethodDefs(*this, IMPDecl->getLocation(), PI, IncompleteImpl,
3015  InsMap, ClsMap, I, ExplicitImplProtocols);
3016  } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
3017  // For extended class, unimplemented methods in its protocols will
3018  // be reported in the primary class.
3019  if (!C->IsClassExtension()) {
3020  for (auto *P : C->protocols())
3021  CheckProtocolMethodDefs(*this, IMPDecl->getLocation(), P,
3022  IncompleteImpl, InsMap, ClsMap, CDecl,
3023  ExplicitImplProtocols);
3024  DiagnoseUnimplementedProperties(S, IMPDecl, CDecl,
3025  /*SynthesizeProperties=*/false);
3026  }
3027  } else
3028  llvm_unreachable("invalid ObjCContainerDecl type.");
3029 }
3030 
3033  IdentifierInfo **IdentList,
3034  SourceLocation *IdentLocs,
3035  ArrayRef<ObjCTypeParamList *> TypeParamLists,
3036  unsigned NumElts) {
3037  SmallVector<Decl *, 8> DeclsInGroup;
3038  for (unsigned i = 0; i != NumElts; ++i) {
3039  // Check for another declaration kind with the same name.
3040  NamedDecl *PrevDecl
3041  = LookupSingleName(TUScope, IdentList[i], IdentLocs[i],
3043  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
3044  // GCC apparently allows the following idiom:
3045  //
3046  // typedef NSObject < XCElementTogglerP > XCElementToggler;
3047  // @class XCElementToggler;
3048  //
3049  // Here we have chosen to ignore the forward class declaration
3050  // with a warning. Since this is the implied behavior.
3051  TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(PrevDecl);
3052  if (!TDD || !TDD->getUnderlyingType()->isObjCObjectType()) {
3053  Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];
3054  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
3055  } else {
3056  // a forward class declaration matching a typedef name of a class refers
3057  // to the underlying class. Just ignore the forward class with a warning
3058  // as this will force the intended behavior which is to lookup the
3059  // typedef name.
3060  if (isa<ObjCObjectType>(TDD->getUnderlyingType())) {
3061  Diag(AtClassLoc, diag::warn_forward_class_redefinition)
3062  << IdentList[i];
3063  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
3064  continue;
3065  }
3066  }
3067  }
3068 
3069  // Create a declaration to describe this forward declaration.
3070  ObjCInterfaceDecl *PrevIDecl
3071  = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
3072 
3073  IdentifierInfo *ClassName = IdentList[i];
3074  if (PrevIDecl && PrevIDecl->getIdentifier() != ClassName) {
3075  // A previous decl with a different name is because of
3076  // @compatibility_alias, for example:
3077  // \code
3078  // @class NewImage;
3079  // @compatibility_alias OldImage NewImage;
3080  // \endcode
3081  // A lookup for 'OldImage' will return the 'NewImage' decl.
3082  //
3083  // In such a case use the real declaration name, instead of the alias one,
3084  // otherwise we will break IdentifierResolver and redecls-chain invariants.
3085  // FIXME: If necessary, add a bit to indicate that this ObjCInterfaceDecl
3086  // has been aliased.
3087  ClassName = PrevIDecl->getIdentifier();
3088  }
3089 
3090  // If this forward declaration has type parameters, compare them with the
3091  // type parameters of the previous declaration.
3092  ObjCTypeParamList *TypeParams = TypeParamLists[i];
3093  if (PrevIDecl && TypeParams) {
3094  if (ObjCTypeParamList *PrevTypeParams = PrevIDecl->getTypeParamList()) {
3095  // Check for consistency with the previous declaration.
3097  *this, PrevTypeParams, TypeParams,
3098  TypeParamListContext::ForwardDeclaration)) {
3099  TypeParams = nullptr;
3100  }
3101  } else if (ObjCInterfaceDecl *Def = PrevIDecl->getDefinition()) {
3102  // The @interface does not have type parameters. Complain.
3103  Diag(IdentLocs[i], diag::err_objc_parameterized_forward_class)
3104  << ClassName
3105  << TypeParams->getSourceRange();
3106  Diag(Def->getLocation(), diag::note_defined_here)
3107  << ClassName;
3108 
3109  TypeParams = nullptr;
3110  }
3111  }
3112 
3113  ObjCInterfaceDecl *IDecl
3115  ClassName, TypeParams, PrevIDecl,
3116  IdentLocs[i]);
3117  IDecl->setAtEndRange(IdentLocs[i]);
3118 
3119  PushOnScopeChains(IDecl, TUScope);
3120  CheckObjCDeclScope(IDecl);
3121  DeclsInGroup.push_back(IDecl);
3122  }
3123 
3124  return BuildDeclaratorGroup(DeclsInGroup);
3125 }
3126 
3128  Sema::MethodMatchStrategy strategy,
3129  const Type *left, const Type *right);
3130 
3131 static bool matchTypes(ASTContext &Context, Sema::MethodMatchStrategy strategy,
3132  QualType leftQT, QualType rightQT) {
3133  const Type *left =
3134  Context.getCanonicalType(leftQT).getUnqualifiedType().getTypePtr();
3135  const Type *right =
3136  Context.getCanonicalType(rightQT).getUnqualifiedType().getTypePtr();
3137 
3138  if (left == right) return true;
3139 
3140  // If we're doing a strict match, the types have to match exactly.
3141  if (strategy == Sema::MMS_strict) return false;
3142 
3143  if (left->isIncompleteType() || right->isIncompleteType()) return false;
3144 
3145  // Otherwise, use this absurdly complicated algorithm to try to
3146  // validate the basic, low-level compatibility of the two types.
3147 
3148  // As a minimum, require the sizes and alignments to match.
3149  TypeInfo LeftTI = Context.getTypeInfo(left);
3150  TypeInfo RightTI = Context.getTypeInfo(right);
3151  if (LeftTI.Width != RightTI.Width)
3152  return false;
3153 
3154  if (LeftTI.Align != RightTI.Align)
3155  return false;
3156 
3157  // Consider all the kinds of non-dependent canonical types:
3158  // - functions and arrays aren't possible as return and parameter types
3159 
3160  // - vector types of equal size can be arbitrarily mixed
3161  if (isa<VectorType>(left)) return isa<VectorType>(right);
3162  if (isa<VectorType>(right)) return false;
3163 
3164  // - references should only match references of identical type
3165  // - structs, unions, and Objective-C objects must match more-or-less
3166  // exactly
3167  // - everything else should be a scalar
3168  if (!left->isScalarType() || !right->isScalarType())
3169  return tryMatchRecordTypes(Context, strategy, left, right);
3170 
3171  // Make scalars agree in kind, except count bools as chars, and group
3172  // all non-member pointers together.
3173  Type::ScalarTypeKind leftSK = left->getScalarTypeKind();
3174  Type::ScalarTypeKind rightSK = right->getScalarTypeKind();
3175  if (leftSK == Type::STK_Bool) leftSK = Type::STK_Integral;
3176  if (rightSK == Type::STK_Bool) rightSK = Type::STK_Integral;
3177  if (leftSK == Type::STK_CPointer || leftSK == Type::STK_BlockPointer)
3178  leftSK = Type::STK_ObjCObjectPointer;
3179  if (rightSK == Type::STK_CPointer || rightSK == Type::STK_BlockPointer)
3180  rightSK = Type::STK_ObjCObjectPointer;
3181 
3182  // Note that data member pointers and function member pointers don't
3183  // intermix because of the size differences.
3184 
3185  return (leftSK == rightSK);
3186 }
3187 
3188 static bool tryMatchRecordTypes(ASTContext &Context,
3189  Sema::MethodMatchStrategy strategy,
3190  const Type *lt, const Type *rt) {
3191  assert(lt && rt && lt != rt);
3192 
3193  if (!isa<RecordType>(lt) || !isa<RecordType>(rt)) return false;
3194  RecordDecl *left = cast<RecordType>(lt)->getDecl();
3195  RecordDecl *right = cast<RecordType>(rt)->getDecl();
3196 
3197  // Require union-hood to match.
3198  if (left->isUnion() != right->isUnion()) return false;
3199 
3200  // Require an exact match if either is non-POD.
3201  if ((isa<CXXRecordDecl>(left) && !cast<CXXRecordDecl>(left)->isPOD()) ||
3202  (isa<CXXRecordDecl>(right) && !cast<CXXRecordDecl>(right)->isPOD()))
3203  return false;
3204 
3205  // Require size and alignment to match.
3206  TypeInfo LeftTI = Context.getTypeInfo(lt);
3207  TypeInfo RightTI = Context.getTypeInfo(rt);
3208  if (LeftTI.Width != RightTI.Width)
3209  return false;
3210 
3211  if (LeftTI.Align != RightTI.Align)
3212  return false;
3213 
3214  // Require fields to match.
3215  RecordDecl::field_iterator li = left->field_begin(), le = left->field_end();
3216  RecordDecl::field_iterator ri = right->field_begin(), re = right->field_end();
3217  for (; li != le && ri != re; ++li, ++ri) {
3218  if (!matchTypes(Context, strategy, li->getType(), ri->getType()))
3219  return false;
3220  }
3221  return (li == le && ri == re);
3222 }
3223 
3224 /// MatchTwoMethodDeclarations - Checks that two methods have matching type and
3225 /// returns true, or false, accordingly.
3226 /// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
3228  const ObjCMethodDecl *right,
3229  MethodMatchStrategy strategy) {
3230  if (!matchTypes(Context, strategy, left->getReturnType(),
3231  right->getReturnType()))
3232  return false;
3233 
3234  // If either is hidden, it is not considered to match.
3235  if (left->isHidden() || right->isHidden())
3236  return false;
3237 
3238  if (getLangOpts().ObjCAutoRefCount &&
3239  (left->hasAttr<NSReturnsRetainedAttr>()
3240  != right->hasAttr<NSReturnsRetainedAttr>() ||
3241  left->hasAttr<NSConsumesSelfAttr>()
3242  != right->hasAttr<NSConsumesSelfAttr>()))
3243  return false;
3244 
3246  li = left->param_begin(), le = left->param_end(), ri = right->param_begin(),
3247  re = right->param_end();
3248 
3249  for (; li != le && ri != re; ++li, ++ri) {
3250  assert(ri != right->param_end() && "Param mismatch");
3251  const ParmVarDecl *lparm = *li, *rparm = *ri;
3252 
3253  if (!matchTypes(Context, strategy, lparm->getType(), rparm->getType()))
3254  return false;
3255 
3256  if (getLangOpts().ObjCAutoRefCount &&
3257  lparm->hasAttr<NSConsumedAttr>() != rparm->hasAttr<NSConsumedAttr>())
3258  return false;
3259  }
3260  return true;
3261 }
3262 
3264  ObjCMethodDecl *MethodInList) {
3265  auto *MethodProtocol = dyn_cast<ObjCProtocolDecl>(Method->getDeclContext());
3266  auto *MethodInListProtocol =
3267  dyn_cast<ObjCProtocolDecl>(MethodInList->getDeclContext());
3268  // If this method belongs to a protocol but the method in list does not, or
3269  // vice versa, we say the context is not the same.
3270  if ((MethodProtocol && !MethodInListProtocol) ||
3271  (!MethodProtocol && MethodInListProtocol))
3272  return false;
3273 
3274  if (MethodProtocol && MethodInListProtocol)
3275  return true;
3276 
3277  ObjCInterfaceDecl *MethodInterface = Method->getClassInterface();
3278  ObjCInterfaceDecl *MethodInListInterface =
3279  MethodInList->getClassInterface();
3280  return MethodInterface == MethodInListInterface;
3281 }
3282 
3284  ObjCMethodDecl *Method) {
3285  // Record at the head of the list whether there were 0, 1, or >= 2 methods
3286  // inside categories.
3287  if (ObjCCategoryDecl *CD =
3288  dyn_cast<ObjCCategoryDecl>(Method->getDeclContext()))
3289  if (!CD->IsClassExtension() && List->getBits() < 2)
3290  List->setBits(List->getBits() + 1);
3291 
3292  // If the list is empty, make it a singleton list.
3293  if (List->getMethod() == nullptr) {
3294  List->setMethod(Method);
3295  List->setNext(nullptr);
3296  return;
3297  }
3298 
3299  // We've seen a method with this name, see if we have already seen this type
3300  // signature.
3301  ObjCMethodList *Previous = List;
3302  ObjCMethodList *ListWithSameDeclaration = nullptr;
3303  for (; List; Previous = List, List = List->getNext()) {
3304  // If we are building a module, keep all of the methods.
3306  continue;
3307 
3308  bool SameDeclaration = MatchTwoMethodDeclarations(Method,
3309  List->getMethod());
3310  // Looking for method with a type bound requires the correct context exists.
3311  // We need to insert a method into the list if the context is different.
3312  // If the method's declaration matches the list
3313  // a> the method belongs to a different context: we need to insert it, in
3314  // order to emit the availability message, we need to prioritize over
3315  // availability among the methods with the same declaration.
3316  // b> the method belongs to the same context: there is no need to insert a
3317  // new entry.
3318  // If the method's declaration does not match the list, we insert it to the
3319  // end.
3320  if (!SameDeclaration ||
3321  !isMethodContextSameForKindofLookup(Method, List->getMethod())) {
3322  // Even if two method types do not match, we would like to say
3323  // there is more than one declaration so unavailability/deprecated
3324  // warning is not too noisy.
3325  if (!Method->isDefined())
3326  List->setHasMoreThanOneDecl(true);
3327 
3328  // For methods with the same declaration, the one that is deprecated
3329  // should be put in the front for better diagnostics.
3330  if (Method->isDeprecated() && SameDeclaration &&
3331  !ListWithSameDeclaration && !List->getMethod()->isDeprecated())
3332  ListWithSameDeclaration = List;
3333 
3334  if (Method->isUnavailable() && SameDeclaration &&
3335  !ListWithSameDeclaration &&
3337  ListWithSameDeclaration = List;
3338  continue;
3339  }
3340 
3341  ObjCMethodDecl *PrevObjCMethod = List->getMethod();
3342 
3343  // Propagate the 'defined' bit.
3344  if (Method->isDefined())
3345  PrevObjCMethod->setDefined(true);
3346  else {
3347  // Objective-C doesn't allow an @interface for a class after its
3348  // @implementation. So if Method is not defined and there already is
3349  // an entry for this type signature, Method has to be for a different
3350  // class than PrevObjCMethod.
3351  List->setHasMoreThanOneDecl(true);
3352  }
3353 
3354  // If a method is deprecated, push it in the global pool.
3355  // This is used for better diagnostics.
3356  if (Method->isDeprecated()) {
3357  if (!PrevObjCMethod->isDeprecated())
3358  List->setMethod(Method);
3359  }
3360  // If the new method is unavailable, push it into global pool
3361  // unless previous one is deprecated.
3362  if (Method->isUnavailable()) {
3363  if (PrevObjCMethod->getAvailability() < AR_Deprecated)
3364  List->setMethod(Method);
3365  }
3366 
3367  return;
3368  }
3369 
3370  // We have a new signature for an existing method - add it.
3371  // This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
3372  ObjCMethodList *Mem = BumpAlloc.Allocate<ObjCMethodList>();
3373 
3374  // We insert it right before ListWithSameDeclaration.
3375  if (ListWithSameDeclaration) {
3376  auto *List = new (Mem) ObjCMethodList(*ListWithSameDeclaration);
3377  // FIXME: should we clear the other bits in ListWithSameDeclaration?
3378  ListWithSameDeclaration->setMethod(Method);
3379  ListWithSameDeclaration->setNext(List);
3380  return;
3381  }
3382 
3383  Previous->setNext(new (Mem) ObjCMethodList(Method));
3384 }
3385 
3386 /// Read the contents of the method pool for a given selector from
3387 /// external storage.
3389  assert(ExternalSource && "We need an external AST source");
3390  ExternalSource->ReadMethodPool(Sel);
3391 }
3392 
3394  if (!ExternalSource)
3395  return;
3396  ExternalSource->updateOutOfDateSelector(Sel);
3397 }
3398 
3399 void Sema::AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl,
3400  bool instance) {
3401  // Ignore methods of invalid containers.
3402  if (cast<Decl>(Method->getDeclContext())->isInvalidDecl())
3403  return;
3404 
3405  if (ExternalSource)
3406  ReadMethodPool(Method->getSelector());
3407 
3408  GlobalMethodPool::iterator Pos = MethodPool.find(Method->getSelector());
3409  if (Pos == MethodPool.end())
3410  Pos = MethodPool.insert(std::make_pair(Method->getSelector(),
3411  GlobalMethods())).first;
3412 
3413  Method->setDefined(impl);
3414 
3415  ObjCMethodList &Entry = instance ? Pos->second.first : Pos->second.second;
3416  addMethodToGlobalList(&Entry, Method);
3417 }
3418 
3419 /// Determines if this is an "acceptable" loose mismatch in the global
3420 /// method pool. This exists mostly as a hack to get around certain
3421 /// global mismatches which we can't afford to make warnings / errors.
3422 /// Really, what we want is a way to take a method out of the global
3423 /// method pool.
3425  ObjCMethodDecl *other) {
3426  if (!chosen->isInstanceMethod())
3427  return false;
3428 
3429  Selector sel = chosen->getSelector();
3430  if (!sel.isUnarySelector() || sel.getNameForSlot(0) != "length")
3431  return false;
3432 
3433  // Don't complain about mismatches for -length if the method we
3434  // chose has an integral result type.
3435  return (chosen->getReturnType()->isIntegerType());
3436 }
3437 
3438 /// Return true if the given method is wthin the type bound.
3440  const ObjCObjectType *TypeBound) {
3441  if (!TypeBound)
3442  return true;
3443 
3444  if (TypeBound->isObjCId())
3445  // FIXME: should we handle the case of bounding to id<A, B> differently?
3446  return true;
3447 
3448  auto *BoundInterface = TypeBound->getInterface();
3449  assert(BoundInterface && "unexpected object type!");
3450 
3451  // Check if the Method belongs to a protocol. We should allow any method
3452  // defined in any protocol, because any subclass could adopt the protocol.
3453  auto *MethodProtocol = dyn_cast<ObjCProtocolDecl>(Method->getDeclContext());
3454  if (MethodProtocol) {
3455  return true;
3456  }
3457 
3458  // If the Method belongs to a class, check if it belongs to the class
3459  // hierarchy of the class bound.
3460  if (ObjCInterfaceDecl *MethodInterface = Method->getClassInterface()) {
3461  // We allow methods declared within classes that are part of the hierarchy
3462  // of the class bound (superclass of, subclass of, or the same as the class
3463  // bound).
3464  return MethodInterface == BoundInterface ||
3465  MethodInterface->isSuperClassOf(BoundInterface) ||
3466  BoundInterface->isSuperClassOf(MethodInterface);
3467  }
3468  llvm_unreachable("unknown method context");
3469 }
3470 
3471 /// We first select the type of the method: Instance or Factory, then collect
3472 /// all methods with that type.
3475  bool InstanceFirst, bool CheckTheOther,
3476  const ObjCObjectType *TypeBound) {
3477  if (ExternalSource)
3478  ReadMethodPool(Sel);
3479 
3480  GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
3481  if (Pos == MethodPool.end())
3482  return false;
3483 
3484  // Gather the non-hidden methods.
3485  ObjCMethodList &MethList = InstanceFirst ? Pos->second.first :
3486  Pos->second.second;
3487  for (ObjCMethodList *M = &MethList; M; M = M->getNext())
3488  if (M->getMethod() && !M->getMethod()->isHidden()) {
3489  if (FilterMethodsByTypeBound(M->getMethod(), TypeBound))
3490  Methods.push_back(M->getMethod());
3491  }
3492 
3493  // Return if we find any method with the desired kind.
3494  if (!Methods.empty())
3495  return Methods.size() > 1;
3496 
3497  if (!CheckTheOther)
3498  return false;
3499 
3500  // Gather the other kind.
3501  ObjCMethodList &MethList2 = InstanceFirst ? Pos->second.second :
3502  Pos->second.first;
3503  for (ObjCMethodList *M = &MethList2; M; M = M->getNext())
3504  if (M->getMethod() && !M->getMethod()->isHidden()) {
3505  if (FilterMethodsByTypeBound(M->getMethod(), TypeBound))
3506  Methods.push_back(M->getMethod());
3507  }
3508 
3509  return Methods.size() > 1;
3510 }
3511 
3513  Selector Sel, ObjCMethodDecl *BestMethod, SourceRange R,
3514  bool receiverIdOrClass, SmallVectorImpl<ObjCMethodDecl *> &Methods) {
3515  // Diagnose finding more than one method in global pool.
3516  SmallVector<ObjCMethodDecl *, 4> FilteredMethods;
3517  FilteredMethods.push_back(BestMethod);
3518 
3519  for (auto *M : Methods)
3520  if (M != BestMethod && !M->hasAttr<UnavailableAttr>())
3521  FilteredMethods.push_back(M);
3522 
3523  if (FilteredMethods.size() > 1)
3524  DiagnoseMultipleMethodInGlobalPool(FilteredMethods, Sel, R,
3525  receiverIdOrClass);
3526 
3527  GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
3528  // Test for no method in the pool which should not trigger any warning by
3529  // caller.
3530  if (Pos == MethodPool.end())
3531  return true;
3532  ObjCMethodList &MethList =
3533  BestMethod->isInstanceMethod() ? Pos->second.first : Pos->second.second;
3534  return MethList.hasMoreThanOneDecl();
3535 }
3536 
3537 ObjCMethodDecl *Sema::LookupMethodInGlobalPool(Selector Sel, SourceRange R,
3538  bool receiverIdOrClass,
3539  bool instance) {
3540  if (ExternalSource)
3541  ReadMethodPool(Sel);
3542 
3543  GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
3544  if (Pos == MethodPool.end())
3545  return nullptr;
3546 
3547  // Gather the non-hidden methods.
3548  ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
3550  for (ObjCMethodList *M = &MethList; M; M = M->getNext()) {
3551  if (M->getMethod() && !M->getMethod()->isHidden())
3552  return M->getMethod();
3553  }
3554  return nullptr;
3555 }
3556 
3558  Selector Sel, SourceRange R,
3559  bool receiverIdOrClass) {
3560  // We found multiple methods, so we may have to complain.
3561  bool issueDiagnostic = false, issueError = false;
3562 
3563  // We support a warning which complains about *any* difference in
3564  // method signature.
3565  bool strictSelectorMatch =
3566  receiverIdOrClass &&
3567  !Diags.isIgnored(diag::warn_strict_multiple_method_decl, R.getBegin());
3568  if (strictSelectorMatch) {
3569  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
3570  if (!MatchTwoMethodDeclarations(Methods[0], Methods[I], MMS_strict)) {
3571  issueDiagnostic = true;
3572  break;
3573  }
3574  }
3575  }
3576 
3577  // If we didn't see any strict differences, we won't see any loose
3578  // differences. In ARC, however, we also need to check for loose
3579  // mismatches, because most of them are errors.
3580  if (!strictSelectorMatch ||
3581  (issueDiagnostic && getLangOpts().ObjCAutoRefCount))
3582  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
3583  // This checks if the methods differ in type mismatch.
3584  if (!MatchTwoMethodDeclarations(Methods[0], Methods[I], MMS_loose) &&
3585  !isAcceptableMethodMismatch(Methods[0], Methods[I])) {
3586  issueDiagnostic = true;
3587  if (getLangOpts().ObjCAutoRefCount)
3588  issueError = true;
3589  break;
3590  }
3591  }
3592 
3593  if (issueDiagnostic) {
3594  if (issueError)
3595  Diag(R.getBegin(), diag::err_arc_multiple_method_decl) << Sel << R;
3596  else if (strictSelectorMatch)
3597  Diag(R.getBegin(), diag::warn_strict_multiple_method_decl) << Sel << R;
3598  else
3599  Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R;
3600 
3601  Diag(Methods[0]->getBeginLoc(),
3602  issueError ? diag::note_possibility : diag::note_using)
3603  << Methods[0]->getSourceRange();
3604  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
3605  Diag(Methods[I]->getBeginLoc(), diag::note_also_found)
3606  << Methods[I]->getSourceRange();
3607  }
3608  }
3609 }
3610 
3612  GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
3613  if (Pos == MethodPool.end())
3614  return nullptr;
3615 
3616  GlobalMethods &Methods = Pos->second;
3617  for (const ObjCMethodList *Method = &Methods.first; Method;
3618  Method = Method->getNext())
3619  if (Method->getMethod() &&
3620  (Method->getMethod()->isDefined() ||
3621  Method->getMethod()->isPropertyAccessor()))
3622  return Method->getMethod();
3623 
3624  for (const ObjCMethodList *Method = &Methods.second; Method;
3625  Method = Method->getNext())
3626  if (Method->getMethod() &&
3627  (Method->getMethod()->isDefined() ||
3628  Method->getMethod()->isPropertyAccessor()))
3629  return Method->getMethod();
3630  return nullptr;
3631 }
3632 
3633 static void
3636  StringRef Typo, const ObjCMethodDecl * Method) {
3637  const unsigned MaxEditDistance = 1;
3638  unsigned BestEditDistance = MaxEditDistance + 1;
3639  std::string MethodName = Method->getSelector().getAsString();
3640 
3641  unsigned MinPossibleEditDistance = abs((int)MethodName.size() - (int)Typo.size());
3642  if (MinPossibleEditDistance > 0 &&
3643  Typo.size() / MinPossibleEditDistance < 1)
3644  return;
3645  unsigned EditDistance = Typo.edit_distance(MethodName, true, MaxEditDistance);
3646  if (EditDistance > MaxEditDistance)
3647  return;
3648  if (EditDistance == BestEditDistance)
3649  BestMethod.push_back(Method);
3650  else if (EditDistance < BestEditDistance) {
3651  BestMethod.clear();
3652  BestMethod.push_back(Method);
3653  }
3654 }
3655 
3657  QualType ObjectType) {
3658  if (ObjectType.isNull())
3659  return true;
3660  if (S.LookupMethodInObjectType(Sel, ObjectType, true/*Instance method*/))
3661  return true;
3662  return S.LookupMethodInObjectType(Sel, ObjectType, false/*Class method*/) !=
3663  nullptr;
3664 }
3665 
3666 const ObjCMethodDecl *
3668  QualType ObjectType) {
3669  unsigned NumArgs = Sel.getNumArgs();
3671  bool ObjectIsId = true, ObjectIsClass = true;
3672  if (ObjectType.isNull())
3673  ObjectIsId = ObjectIsClass = false;
3674  else if (!ObjectType->isObjCObjectPointerType())
3675  return nullptr;
3676  else if (const ObjCObjectPointerType *ObjCPtr =
3677  ObjectType->getAsObjCInterfacePointerType()) {
3678  ObjectType = QualType(ObjCPtr->getInterfaceType(), 0);
3679  ObjectIsId = ObjectIsClass = false;
3680  }
3681  else if (ObjectType->isObjCIdType() || ObjectType->isObjCQualifiedIdType())
3682  ObjectIsClass = false;
3683  else if (ObjectType->isObjCClassType() || ObjectType->isObjCQualifiedClassType())
3684  ObjectIsId = false;
3685  else
3686  return nullptr;
3687 
3688  for (GlobalMethodPool::iterator b = MethodPool.begin(),
3689  e = MethodPool.end(); b != e; b++) {
3690  // instance methods
3691  for (ObjCMethodList *M = &b->second.first; M; M=M->getNext())
3692  if (M->getMethod() &&
3693  (M->getMethod()->getSelector().getNumArgs() == NumArgs) &&
3694  (M->getMethod()->getSelector() != Sel)) {
3695  if (ObjectIsId)
3696  Methods.push_back(M->getMethod());
3697  else if (!ObjectIsClass &&
3698  HelperIsMethodInObjCType(*this, M->getMethod()->getSelector(),
3699  ObjectType))
3700  Methods.push_back(M->getMethod());
3701  }
3702  // class methods
3703  for (ObjCMethodList *M = &b->second.second; M; M=M->getNext())
3704  if (M->getMethod() &&
3705  (M->getMethod()->getSelector().getNumArgs() == NumArgs) &&
3706  (M->getMethod()->getSelector() != Sel)) {
3707  if (ObjectIsClass)
3708  Methods.push_back(M->getMethod());
3709  else if (!ObjectIsId &&
3710  HelperIsMethodInObjCType(*this, M->getMethod()->getSelector(),
3711  ObjectType))
3712  Methods.push_back(M->getMethod());
3713  }
3714  }
3715 
3717  for (unsigned i = 0, e = Methods.size(); i < e; i++) {
3718  HelperSelectorsForTypoCorrection(SelectedMethods,
3719  Sel.getAsString(), Methods[i]);
3720  }
3721  return (SelectedMethods.size() == 1) ? SelectedMethods[0] : nullptr;
3722 }
3723 
3724 /// DiagnoseDuplicateIvars -
3725 /// Check for duplicate ivars in the entire class at the start of
3726 /// \@implementation. This becomes necesssary because class extension can
3727 /// add ivars to a class in random order which will not be known until
3728 /// class's \@implementation is seen.
3730  ObjCInterfaceDecl *SID) {
3731  for (auto *Ivar : ID->ivars()) {
3732  if (Ivar->isInvalidDecl())
3733  continue;
3734  if (IdentifierInfo *II = Ivar->getIdentifier()) {
3735  ObjCIvarDecl* prevIvar = SID->lookupInstanceVariable(II);
3736  if (prevIvar) {
3737  Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
3738  Diag(prevIvar->getLocation(), diag::note_previous_declaration);
3739  Ivar->setInvalidDecl();
3740  }
3741  }
3742  }
3743 }
3744 
3745 /// Diagnose attempts to define ARC-__weak ivars when __weak is disabled.
3747  if (S.getLangOpts().ObjCWeak) return;
3748 
3749  for (auto ivar = ID->getClassInterface()->all_declared_ivar_begin();
3750  ivar; ivar = ivar->getNextIvar()) {
3751  if (ivar->isInvalidDecl()) continue;
3752  if (ivar->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
3753  if (S.getLangOpts().ObjCWeakRuntime) {
3754  S.Diag(ivar->getLocation(), diag::err_arc_weak_disabled);
3755  } else {
3756  S.Diag(ivar->getLocation(), diag::err_arc_weak_no_runtime);
3757  }
3758  }
3759  }
3760 }
3761 
3762 /// Diagnose attempts to use flexible array member with retainable object type.
3764  ObjCInterfaceDecl *ID) {
3765  if (!S.getLangOpts().ObjCAutoRefCount)
3766  return;
3767 
3768  for (auto ivar = ID->all_declared_ivar_begin(); ivar;
3769  ivar = ivar->getNextIvar()) {
3770  if (ivar->isInvalidDecl())
3771  continue;
3772  QualType IvarTy = ivar->getType();
3773  if (IvarTy->isIncompleteArrayType() &&
3775  IvarTy->isObjCLifetimeType()) {
3776  S.Diag(ivar->getLocation(), diag::err_flexible_array_arc_retainable);
3777  ivar->setInvalidDecl();
3778  }
3779  }
3780 }
3781 
3783  switch (CurContext->getDeclKind()) {
3784  case Decl::ObjCInterface:
3785  return Sema::OCK_Interface;
3786  case Decl::ObjCProtocol:
3787  return Sema::OCK_Protocol;
3788  case Decl::ObjCCategory:
3789  if (cast<ObjCCategoryDecl>(CurContext)->IsClassExtension())
3790  return Sema::OCK_ClassExtension;
3791  return Sema::OCK_Category;
3792  case Decl::ObjCImplementation:
3793  return Sema::OCK_Implementation;
3794  case Decl::ObjCCategoryImpl:
3796 
3797  default:
3798  return Sema::OCK_None;
3799  }
3800 }
3801 
3803  if (T->isIncompleteArrayType())
3804  return true;
3805  const auto *RecordTy = T->getAs<RecordType>();
3806  return (RecordTy && RecordTy->getDecl()->hasFlexibleArrayMember());
3807 }
3808 
3810  ObjCInterfaceDecl *IntfDecl = nullptr;
3811  ObjCInterfaceDecl::ivar_range Ivars = llvm::make_range(
3813  if ((IntfDecl = dyn_cast<ObjCInterfaceDecl>(OCD))) {
3814  Ivars = IntfDecl->ivars();
3815  } else if (auto *ImplDecl = dyn_cast<ObjCImplementationDecl>(OCD)) {
3816  IntfDecl = ImplDecl->getClassInterface();
3817  Ivars = ImplDecl->ivars();
3818  } else if (auto *CategoryDecl = dyn_cast<ObjCCategoryDecl>(OCD)) {
3819  if (CategoryDecl->IsClassExtension()) {
3820  IntfDecl = CategoryDecl->getClassInterface();
3821  Ivars = CategoryDecl->ivars();
3822  }
3823  }
3824 
3825  // Check if variable sized ivar is in interface and visible to subclasses.
3826  if (!isa<ObjCInterfaceDecl>(OCD)) {
3827  for (auto ivar : Ivars) {
3828  if (!ivar->isInvalidDecl() && IsVariableSizedType(ivar->getType())) {
3829  S.Diag(ivar->getLocation(), diag::warn_variable_sized_ivar_visibility)
3830  << ivar->getDeclName() << ivar->getType();
3831  }
3832  }
3833  }
3834 
3835  // Subsequent checks require interface decl.
3836  if (!IntfDecl)
3837  return;
3838 
3839  // Check if variable sized ivar is followed by another ivar.
3840  for (ObjCIvarDecl *ivar = IntfDecl->all_declared_ivar_begin(); ivar;
3841  ivar = ivar->getNextIvar()) {
3842  if (ivar->isInvalidDecl() || !ivar->getNextIvar())
3843  continue;
3844  QualType IvarTy = ivar->getType();
3845  bool IsInvalidIvar = false;
3846  if (IvarTy->isIncompleteArrayType()) {
3847  S.Diag(ivar->getLocation(), diag::err_flexible_array_not_at_end)
3848  << ivar->getDeclName() << IvarTy
3849  << TTK_Class; // Use "class" for Obj-C.
3850  IsInvalidIvar = true;
3851  } else if (const RecordType *RecordTy = IvarTy->getAs<RecordType>()) {
3852  if (RecordTy->getDecl()->hasFlexibleArrayMember()) {
3853  S.Diag(ivar->getLocation(),
3854  diag::err_objc_variable_sized_type_not_at_end)
3855  << ivar->getDeclName() << IvarTy;
3856  IsInvalidIvar = true;
3857  }
3858  }
3859  if (IsInvalidIvar) {
3860  S.Diag(ivar->getNextIvar()->getLocation(),
3861  diag::note_next_ivar_declaration)
3862  << ivar->getNextIvar()->getSynthesize();
3863  ivar->setInvalidDecl();
3864  }
3865  }
3866 
3867  // Check if ObjC container adds ivars after variable sized ivar in superclass.
3868  // Perform the check only if OCD is the first container to declare ivars to
3869  // avoid multiple warnings for the same ivar.
3870  ObjCIvarDecl *FirstIvar =
3871  (Ivars.begin() == Ivars.end()) ? nullptr : *Ivars.begin();
3872  if (FirstIvar && (FirstIvar == IntfDecl->all_declared_ivar_begin())) {
3873  const ObjCInterfaceDecl *SuperClass = IntfDecl->getSuperClass();
3874  while (SuperClass && SuperClass->ivar_empty())
3875  SuperClass = SuperClass->getSuperClass();
3876  if (SuperClass) {
3877  auto IvarIter = SuperClass->ivar_begin();
3878  std::advance(IvarIter, SuperClass->ivar_size() - 1);
3879  const ObjCIvarDecl *LastIvar = *IvarIter;
3880  if (IsVariableSizedType(LastIvar->getType())) {
3881  S.Diag(FirstIvar->getLocation(),
3882  diag::warn_superclass_variable_sized_type_not_at_end)
3883  << FirstIvar->getDeclName() << LastIvar->getDeclName()
3884  << LastIvar->getType() << SuperClass->getDeclName();
3885  S.Diag(LastIvar->getLocation(), diag::note_entity_declared_at)
3886  << LastIvar->getDeclName();
3887  }
3888  }
3889  }
3890 }
3891 
3892 // Note: For class/category implementations, allMethods is always null.
3894  ArrayRef<DeclGroupPtrTy> allTUVars) {
3896  return nullptr;
3897 
3898  assert(AtEnd.isValid() && "Invalid location for '@end'");
3899 
3900  auto *OCD = cast<ObjCContainerDecl>(CurContext);
3901  Decl *ClassDecl = OCD;
3902 
3903  bool isInterfaceDeclKind =
3904  isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
3905  || isa<ObjCProtocolDecl>(ClassDecl);
3906  bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
3907 
3908  // FIXME: Remove these and use the ObjCContainerDecl/DeclContext.
3909  llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
3910  llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
3911 
3912  for (unsigned i = 0, e = allMethods.size(); i != e; i++ ) {
3913  ObjCMethodDecl *Method =
3914  cast_or_null<ObjCMethodDecl>(allMethods[i]);
3915 
3916  if (!Method) continue; // Already issued a diagnostic.
3917  if (Method->isInstanceMethod()) {
3918  /// Check for instance method of the same name with incompatible types
3919  const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()];
3920  bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
3921  : false;
3922  if ((isInterfaceDeclKind && PrevMethod && !match)
3923  || (checkIdenticalMethods && match)) {
3924  Diag(Method->getLocation(), diag::err_duplicate_method_decl)
3925  << Method->getDeclName();
3926  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
3927  Method->setInvalidDecl();
3928  } else {
3929  if (PrevMethod) {
3930  Method->setAsRedeclaration(PrevMethod);
3931  if (!Context.getSourceManager().isInSystemHeader(
3932  Method->getLocation()))
3933  Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
3934  << Method->getDeclName();
3935  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
3936  }
3937  InsMap[Method->getSelector()] = Method;
3938  /// The following allows us to typecheck messages to "id".
3940  }
3941  } else {
3942  /// Check for class method of the same name with incompatible types
3943  const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()];
3944  bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
3945  : false;
3946  if ((isInterfaceDeclKind && PrevMethod && !match)
3947  || (checkIdenticalMethods && match)) {
3948  Diag(Method->getLocation(), diag::err_duplicate_method_decl)
3949  << Method->getDeclName();
3950  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
3951  Method->setInvalidDecl();
3952  } else {
3953  if (PrevMethod) {
3954  Method->setAsRedeclaration(PrevMethod);
3955  if (!Context.getSourceManager().isInSystemHeader(
3956  Method->getLocation()))
3957  Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
3958  << Method->getDeclName();
3959  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
3960  }
3961  ClsMap[Method->getSelector()] = Method;
3963  }
3964  }
3965  }
3966  if (isa<ObjCInterfaceDecl>(ClassDecl)) {
3967  // Nothing to do here.
3968  } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
3969  // Categories are used to extend the class by declaring new methods.
3970  // By the same token, they are also used to add new properties. No
3971  // need to compare the added property to those in the class.
3972 
3973  if (C->IsClassExtension()) {
3974  ObjCInterfaceDecl *CCPrimary = C->getClassInterface();
3975  DiagnoseClassExtensionDupMethods(C, CCPrimary);
3976  }
3977  }
3978  if (ObjCContainerDecl *CDecl = dyn_cast<ObjCContainerDecl>(ClassDecl)) {
3979  if (CDecl->getIdentifier())
3980  // ProcessPropertyDecl is responsible for diagnosing conflicts with any
3981  // user-defined setter/getter. It also synthesizes setter/getter methods
3982  // and adds them to the DeclContext and global method pools.
3983  for (auto *I : CDecl->properties())
3985  CDecl->setAtEndRange(AtEnd);
3986  }
3987  if (ObjCImplementationDecl *IC=dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
3988  IC->setAtEndRange(AtEnd);
3989  if (ObjCInterfaceDecl* IDecl = IC->getClassInterface()) {
3990  // Any property declared in a class extension might have user
3991  // declared setter or getter in current class extension or one
3992  // of the other class extensions. Mark them as synthesized as
3993  // property will be synthesized when property with same name is
3994  // seen in the @implementation.
3995  for (const auto *Ext : IDecl->visible_extensions()) {
3996  for (const auto *Property : Ext->instance_properties()) {
3997  // Skip over properties declared @dynamic
3998  if (const ObjCPropertyImplDecl *PIDecl
3999  = IC->FindPropertyImplDecl(Property->getIdentifier(),
4000  Property->getQueryKind()))
4001  if (PIDecl->getPropertyImplementation()
4003  continue;
4004 
4005  for (const auto *Ext : IDecl->visible_extensions()) {
4006  if (ObjCMethodDecl *GetterMethod
4007  = Ext->getInstanceMethod(Property->getGetterName()))
4008  GetterMethod->setPropertyAccessor(true);
4009  if (!Property->isReadOnly())
4010  if (ObjCMethodDecl *SetterMethod
4011  = Ext->getInstanceMethod(Property->getSetterName()))
4012  SetterMethod->setPropertyAccessor(true);
4013  }
4014  }
4015  }
4016  ImplMethodsVsClassMethods(S, IC, IDecl);
4020  if (IDecl->hasDesignatedInitializers())
4022  DiagnoseWeakIvars(*this, IC);
4024 
4025  bool HasRootClassAttr = IDecl->hasAttr<ObjCRootClassAttr>();
4026  if (IDecl->getSuperClass() == nullptr) {
4027  // This class has no superclass, so check that it has been marked with
4028  // __attribute((objc_root_class)).
4029  if (!HasRootClassAttr) {
4030  SourceLocation DeclLoc(IDecl->getLocation());
4031  SourceLocation SuperClassLoc(getLocForEndOfToken(DeclLoc));
4032  Diag(DeclLoc, diag::warn_objc_root_class_missing)
4033  << IDecl->getIdentifier();
4034  // See if NSObject is in the current scope, and if it is, suggest
4035  // adding " : NSObject " to the class declaration.
4037  NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject),
4038  DeclLoc, LookupOrdinaryName);
4039  ObjCInterfaceDecl *NSObjectDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
4040  if (NSObjectDecl && NSObjectDecl->getDefinition()) {
4041  Diag(SuperClassLoc, diag::note_objc_needs_superclass)
4042  << FixItHint::CreateInsertion(SuperClassLoc, " : NSObject ");
4043  } else {
4044  Diag(SuperClassLoc, diag::note_objc_needs_superclass);
4045  }
4046  }
4047  } else if (HasRootClassAttr) {
4048  // Complain that only root classes may have this attribute.
4049  Diag(IDecl->getLocation(), diag::err_objc_root_class_subclass);
4050  }
4051 
4052  if (const ObjCInterfaceDecl *Super = IDecl->getSuperClass()) {
4053  // An interface can subclass another interface with a
4054  // objc_subclassing_restricted attribute when it has that attribute as
4055  // well (because of interfaces imported from Swift). Therefore we have
4056  // to check if we can subclass in the implementation as well.
4057  if (IDecl->hasAttr<ObjCSubclassingRestrictedAttr>() &&
4058  Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {
4059  Diag(IC->getLocation(), diag::err_restricted_superclass_mismatch);
4060  Diag(Super->getLocation(), diag::note_class_declared);
4061  }
4062  }
4063 
4064  if (IDecl->hasAttr<ObjCClassStubAttr>())
4065  Diag(IC->getLocation(), diag::err_implementation_of_class_stub);
4066 
4068  while (IDecl->getSuperClass()) {
4069  DiagnoseDuplicateIvars(IDecl, IDecl->getSuperClass());
4070  IDecl = IDecl->getSuperClass();
4071  }
4072  }
4073  }
4074  SetIvarInitializers(IC);
4075  } else if (ObjCCategoryImplDecl* CatImplClass =
4076  dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
4077  CatImplClass->setAtEndRange(AtEnd);
4078 
4079  // Find category interface decl and then check that all methods declared
4080  // in this interface are implemented in the category @implementation.
4081  if (ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface()) {
4082  if (ObjCCategoryDecl *Cat
4083  = IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier())) {
4084  ImplMethodsVsClassMethods(S, CatImplClass, Cat);
4085  }
4086  }
4087  } else if (const auto *IntfDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
4088  if (const ObjCInterfaceDecl *Super = IntfDecl->getSuperClass()) {
4089  if (!IntfDecl->hasAttr<ObjCSubclassingRestrictedAttr>() &&
4090  Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {
4091  Diag(IntfDecl->getLocation(), diag::err_restricted_superclass_mismatch);
4092  Diag(Super->getLocation(), diag::note_class_declared);
4093  }
4094  }
4095 
4096  if (IntfDecl->hasAttr<ObjCClassStubAttr>() &&
4097  !IntfDecl->hasAttr<ObjCSubclassingRestrictedAttr>())
4098  Diag(IntfDecl->getLocation(), diag::err_class_stub_subclassing_mismatch);
4099  }
4100  DiagnoseVariableSizedIvars(*this, OCD);
4101  if (isInterfaceDeclKind) {
4102  // Reject invalid vardecls.
4103  for (unsigned i = 0, e = allTUVars.size(); i != e; i++) {
4104  DeclGroupRef DG = allTUVars[i].get();
4105  for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
4106  if (VarDecl *VDecl = dyn_cast<VarDecl>(*I)) {
4107  if (!VDecl->hasExternalStorage())
4108  Diag(VDecl->getLocation(), diag::err_objc_var_decl_inclass);
4109  }
4110  }
4111  }
4113 
4114  for (unsigned i = 0, e = allTUVars.size(); i != e; i++) {
4115  DeclGroupRef DG = allTUVars[i].get();
4116  for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
4117  (*I)->setTopLevelDeclInObjCContainer();
4119  }
4120 
4121  ActOnDocumentableDecl(ClassDecl);
4122  return ClassDecl;
4123 }
4124 
4125 /// CvtQTToAstBitMask - utility routine to produce an AST bitmask for
4126 /// objective-c's type qualifier from the parser version of the same info.
4129  return (Decl::ObjCDeclQualifier) (unsigned) PQTVal;
4130 }
4131 
4132 /// Check whether the declared result type of the given Objective-C
4133 /// method declaration is compatible with the method's class.
4134 ///
4137  ObjCInterfaceDecl *CurrentClass) {
4138  QualType ResultType = Method->getReturnType();
4139 
4140  // If an Objective-C method inherits its related result type, then its
4141  // declared result type must be compatible with its own class type. The
4142  // declared result type is compatible if:
4143  if (const ObjCObjectPointerType *ResultObjectType
4144  = ResultType->getAs<ObjCObjectPointerType>()) {
4145  // - it is id or qualified id, or
4146  if (ResultObjectType->isObjCIdType() ||
4147  ResultObjectType->isObjCQualifiedIdType())
4148  return Sema::RTC_Compatible;
4149 
4150  if (CurrentClass) {
4151  if (ObjCInterfaceDecl *ResultClass
4152  = ResultObjectType->getInterfaceDecl()) {
4153  // - it is the same as the method's class type, or
4154  if (declaresSameEntity(CurrentClass, ResultClass))
4155  return Sema::RTC_Compatible;
4156 
4157  // - it is a superclass of the method's class type
4158  if (ResultClass->isSuperClassOf(CurrentClass))
4159  return Sema::RTC_Compatible;
4160  }
4161  } else {
4162  // Any Objective-C pointer type might be acceptable for a protocol
4163  // method; we just don't know.
4164  return Sema::RTC_Unknown;
4165  }
4166  }
4167 
4168  return Sema::RTC_Incompatible;
4169 }
4170 
4171 namespace {
4172 /// A helper class for searching for methods which a particular method
4173 /// overrides.
4174 class OverrideSearch {
4175 public:
4176  const ObjCMethodDecl *Method;
4178  bool Recursive;
4179 
4180 public:
4181  OverrideSearch(Sema &S, const ObjCMethodDecl *method) : Method(method) {
4182  Selector selector = method->getSelector();
4183 
4184  // Bypass this search if we've never seen an instance/class method
4185  // with this selector before.
4186  Sema::GlobalMethodPool::iterator it = S.MethodPool.find(selector);
4187  if (it == S.MethodPool.end()) {
4188  if (!S.getExternalSource()) return;
4189  S.ReadMethodPool(selector);
4190 
4191  it = S.MethodPool.find(selector);
4192  if (it == S.MethodPool.end())
4193  return;
4194  }
4195  const ObjCMethodList &list =
4196  method->isInstanceMethod() ? it->second.first : it->second.second;
4197  if (!list.getMethod()) return;
4198 
4199  const ObjCContainerDecl *container
4200  = cast<ObjCContainerDecl>(method->getDeclContext());
4201 
4202  // Prevent the search from reaching this container again. This is
4203  // important with categories, which override methods from the
4204  // interface and each other.
4205  if (const ObjCCategoryDecl *Category =
4206  dyn_cast<ObjCCategoryDecl>(container)) {
4207  searchFromContainer(container);
4208  if (const ObjCInterfaceDecl *Interface = Category->getClassInterface())
4209  searchFromContainer(Interface);
4210  } else {
4211  searchFromContainer(container);
4212  }
4213  }
4214 
4215  typedef decltype(Overridden)::iterator iterator;
4216  iterator begin() const { return Overridden.begin(); }
4217  iterator end() const { return Overridden.end(); }
4218 
4219 private:
4220  void searchFromContainer(const ObjCContainerDecl *container) {
4221  if (container->isInvalidDecl()) return;
4222 
4223  switch (container->getDeclKind()) {
4224 #define OBJCCONTAINER(type, base) \
4225  case Decl::type: \
4226  searchFrom(cast<type##Decl>(container)); \
4227  break;
4228 #define ABSTRACT_DECL(expansion)
4229 #define DECL(type, base) \
4230  case Decl::type:
4231 #include "clang/AST/DeclNodes.inc"
4232  llvm_unreachable("not an ObjC container!");
4233  }
4234  }
4235 
4236  void searchFrom(const ObjCProtocolDecl *protocol) {
4237  if (!protocol->hasDefinition())
4238  return;
4239 
4240  // A method in a protocol declaration overrides declarations from
4241  // referenced ("parent") protocols.
4242  search(protocol->getReferencedProtocols());
4243  }
4244 
4245  void searchFrom(const ObjCCategoryDecl *category) {
4246  // A method in a category declaration overrides declarations from
4247  // the main class and from protocols the category references.
4248  // The main class is handled in the constructor.
4249  search(category->getReferencedProtocols());
4250  }
4251 
4252  void searchFrom(const ObjCCategoryImplDecl *impl) {
4253  // A method in a category definition that has a category
4254  // declaration overrides declarations from the category
4255  // declaration.
4256  if (ObjCCategoryDecl *category = impl->getCategoryDecl()) {
4257  search(category);
4258  if (ObjCInterfaceDecl *Interface = category->getClassInterface())
4259  search(Interface);
4260 
4261  // Otherwise it overrides declarations from the class.
4262  } else if (const auto *Interface = impl->getClassInterface()) {
4263  search(Interface);
4264  }
4265  }
4266 
4267  void searchFrom(const ObjCInterfaceDecl *iface) {
4268  // A method in a class declaration overrides declarations from
4269  if (!iface->hasDefinition())
4270  return;
4271 
4272  // - categories,
4273  for (auto *Cat : iface->known_categories())
4274  search(Cat);
4275 
4276  // - the super class, and
4277  if (ObjCInterfaceDecl *super = iface->getSuperClass())
4278  search(super);
4279 
4280  // - any referenced protocols.
4281  search(iface->getReferencedProtocols());
4282  }
4283 
4284  void searchFrom(const ObjCImplementationDecl *impl) {
4285  // A method in a class implementation overrides declarations from
4286  // the class interface.
4287  if (const auto *Interface = impl->getClassInterface())
4288  search(Interface);
4289  }
4290 
4291  void search(const ObjCProtocolList &protocols) {
4292  for (const auto *Proto : protocols)
4293  search(Proto);
4294  }
4295 
4296  void search(const ObjCContainerDecl *container) {
4297  // Check for a method in this container which matches this selector.
4298  ObjCMethodDecl *meth = container->getMethod(Method->getSelector(),
4299  Method->isInstanceMethod(),
4300  /*AllowHidden=*/true);
4301 
4302  // If we find one, record it and bail out.
4303  if (meth) {
4304  Overridden.insert(meth);
4305  return;
4306  }
4307 
4308  // Otherwise, search for methods that a hypothetical method here
4309  // would have overridden.
4310 
4311  // Note that we're now in a recursive case.
4312  Recursive = true;
4313 
4314  searchFromContainer(container);
4315  }
4316 };
4317 } // end anonymous namespace
4318 
4320  ObjCInterfaceDecl *CurrentClass,
4322  if (!ObjCMethod)
4323  return;
4324  // Search for overridden methods and merge information down from them.
4325  OverrideSearch overrides(*this, ObjCMethod);
4326  // Keep track if the method overrides any method in the class's base classes,
4327  // its protocols, or its categories' protocols; we will keep that info
4328  // in the ObjCMethodDecl.
4329  // For this info, a method in an implementation is not considered as
4330  // overriding the same method in the interface or its categories.
4331  bool hasOverriddenMethodsInBaseOrProtocol = false;
4332  for (ObjCMethodDecl *overridden : overrides) {
4333  if (!hasOverriddenMethodsInBaseOrProtocol) {
4334  if (isa<ObjCProtocolDecl>(overridden->getDeclContext()) ||
4335  CurrentClass != overridden->getClassInterface() ||
4336  overridden->isOverriding()) {
4337  hasOverriddenMethodsInBaseOrProtocol = true;
4338 
4339  } else if (isa<ObjCImplDecl>(ObjCMethod->getDeclContext())) {
4340  // OverrideSearch will return as "overridden" the same method in the
4341  // interface. For hasOverriddenMethodsInBaseOrProtocol, we need to
4342  // check whether a category of a base class introduced a method with the
4343  // same selector, after the interface method declaration.
4344  // To avoid unnecessary lookups in the majority of cases, we use the
4345  // extra info bits in GlobalMethodPool to check whether there were any
4346  // category methods with this selector.
4347  GlobalMethodPool::iterator It =
4348  MethodPool.find(ObjCMethod->getSelector());
4349  if (It != MethodPool.end()) {
4350  ObjCMethodList &List =
4351  ObjCMethod->isInstanceMethod()? It->second.first: It->second.second;
4352  unsigned CategCount = List.getBits();
4353  if (CategCount > 0) {
4354  // If the method is in a category we'll do lookup if there were at
4355  // least 2 category methods recorded, otherwise only one will do.
4356  if (CategCount > 1 ||
4357  !isa<ObjCCategoryImplDecl>(overridden->getDeclContext())) {
4358  OverrideSearch overrides(*this, overridden);
4359  for (ObjCMethodDecl *SuperOverridden : overrides) {
4360  if (isa<ObjCProtocolDecl>(SuperOverridden->getDeclContext()) ||
4361  CurrentClass != SuperOverridden->getClassInterface()) {
4362  hasOverriddenMethodsInBaseOrProtocol = true;
4363  overridden->setOverriding(true);
4364  break;
4365  }
4366  }
4367  }
4368  }
4369  }
4370  }
4371  }
4372 
4373  // Propagate down the 'related result type' bit from overridden methods.
4374  if (RTC != Sema::RTC_Incompatible && overridden->hasRelatedResultType())
4375  ObjCMethod->setRelatedResultType();
4376 
4377  // Then merge the declarations.
4378  mergeObjCMethodDecls(ObjCMethod, overridden);
4379 
4380  if (ObjCMethod->isImplicit() && overridden->isImplicit())
4381  continue; // Conflicting properties are detected elsewhere.
4382 
4383  // Check for overriding methods
4384  if (isa<ObjCInterfaceDecl>(ObjCMethod->getDeclContext()) ||
4385  isa<ObjCImplementationDecl>(ObjCMethod->getDeclContext()))
4386  CheckConflictingOverridingMethod(ObjCMethod, overridden,
4387  isa<ObjCProtocolDecl>(overridden->getDeclContext()));
4388 
4389  if (CurrentClass && overridden->getDeclContext() != CurrentClass &&
4390  isa<ObjCInterfaceDecl>(overridden->getDeclContext()) &&
4391  !overridden->isImplicit() /* not meant for properties */) {
4392  ObjCMethodDecl::param_iterator ParamI = ObjCMethod->param_begin(),
4393  E = ObjCMethod->param_end();
4394  ObjCMethodDecl::param_iterator PrevI = overridden->param_begin(),
4395  PrevE = overridden->param_end();
4396  for (; ParamI != E && PrevI != PrevE; ++ParamI, ++PrevI) {
4397  assert(PrevI != overridden->param_end() && "Param mismatch");
4398  QualType T1 = Context.getCanonicalType((*ParamI)->getType());
4399  QualType T2 = Context.getCanonicalType((*PrevI)->getType());
4400  // If type of argument of method in this class does not match its
4401  // respective argument type in the super class method, issue warning;
4402  if (!Context.typesAreCompatible(T1, T2)) {
4403  Diag((*ParamI)->getLocation(), diag::ext_typecheck_base_super)
4404  << T1 << T2;
4405  Diag(overridden->getLocation(), diag::note_previous_declaration);
4406  break;
4407  }
4408  }
4409  }
4410  }
4411 
4412  ObjCMethod->setOverriding(hasOverriddenMethodsInBaseOrProtocol);
4413 }
4414 
4415 /// Merge type nullability from for a redeclaration of the same entity,
4416 /// producing the updated type of the redeclared entity.
4418  QualType type,
4419  bool usesCSKeyword,
4420  SourceLocation prevLoc,
4421  QualType prevType,
4422  bool prevUsesCSKeyword) {
4423  // Determine the nullability of both types.
4424  auto nullability = type->getNullability(S.Context);
4425  auto prevNullability = prevType->getNullability(S.Context);
4426 
4427  // Easy case: both have nullability.
4428  if (nullability.hasValue() == prevNullability.hasValue()) {
4429  // Neither has nullability; continue.
4430  if (!nullability)
4431  return type;
4432 
4433  // The nullabilities are equivalent; do nothing.
4434  if (*nullability == *prevNullability)
4435  return type;
4436 
4437  // Complain about mismatched nullability.
4438  S.Diag(loc, diag::err_nullability_conflicting)
4439  << DiagNullabilityKind(*nullability, usesCSKeyword)
4440  << DiagNullabilityKind(*prevNullability, prevUsesCSKeyword);
4441  return type;
4442  }
4443 
4444  // If it's the redeclaration that has nullability, don't change anything.
4445  if (nullability)
4446  return type;
4447 
4448  // Otherwise, provide the result with the same nullability.
4449  return S.Context.getAttributedType(
4450  AttributedType::getNullabilityAttrKind(*prevNullability),
4451  type, type);
4452 }
4453 
4454 /// Merge information from the declaration of a method in the \@interface
4455 /// (or a category/extension) into the corresponding method in the
4456 /// @implementation (for a class or category).
4458  ObjCMethodDecl *method,
4459  ObjCMethodDecl *prevMethod) {
4460  // Merge the objc_requires_super attribute.
4461  if (prevMethod->hasAttr<ObjCRequiresSuperAttr>() &&
4462  !method->hasAttr<ObjCRequiresSuperAttr>()) {
4463  // merge the attribute into implementation.
4464  method->addAttr(
4465  ObjCRequiresSuperAttr::CreateImplicit(S.Context,
4466  method->getLocation()));
4467  }
4468 
4469  // Merge nullability of the result type.
4470  QualType newReturnType
4472  S, method->getReturnTypeSourceRange().getBegin(),
4473  method->getReturnType(),
4475  prevMethod->getReturnTypeSourceRange().getBegin(),
4476  prevMethod->getReturnType(),
4478  method->setReturnType(newReturnType);
4479 
4480  // Handle each of the parameters.
4481  unsigned numParams = method->param_size();
4482  unsigned numPrevParams = prevMethod->param_size();
4483  for (unsigned i = 0, n = std::min(numParams, numPrevParams); i != n; ++i) {
4484  ParmVarDecl *param = method->param_begin()[i];
4485  ParmVarDecl *prevParam = prevMethod->param_begin()[i];
4486 
4487  // Merge nullability.
4488  QualType newParamType
4490  S, param->getLocation(), param->getType(),
4492  prevParam->getLocation(), prevParam->getType(),
4494  param->setType(newParamType);
4495  }
4496 }
4497 
4498 /// Verify that the method parameters/return value have types that are supported
4499 /// by the x86 target.
4501  const ObjCMethodDecl *Method) {
4502  assert(SemaRef.getASTContext().getTargetInfo().getTriple().getArch() ==
4503  llvm::Triple::x86 &&
4504  "x86-specific check invoked for a different target");
4505  SourceLocation Loc;
4506  QualType T;
4507  for (const ParmVarDecl *P : Method->parameters()) {
4508  if (P->getType()->isVectorType()) {
4509  Loc = P->getBeginLoc();
4510  T = P->getType();
4511  break;
4512  }
4513  }
4514  if (Loc.isInvalid()) {
4515  if (Method->getReturnType()->isVectorType()) {
4516  Loc = Method->getReturnTypeSourceRange().getBegin();
4517  T = Method->getReturnType();
4518  } else
4519  return;
4520  }
4521 
4522  // Vector parameters/return values are not supported by objc_msgSend on x86 in
4523  // iOS < 9 and macOS < 10.11.
4524  const auto &Triple = SemaRef.getASTContext().getTargetInfo().getTriple();
4525  VersionTuple AcceptedInVersion;
4526  if (Triple.getOS() == llvm::Triple::IOS)
4527  AcceptedInVersion = VersionTuple(/*Major=*/9);
4528  else if (Triple.isMacOSX())
4529  AcceptedInVersion = VersionTuple(/*Major=*/10, /*Minor=*/11);
4530  else
4531  return;
4533  AcceptedInVersion)
4534  return;
4535  SemaRef.Diag(Loc, diag::err_objc_method_unsupported_param_ret_type)
4536  << T << (Method->getReturnType()->isVectorType() ? /*return value*/ 1
4537  : /*parameter*/ 0)
4538  << (Triple.isMacOSX() ? "macOS 10.11" : "iOS 9");
4539 }
4540 
4542  Scope *S, SourceLocation MethodLoc, SourceLocation EndLoc,
4543  tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
4544  ArrayRef<SourceLocation> SelectorLocs, Selector Sel,
4545  // optional arguments. The number of types/arguments is obtained
4546  // from the Sel.getNumArgs().
4547  ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo,
4548  unsigned CNumArgs, // c-style args
4549  const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodDeclKind,
4550  bool isVariadic, bool MethodDefinition) {
4551  // Make sure we can establish a context for the method.
4552  if (!CurContext->isObjCContainer()) {
4553  Diag(MethodLoc, diag::err_missing_method_context);
4554  return nullptr;
4555  }
4556  Decl *ClassDecl = cast<ObjCContainerDecl>(CurContext);
4557  QualType resultDeclType;
4558 
4559  bool HasRelatedResultType = false;
4560  TypeSourceInfo *ReturnTInfo = nullptr;
4561  if (ReturnType) {
4562  resultDeclType = GetTypeFromParser(ReturnType, &ReturnTInfo);
4563 
4564  if (CheckFunctionReturnType(resultDeclType, MethodLoc))
4565  return nullptr;
4566 
4567  QualType bareResultType = resultDeclType;
4568  (void)AttributedType::stripOuterNullability(bareResultType);
4569  HasRelatedResultType = (bareResultType == Context.getObjCInstanceType());
4570  } else { // get the type for "id".
4571  resultDeclType = Context.getObjCIdType();
4572  Diag(MethodLoc, diag::warn_missing_method_return_type)
4573  << FixItHint::CreateInsertion(SelectorLocs.front(), "(id)");
4574  }
4575 
4576  ObjCMethodDecl *ObjCMethod = ObjCMethodDecl::Create(
4577  Context, MethodLoc, EndLoc, Sel, resultDeclType, ReturnTInfo, CurContext,
4578  MethodType == tok::minus, isVariadic,
4579  /*isPropertyAccessor=*/false,
4580  /*isImplicitlyDeclared=*/false, /*isDefined=*/false,
4581  MethodDeclKind == tok::objc_optional ? ObjCMethodDecl::Optional
4583  HasRelatedResultType);
4584 
4586 
4587  for (unsigned i = 0, e = Sel.getNumArgs(); i != e; ++i) {
4588  QualType ArgType;
4589  TypeSourceInfo *DI;
4590 
4591  if (!ArgInfo[i].Type) {
4592  ArgType = Context.getObjCIdType();
4593  DI = nullptr;
4594  } else {
4595  ArgType = GetTypeFromParser(ArgInfo[i].Type, &DI);
4596  }
4597 
4598  LookupResult R(*this, ArgInfo[i].Name, ArgInfo[i].NameLoc,
4600  LookupName(R, S);
4601  if (R.isSingleResult()) {
4602  NamedDecl *PrevDecl = R.getFoundDecl();
4603  if (S->isDeclScope(PrevDecl)) {
4604  Diag(ArgInfo[i].NameLoc,
4605  (MethodDefinition ? diag::warn_method_param_redefinition
4606  : diag::warn_method_param_declaration))
4607  << ArgInfo[i].Name;
4608  Diag(PrevDecl->getLocation(),
4609  diag::note_previous_declaration);
4610  }
4611  }
4612 
4613  SourceLocation StartLoc = DI
4614  ? DI->getTypeLoc().getBeginLoc()
4615  : ArgInfo[i].NameLoc;
4616 
4617  ParmVarDecl* Param = CheckParameter(ObjCMethod, StartLoc,
4618  ArgInfo[i].NameLoc, ArgInfo[i].Name,
4619  ArgType, DI, SC_None);
4620 
4621  Param->setObjCMethodScopeInfo(i);
4622 
4623  Param->setObjCDeclQualifier(
4624  CvtQTToAstBitMask(ArgInfo[i].DeclSpec.getObjCDeclQualifier()));
4625 
4626  // Apply the attributes to the parameter.
4627  ProcessDeclAttributeList(TUScope, Param, ArgInfo[i].ArgAttrs);
4628  AddPragmaAttributes(TUScope, Param);
4629 
4630  if (Param->hasAttr<BlocksAttr>()) {
4631  Diag(Param->getLocation(), diag::err_block_on_nonlocal);
4632  Param->setInvalidDecl();
4633  }
4634  S->AddDecl(Param);
4635  IdResolver.AddDecl(Param);
4636 
4637  Params.push_back(Param);
4638  }
4639 
4640  for (unsigned i = 0, e = CNumArgs; i != e; ++i) {
4641  ParmVarDecl *Param = cast<ParmVarDecl>(CParamInfo[i].Param);
4642  QualType ArgType = Param->getType();
4643  if (ArgType.isNull())
4644  ArgType = Context.getObjCIdType();
4645  else
4646  // Perform the default array/function conversions (C99 6.7.5.3p[7,8]).
4647  ArgType = Context.getAdjustedParameterType(ArgType);
4648 
4649  Param->setDeclContext(ObjCMethod);
4650  Params.push_back(Param);
4651  }
4652 
4653  ObjCMethod->setMethodParams(Context, Params, SelectorLocs);
4654  ObjCMethod->setObjCDeclQualifier(
4656 
4657  ProcessDeclAttributeList(TUScope, ObjCMethod, AttrList);
4658  AddPragmaAttributes(TUScope, ObjCMethod);
4659 
4660  // Add the method now.
4661  const ObjCMethodDecl *PrevMethod = nullptr;
4662  if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
4663  if (MethodType == tok::minus) {
4664  PrevMethod = ImpDecl->getInstanceMethod(Sel);
4665  ImpDecl->addInstanceMethod(ObjCMethod);
4666  } else {
4667  PrevMethod = ImpDecl->getClassMethod(Sel);
4668  ImpDecl->addClassMethod(ObjCMethod);
4669  }
4670 
4671  // Merge information from the @interface declaration into the
4672  // @implementation.
4673  if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface()) {
4674  if (auto *IMD = IDecl->lookupMethod(ObjCMethod->getSelector(),
4675  ObjCMethod->isInstanceMethod())) {
4676  mergeInterfaceMethodToImpl(*this, ObjCMethod, IMD);
4677 
4678  // Warn about defining -dealloc in a category.
4679  if (isa<ObjCCategoryImplDecl>(ImpDecl) && IMD->isOverriding() &&
4680  ObjCMethod->getSelector().getMethodFamily() == OMF_dealloc) {
4681  Diag(ObjCMethod->getLocation(), diag::warn_dealloc_in_category)
4682  << ObjCMethod->getDeclName();
4683  }
4684  }
4685 
4686  // Warn if a method declared in a protocol to which a category or
4687  // extension conforms is non-escaping and the implementation's method is
4688  // escaping.
4689  for (auto *C : IDecl->visible_categories())
4690  for (auto &P : C->protocols())
4691  if (auto *IMD = P->lookupMethod(ObjCMethod->getSelector(),
4692  ObjCMethod->isInstanceMethod())) {
4693  assert(ObjCMethod->parameters().size() ==
4694  IMD->parameters().size() &&
4695  "Methods have different number of parameters");
4696  auto OI = IMD->param_begin(), OE = IMD->param_end();
4697  auto NI = ObjCMethod->param_begin();
4698  for (; OI != OE; ++OI, ++NI)
4699  diagnoseNoescape(*NI, *OI, C, P, *this);
4700  }
4701  }
4702  } else {
4703  cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod);
4704  }
4705 
4706  if (PrevMethod) {
4707  // You can never have two method definitions with the same name.
4708  Diag(ObjCMethod->getLocation(), diag::err_duplicate_method_decl)
4709  << ObjCMethod->getDeclName();
4710  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
4711  ObjCMethod->setInvalidDecl();
4712  return ObjCMethod;
4713  }
4714 
4715  // If this Objective-C method does not have a related result type, but we
4716  // are allowed to infer related result types, try to do so based on the
4717  // method family.
4718  ObjCInterfaceDecl *CurrentClass = dyn_cast<ObjCInterfaceDecl>(ClassDecl);
4719  if (!CurrentClass) {
4720  if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl))
4721  CurrentClass = Cat->getClassInterface();
4722  else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(ClassDecl))
4723  CurrentClass = Impl->getClassInterface();
4724  else if (ObjCCategoryImplDecl *CatImpl
4725  = dyn_cast<ObjCCategoryImplDecl>(ClassDecl))
4726  CurrentClass = CatImpl->getClassInterface();
4727  }
4728 
4730  = CheckRelatedResultTypeCompatibility(*this, ObjCMethod, CurrentClass);
4731 
4732  CheckObjCMethodOverrides(ObjCMethod, CurrentClass, RTC);
4733 
4734  bool ARCError = false;
4735  if (getLangOpts().ObjCAutoRefCount)
4736  ARCError = CheckARCMethodDecl(ObjCMethod);
4737 
4738  // Infer the related result type when possible.
4739  if (!ARCError && RTC == Sema::RTC_Compatible &&
4740  !ObjCMethod->hasRelatedResultType() &&
4741  LangOpts.ObjCInferRelatedResultType) {
4742  bool InferRelatedResultType = false;
4743  switch (ObjCMethod->getMethodFamily()) {
4744  case OMF_None:
4745  case OMF_copy:
4746  case OMF_dealloc:
4747  case OMF_finalize:
4748  case OMF_mutableCopy:
4749  case OMF_release:
4750  case OMF_retainCount:
4751  case OMF_initialize:
4752  case OMF_performSelector:
4753  break;
4754 
4755  case OMF_alloc:
4756  case OMF_new:
4757  InferRelatedResultType = ObjCMethod->isClassMethod();
4758  break;
4759 
4760  case OMF_init:
4761  case OMF_autorelease:
4762  case OMF_retain:
4763  case OMF_self:
4764  InferRelatedResultType = ObjCMethod->isInstanceMethod();
4765  break;
4766  }
4767 
4768  if (InferRelatedResultType &&
4769  !ObjCMethod->getReturnType()->isObjCIndependentClassType())
4770  ObjCMethod->setRelatedResultType();
4771  }
4772 
4773  if (MethodDefinition &&
4774  Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
4775  checkObjCMethodX86VectorTypes(*this, ObjCMethod);
4776 
4777  // + load method cannot have availability attributes. It get called on
4778  // startup, so it has to have the availability of the deployment target.
4779  if (const auto *attr = ObjCMethod->getAttr<AvailabilityAttr>()) {
4780  if (ObjCMethod->isClassMethod() &&
4781  ObjCMethod->getSelector().getAsString() == "load") {
4782  Diag(attr->getLocation(), diag::warn_availability_on_static_initializer)
4783  << 0;
4784  ObjCMethod->dropAttr<AvailabilityAttr>();
4785  }
4786  }
4787 
4788  ActOnDocumentableDecl(ObjCMethod);
4789 
4790  return ObjCMethod;
4791 }
4792 
4794  // Following is also an error. But it is caused by a missing @end
4795  // and diagnostic is issued elsewhere.
4796  if (isa<ObjCContainerDecl>(CurContext->getRedeclContext()))
4797  return false;
4798 
4799  // If we switched context to translation unit while we are still lexically in
4800  // an objc container, it means the parser missed emitting an error.
4801  if (isa<TranslationUnitDecl>(getCurLexicalContext()->getRedeclContext()))
4802  return false;
4803 
4804  Diag(D->getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope);
4805  D->setInvalidDecl();
4806 
4807  return true;
4808 }
4809 
4810 /// Called whenever \@defs(ClassName) is encountered in the source. Inserts the
4811 /// instance variables of ClassName into Decls.
4812 void Sema::ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
4813  IdentifierInfo *ClassName,
4814  SmallVectorImpl<Decl*> &Decls) {
4815  // Check that ClassName is a valid class
4816  ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName, DeclStart);
4817  if (!Class) {
4818  Diag(DeclStart, diag::err_undef_interface) << ClassName;
4819  return;
4820  }
4822  Diag(DeclStart, diag::err_atdef_nonfragile_interface);
4823  return;
4824  }
4825 
4826  // Collect the instance variables
4828  Context.DeepCollectObjCIvars(Class, true, Ivars);
4829  // For each ivar, create a fresh ObjCAtDefsFieldDecl.
4830  for (unsigned i = 0; i < Ivars.size(); i++) {
4831  const FieldDecl* ID = Ivars[i];
4832  RecordDecl *Record = dyn_cast<RecordDecl>(TagD);
4833  Decl *FD = ObjCAtDefsFieldDecl::Create(Context, Record,
4834  /*FIXME: StartL=*/ID->getLocation(),
4835  ID->getLocation(),
4836  ID->getIdentifier(), ID->getType(),
4837  ID->getBitWidth());
4838  Decls.push_back(FD);
4839  }
4840 
4841  // Introduce all of these fields into the appropriate scope.
4842  for (SmallVectorImpl<Decl*>::iterator D = Decls.begin();
4843  D != Decls.end(); ++D) {
4844  FieldDecl *FD = cast<FieldDecl>(*D);
4845  if (getLangOpts().CPlusPlus)
4846  PushOnScopeChains(FD, S);
4847  else if (RecordDecl *Record = dyn_cast<RecordDecl>(TagD))
4848  Record->addDecl(FD);
4849  }
4850 }
4851 
4852 /// Build a type-check a new Objective-C exception variable declaration.
4854  SourceLocation StartLoc,
4855  SourceLocation IdLoc,
4856  IdentifierInfo *Id,
4857  bool Invalid) {
4858  // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
4859  // duration shall not be qualified by an address-space qualifier."
4860  // Since all parameters have automatic store duration, they can not have
4861  // an address space.
4862  if (T.getAddressSpace() != LangAS::Default) {
4863  Diag(IdLoc, diag::err_arg_with_address_space);
4864  Invalid = true;
4865  }
4866 
4867  // An @catch parameter must be an unqualified object pointer type;
4868  // FIXME: Recover from "NSObject foo" by inserting the * in "NSObject *foo"?
4869  if (Invalid) {
4870  // Don't do any further checking.
4871  } else if (T->isDependentType()) {
4872  // Okay: we don't know what this type will instantiate to.
4873  } else if (T->isObjCQualifiedIdType()) {
4874  Invalid = true;
4875  Diag(IdLoc, diag::err_illegal_qualifiers_on_catch_parm);
4876  } else if (T->isObjCIdType()) {
4877  // Okay: we don't know what this type will instantiate to.
4878  } else if (!T->isObjCObjectPointerType()) {
4879  Invalid = true;
4880  Diag(IdLoc, diag::err_catch_param_not_objc_type);
4881  } else if (!T->getAs<ObjCObjectPointerType>()->getInterfaceType()) {
4882  Invalid = true;
4883  Diag(IdLoc, diag::err_catch_param_not_objc_type);
4884  }
4885 
4886  VarDecl *New = VarDecl::Create(Context, CurContext, StartLoc, IdLoc, Id,
4887  T, TInfo, SC_None);
4888  New->setExceptionVariable(true);
4889 
4890  // In ARC, infer 'retaining' for variables of retainable type.
4891  if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(New))
4892  Invalid = true;
4893 
4894  if (Invalid)
4895  New->setInvalidDecl();
4896  return New;
4897 }
4898 
4900  const DeclSpec &DS = D.getDeclSpec();
4901 
4902  // We allow the "register" storage class on exception variables because
4903  // GCC did, but we drop it completely. Any other storage class is an error.
4905  Diag(DS.getStorageClassSpecLoc(), diag::warn_register_objc_catch_parm)
4907  } else if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
4908  Diag(DS.getStorageClassSpecLoc(), diag::err_storage_spec_on_catch_parm)
4910  }
4911  if (DS.isInlineSpecified())
4912  Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
4913  << getLangOpts().CPlusPlus17;
4916  diag::err_invalid_thread)
4917  << DeclSpec::getSpecifierName(TSCS);
4919 
4921 
4922  // Check that there are no default arguments inside the type of this
4923  // exception object (C++ only).
4924  if (getLangOpts().CPlusPlus)
4926 
4927  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
4928  QualType ExceptionType = TInfo->getType();
4929 
4930  VarDecl *New = BuildObjCExceptionDecl(TInfo, ExceptionType,
4931  D.getSourceRange().getBegin(),
4932  D.getIdentifierLoc(),
4933  D.getIdentifier(),
4934  D.isInvalidType());
4935 
4936  // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
4937  if (D.getCXXScopeSpec().isSet()) {
4938  Diag(D.getIdentifierLoc(), diag::err_qualified_objc_catch_parm)
4939  << D.getCXXScopeSpec().getRange();
4940  New->setInvalidDecl();
4941  }
4942 
4943  // Add the parameter declaration into this scope.
4944  S->AddDecl(New);
4945  if (D.getIdentifier())
4946  IdResolver.AddDecl(New);
4947 
4948  ProcessDeclAttributes(S, New, D);
4949 
4950  if (New->hasAttr<BlocksAttr>())
4951  Diag(New->getLocation(), diag::err_block_on_nonlocal);
4952  return New;
4953 }
4954 
4955 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
4956 /// initialization.
4959  for (ObjCIvarDecl *Iv = OI->all_declared_ivar_begin(); Iv;
4960  Iv= Iv->getNextIvar()) {
4961  QualType QT = Context.getBaseElementType(Iv->getType());
4962  if (QT->isRecordType())
4963  Ivars.push_back(Iv);
4964  }
4965 }
4966 
4968  // Load referenced selectors from the external source.
4969  if (ExternalSource) {
4971  ExternalSource->ReadReferencedSelectors(Sels);
4972  for (unsigned I = 0, N = Sels.size(); I != N; ++I)
4973  ReferencedSelectors[Sels[I].first] = Sels[I].second;
4974  }
4975 
4976  // Warning will be issued only when selector table is
4977  // generated (which means there is at lease one implementation
4978  // in the TU). This is to match gcc's behavior.
4979  if (ReferencedSelectors.empty() ||
4980  !Context.AnyObjCImplementation())
4981  return;
4982  for (auto &SelectorAndLocation : ReferencedSelectors) {
4983  Selector Sel = SelectorAndLocation.first;
4984  SourceLocation Loc = SelectorAndLocation.second;
4986  Diag(Loc, diag::warn_unimplemented_selector) << Sel;
4987  }
4988 }
4989 
4990 ObjCIvarDecl *
4992  const ObjCPropertyDecl *&PDecl) const {
4993  if (Method->isClassMethod())
4994  return nullptr;
4995  const ObjCInterfaceDecl *IDecl = Method->getClassInterface();
4996  if (!IDecl)
4997  return nullptr;
4998  Method = IDecl->lookupMethod(Method->getSelector(), /*isInstance=*/true,
4999  /*shallowCategoryLookup=*/false,
5000  /*followSuper=*/false);
5001  if (!Method || !Method->isPropertyAccessor())
5002  return nullptr;
5003  if ((PDecl = Method->findPropertyDecl()))
5004  if (ObjCIvarDecl *IV = PDecl->getPropertyIvarDecl()) {
5005  // property backing ivar must belong to property's class
5006  // or be a private ivar in class's implementation.
5007  // FIXME. fix the const-ness issue.
5008  IV = const_cast<ObjCInterfaceDecl *>(IDecl)->lookupInstanceVariable(
5009  IV->getIdentifier());
5010  return IV;
5011  }
5012  return nullptr;
5013 }
5014 
5015 namespace {
5016  /// Used by Sema::DiagnoseUnusedBackingIvarInAccessor to check if a property
5017  /// accessor references the backing ivar.
5018  class UnusedBackingIvarChecker :
5019  public RecursiveASTVisitor<UnusedBackingIvarChecker> {
5020  public:
5021  Sema &S;
5022  const ObjCMethodDecl *Method;
5023  const ObjCIvarDecl *IvarD;
5024  bool AccessedIvar;
5025  bool InvokedSelfMethod;
5026 
5027  UnusedBackingIvarChecker(Sema &S, const ObjCMethodDecl *Method,
5028  const ObjCIvarDecl *IvarD)
5029  : S(S), Method(Method), IvarD(IvarD),
5030  AccessedIvar(false), InvokedSelfMethod(false) {
5031  assert(IvarD);
5032  }
5033 
5034  bool VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
5035  if (E->getDecl() == IvarD) {
5036  AccessedIvar = true;
5037  return false;
5038  }
5039  return true;
5040  }
5041 
5042  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
5044  S.isSelfExpr(E->getInstanceReceiver(), Method)) {
5045  InvokedSelfMethod = true;
5046  }
5047  return true;
5048  }
5049  };
5050 } // end anonymous namespace
5051 
5053  const ObjCImplementationDecl *ImplD) {
5055  return;
5056 
5057  for (const auto *CurMethod : ImplD->instance_methods()) {
5058  unsigned DIAG = diag::warn_unused_property_backing_ivar;
5059  SourceLocation Loc = CurMethod->getLocation();
5060  if (Diags.isIgnored(DIAG, Loc))
5061  continue;
5062 
5063  const ObjCPropertyDecl *PDecl;
5064  const ObjCIvarDecl *IV = GetIvarBackingPropertyAccessor(CurMethod, PDecl);
5065  if (!IV)
5066  continue;
5067 
5068  UnusedBackingIvarChecker Checker(*this, CurMethod, IV);
5069  Checker.TraverseStmt(CurMethod->getBody());
5070  if (Checker.AccessedIvar)
5071  continue;
5072 
5073  // Do not issue this warning if backing ivar is used somewhere and accessor
5074  // implementation makes a self call. This is to prevent false positive in
5075  // cases where the ivar is accessed by another method that the accessor
5076  // delegates to.
5077  if (!IV->isReferenced() || !Checker.InvokedSelfMethod) {
5078  Diag(Loc, DIAG) << IV;
5079  Diag(PDecl->getLocation(), diag::note_property_declare);
5080  }
5081  }
5082 }
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:1553
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:1534
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:429
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:5796
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:1884
VersionTuple getPlatformMinVersion() const
Retrieve the minimum desired version of the platform, to which the program should be compiled...
Definition: TargetInfo.h:1247
ExternalSemaSource * getExternalSource() const
Definition: Sema.h:1295
bool isObjCQualifiedIdType() const
True if this is equivalent to &#39;id.
Definition: Type.h:5943
Smart pointer class that efficiently represents Objective-C method names.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1854
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:14715
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2569
A (possibly-)qualified type.
Definition: Type.h:643
ASTConsumer & Consumer
Definition: Sema.h:375
Simple class containing the result of Sema::CorrectTypo.
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1313
unsigned param_size() const
Definition: DeclObjC.h:340
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.h:2324
all_protocol_range all_referenced_protocols() const
Definition: DeclObjC.h:1423
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1143
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:843
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:3224
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:3258
const ObjCProtocolList & getReferencedProtocols() const
Definition: DeclObjC.h:2348
Expr * getBitWidth() const
Definition: Decl.h:2696
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:985
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:12720
bool isRecordType() const
Definition: Type.h:6464
iterator end()
Definition: DeclGroup.h:105
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1362
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:799
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:5744
StringRef P
ivar_range ivars() const
Definition: DeclObjC.h:1457
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:877
static ObjCProtocolDecl * Create(ASTContext &C, DeclContext *DC, IdentifierInfo *Id, SourceLocation nameLoc, SourceLocation atStartLoc, ObjCProtocolDecl *PrevDecl)
Definition: DeclObjC.cpp:1855
static bool NestedProtocolHasNoDefinition(ObjCProtocolDecl *PDecl, ObjCProtocolDecl *&UndefinedProtocol)
known_categories_range known_categories() const
Definition: DeclObjC.h:1686
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:1433
void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false)
AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Definition: Sema.h:3797
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:263
bool isObjCContainer() const
Definition: DeclBase.h:1818
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:47
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1613
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:693
A container of type source information.
Definition: Decl.h:86
void ProcessPropertyDecl(ObjCPropertyDecl *property)
Process the specified property declaration and create decls for the setters and getters as needed...
ObjCMethodDecl * getMethod() const
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:442
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:351
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:226
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID)
createImplicitParams - Used to lazily create the self and cmd implict parameters. ...
Definition: DeclObjC.cpp:1122
Represents a variable declaration or definition.
Definition: Decl.h:812
void setImplementation(ObjCCategoryImplDecl *ImplD)
Definition: DeclObjC.cpp:2024
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:1775
DiagnosticsEngine & Diags
Definition: Sema.h:376
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6851
ObjCCategoryImplDecl * getImplementation() const
Definition: DeclObjC.cpp:2019
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:1070
llvm::MapVector< Selector, SourceLocation > ReferencedSelectors
Method selectors used in a @selector expression.
Definition: Sema.h:1213
protocol_range protocols() const
Definition: DeclObjC.h:2128
static const NamedDecl * getDefinition(const Decl *D)
Definition: SemaDecl.cpp:2557
Represents a parameter to a function.
Definition: Decl.h:1564
long i
Definition: xmmintrin.h:1456
The collection of all-type qualifiers we support.
Definition: Type.h:137
iterator end() const
Definition: DeclObjC.h:91
MethodMatchStrategy
Definition: Sema.h:3707
const ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.h:2688
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
Represents a struct/union/class.
Definition: Decl.h:3626
SourceLocation getVarianceLoc() const
Retrieve the location of the variance keyword.
Definition: DeclObjC.h:611
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
One of these records is kept for each identifier that is lexed.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:909
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:2120
Represents a class type in Objective C.
Definition: Type.h:5608
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
ObjCMethodDecl * getClassMethod(Selector Sel, bool AllowHidden=false) const
Definition: DeclObjC.h:1091
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:342
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:4004
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:263
bool isObjCIdType() const
Definition: Type.h:6517
Represents a member of a struct/union/class.
Definition: Decl.h:2607
SourceRange getReturnTypeSourceRange() const
Definition: DeclObjC.cpp:1155
instmeth_range instance_methods() const
Definition: DeclObjC.h:1053
bool isDefined() const
Definition: DeclObjC.h:439
void setSuperClass(TypeSourceInfo *superClass)
Definition: DeclObjC.h:1587
method_range methods() const
Definition: DeclObjC.h:1036
SourceRange getSourceRange() const
Definition: DeclObjC.h:707
DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc, IdentifierInfo **IdentList, SourceLocation *IdentLocs, ArrayRef< ObjCTypeParamList *> TypeParamLists, unsigned NumElts)
int Category
Definition: Format.cpp:1714
void ClearStorageClassSpecs()
Definition: DeclSpec.h:455
void setReturnType(QualType T)
Definition: DeclObjC.h:323
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:1555
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:6511
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:1161
IdentifierTable & Idents
Definition: ASTContext.h:569
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:6161
bool isInvalidType() const
Definition: DeclSpec.h:2453
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:985
void MatchAllMethodDeclarations(const SelectorSet &InsMap, const SelectorSet &ClsMap, SelectorSet &InsMapSeen, SelectorSet &ClsMapSeen, ObjCImplDecl *IMPDecl, ObjCContainerDecl *IDecl, bool &IncompleteImpl, bool ImmediateClass, bool WarnCategoryMethodImpl=false)
MatchAllMethodDeclarations - Check methods declaraed in interface or or protocol against those declar...
bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall)
Check whether the given method, which must be in the &#39;init&#39; family, is a valid member of that family...
void setMethod(ObjCMethodDecl *M)
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2685
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:2666
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:1455
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:968
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1244
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:422
static ObjCCategoryDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation AtLoc, SourceLocation ClassNameLoc, SourceLocation CategoryNameLoc, IdentifierInfo *Id, ObjCInterfaceDecl *IDecl, ObjCTypeParamList *typeParamList, SourceLocation IvarLBraceLoc=SourceLocation(), SourceLocation IvarRBraceLoc=SourceLocation())
Definition: DeclObjC.cpp:1986
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:12682
Decl * ActOnObjCContainerStartDefinition(Decl *IDecl)
Definition: SemaDecl.cpp:15469
ObjCContainerKind
Definition: Sema.h:8247
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:2934
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:657
Selector GetNullarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing a nullary selector.
Definition: ASTContext.h:3029
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Definition: Sema.h:1209
Represents a declaration of a type.
Definition: Decl.h:2907
static ObjCAtDefsFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, Expr *BW)
Definition: DeclObjC.cpp:1825
iterator begin()
Definition: DeclGroup.h:99
void setExceptionVariable(bool EV)
Definition: Decl.h:1314
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:2209
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:4301
unsigned Align
Definition: ASTContext.h:144
b
Definition: emmintrin.h:321
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3907
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:855
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2063
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1952
const LangOptions & getLangOpts() const
Definition: Sema.h:1285
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1879
bool isScalarType() const
Definition: Type.h:6732
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:2176
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:618
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:1171
QualType getReturnType() const
Definition: DeclObjC.h:322
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5843
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:2137
const LangOptions & LangOpts
Definition: Sema.h:372
This object can be modified without requiring retains or releases.
Definition: Type.h:158
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:3792
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:2758
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:1136
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:1871
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
visible_extensions_range visible_extensions() const
Definition: DeclObjC.h:1722
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:573
ResultTypeCompatibilityKind
Describes the compatibility of a result type with its method.
Definition: Sema.h:8641
llvm::SmallPtrSet< Selector, 8 > SelectorSet
Definition: Sema.h:3610
bool inferObjCARCLifetime(ValueDecl *decl)
Definition: SemaDecl.cpp:5948
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:629
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:6217
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:8470
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:2694
unsigned ivar_size() const
Definition: DeclObjC.h:1475
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2999
bool hasDefinition() const
Determine whether this protocol has a definition.
Definition: DeclObjC.h:2197
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:189
Type source information for an attributed type.
Definition: TypeLoc.h:851
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:3220
ObjCMethodList * getNext() const
static ObjCMethodDecl * Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl, bool isInstance=true, bool isVariadic=false, bool isPropertyAccessor=false, bool isImplicitlyDeclared=false, bool isDefined=false, ImplementationControl impControl=None, bool HasRelatedResultType=false)
Definition: DeclObjC.cpp:809
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:1459
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:4549
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:6916
TypeResult ActOnTypeName(Scope *S, Declarator &D)
Definition: SemaType.cpp:5815
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:86
bool hasRelatedResultType() const
Determine whether this method has a result type that is related to the message receiver&#39;s type...
Definition: DeclObjC.h:256
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:131
bool isThisDeclarationADefinition() const
Determine whether this particular declaration is also the definition.
Definition: DeclObjC.h:2220
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:451
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:1123
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:1479
void setRelatedResultType(bool RRT=true)
Note whether this method has a related result type.
Definition: DeclObjC.h:261
field_iterator field_end() const
Definition: Decl.h:3844
static ObjCTypeParamDecl * Create(ASTContext &ctx, DeclContext *dc, ObjCTypeParamVariance variance, SourceLocation varianceLoc, unsigned index, SourceLocation nameLoc, IdentifierInfo *name, SourceLocation colonLoc, TypeSourceInfo *boundInfo)
Definition: DeclObjC.cpp:1384
bool isFileContext() const
Definition: DeclBase.h:1849
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isObjCClassType() const
Definition: Type.h:6523
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:5926
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:1433
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition: Type.cpp:1998
void setDefined(bool isDefined)
Definition: DeclObjC.h:440
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7826
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:450
ParmVarDecl *const * param_iterator
Definition: DeclObjC.h:343
void setImplementation(ObjCImplementationDecl *ImplD)
Definition: DeclObjC.cpp:1561
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:3892
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:207
propimpl_range property_impls() const
Definition: DeclObjC.h:2466
bool hasSameNullabilityTypeQualifier(QualType SubT, QualType SuperT, bool IsParam) const
Definition: ASTContext.h:2325
ScalarTypeKind
Definition: Type.h:2090
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:421
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:1370
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:320
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:1398
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:708
bool isObjCClass() const
Definition: Type.h:5677
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:413
void removeCVRQualifiers(unsigned mask)
Definition: Type.h:277
ObjCTypeParamVariance
Describes the variance of a given generic parameter.
Definition: DeclObjC.h:533
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:294
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType)
ObjCDeclQualifier
ObjCDeclQualifier - Qualifier used on types in method declarations.
Definition: DeclSpec.h:807
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:2199
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1772
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1792
std::string getAsString() const
Derive the full selector name (e.g.
SelectorTable & Selectors
Definition: ASTContext.h:570
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:441
ASTContext & getASTContext() const
Definition: Sema.h:1292
StringRef getPlatformName() const
Retrieve the name of the platform as it is used in the availability attribute.
Definition: TargetInfo.h:1243
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:1467
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:6258
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5808
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
Definition: Diagnostic.h:1292
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:2063
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:144
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:1491
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:2279
CanQualType VoidTy
Definition: ASTContext.h:1014
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:24
void setOverriding(bool IsOver)
Definition: DeclObjC.h:450
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:3266
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:6488
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:728
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:2343
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:211
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:1809
bool ObjCIsDesignatedInit
True when this is a method marked as a designated initializer.
Definition: ScopeInfo.h:139
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super&#39;s implementation, such as -dealloc...
Definition: ScopeInfo.h:136
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclObjC.h:246
TypeLoc findExplicitQualifierLoc() const
Find a type with the location of an explicit type qualifier.
Definition: TypeLoc.cpp:419
bool isImplicitInterfaceDecl() const
isImplicitInterfaceDecl - check that this is an implicitly declared ObjCInterfaceDecl node...
Definition: DeclObjC.h:1892
void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList)
bool isVectorType() const
Definition: Type.h:6476
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:561
static bool HelperIsMethodInObjCType(Sema &S, Selector Sel, QualType ObjectType)
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1548
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2320
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:839
ObjCTypeParamDecl * back() const
Definition: DeclObjC.h:694
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;...
Definition: ASTContext.h:1735
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:1621
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:1899
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1977
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2949
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:2439
bool isObjCId() const
Definition: Type.h:5673
Dataflow Directional Tag Classes.
llvm::iterator_range< specific_decl_iterator< ObjCIvarDecl > > ivar_range
Definition: DeclObjC.h:1455
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:2437
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:1218
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:149
QualType getUnderlyingType() const
Definition: Decl.h:3004
const ObjCProtocolList & getReferencedProtocols() const
Definition: DeclObjC.h:1340
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:1548
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:558
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:976
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:1237
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:2148
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
Definition: ScopeInfo.h:153
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:326
IdentifierResolver IdResolver
Definition: Sema.h:872
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:12965
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:2048
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:682
Represents a pointer to an Objective C object.
Definition: Type.h:5864
static bool HasExplicitOwnershipAttr(Sema &S, ParmVarDecl *Param)
HasExplicitOwnershipAttr - returns true when pointer to ObjC pointer has explicit ownership attribute...
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:150
void RemoveDecl(Decl *D)
Definition: Scope.h:293
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2551
bool isIncompleteArrayType() const
Definition: Type.h:6448
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4438
void setNext(ObjCMethodList *L)
bool empty() const
Definition: Type.h:415
static bool isMethodContextSameForKindofLookup(ObjCMethodDecl *Method, ObjCMethodDecl *MethodInList)
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6677
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
SourceLocation getSelectorLoc(unsigned Index) const
Definition: DeclObjC.h:294
void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl *IMPDecl, ObjCContainerDecl *IDecl, bool IncompleteImpl=false)
ImplMethodsVsClassMethods - This is main routine to warn if any method remains unimplemented in the c...
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
bool isObjCQualifiedIdType() const
Definition: Type.h:6505
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:715
DeclContext * getCurLexicalContext() const
Definition: Sema.h:11143
static const TST TST_typename
Definition: DeclSpec.h:297
param_const_iterator param_begin() const
Definition: DeclObjC.h:347
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2705
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:1737
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2296
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:1090
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:1305
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:1514
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:3755
The "class" keyword.
Definition: Type.h:5112
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
Definition: DeclSpec.h:2160
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:2637
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:546
SourceManager & getSourceManager()
Definition: ASTContext.h:665
void setObjCMethodScopeInfo(unsigned parameterIndex)
Definition: Decl.h:1592
bool isObjCObjectType() const
Definition: Type.h:6492
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2062
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:786
bool hasMoreThanOneDecl() const
bool IsClassExtension() const
Definition: DeclObjC.h:2389
ImplementationControl getImplementationControl() const
Definition: DeclObjC.h:481
RedeclarationKind forRedeclarationInCurContext()
Definition: Sema.h:3284
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2143
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2280
ObjCInterfaceDecl * getObjCInterfaceDecl(IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
Definition: SemaDecl.cpp:1883
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:240
Reading or writing from this object requires a barrier call.
Definition: Type.h:168
No particular method family.
const ObjCPropertyDecl * findPropertyDecl(bool CheckOverrides=true) const
Returns the property associated with this method&#39;s selector.
Definition: DeclObjC.cpp:1301
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:221
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:6222
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
Definition: ParsedAttr.h:629
static void HelperSelectorsForTypoCorrection(SmallVectorImpl< const ObjCMethodDecl *> &BestMethod, StringRef Typo, const ObjCMethodDecl *Method)
bool isValid() const
bool isVoidType() const
Definition: Type.h:6643
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:1439
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:6169
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1944
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:944
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:1864
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:386
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:636
ImplicitParamDecl * getCmdDecl() const
Definition: DeclObjC.h:415
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:426
void addAttr(Attr *A)
Definition: DeclBase.cpp:829
SourceManager & getSourceManager() const
Definition: Sema.h:1290
__DEVICE__ int min(int __a, int __b)
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclObjC.h:282
bool isInlineSpecified() const
Definition: DeclSpec.h:558
a linked list of methods with the same selector name but different signatures.
std::pair< ObjCMethodList, ObjCMethodList > GlobalMethods
Definition: Sema.h:1200
#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, SHOWINSYSHEADER, CATEGORY)
uint64_t Width
Definition: ASTContext.h:143
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2108
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:821
result[0]
Definition: emmintrin.h:120
bool isUnion() const
Definition: Decl.h:3285
ObjCTypeParamVariance getVariance() const
Determine the variance of this type parameter.
Definition: DeclObjC.h:601
void ActOnObjCContainerFinishDefinition()
Definition: SemaDecl.cpp:15544
void setObjCDeclQualifier(ObjCDeclQualifier QTVal)
Definition: Decl.h:1625
ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed...
Definition: DeclSpec.h:1234
QualType getType() const
Definition: Decl.h:647
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:298
ASTContext & Context
Definition: Sema.h:374
static SourceRange getTypeRange(TypeSourceInfo *TSI)
This represents a decl that may have a name.
Definition: Decl.h:248
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1591
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:2044
void setVariance(ObjCTypeParamVariance variance)
Set the variance of this type parameter.
Definition: DeclObjC.h:606
void setTypeSourceInfo(TypeSourceInfo *newType)
Definition: Decl.h:3011
void DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl< ObjCMethodDecl *> &Methods, Selector Sel, SourceRange R, bool receiverIdOrClass)
ObjCMethodDecl * getInstanceMethod(Selector Sel, bool AllowHidden=false) const
Definition: DeclObjC.h:1086
bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS, bool ForCompare)
ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an ObjCQualifiedIDType.
bool isPropertyAccessor() const
Definition: DeclObjC.h:431
DeclResult actOnObjCTypeParam(Scope *S, ObjCTypeParamVariance variance, SourceLocation varianceLoc, unsigned index, IdentifierInfo *paramName, SourceLocation paramLoc, SourceLocation colonLoc, ParsedType typeBound)
SourceLocation getLAngleLoc() const
Definition: DeclObjC.h:699
static void diagnoseUseOfProtocols(Sema &TheSema, ObjCContainerDecl *CD, ObjCProtocolDecl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs)
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:630
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
Definition: SemaDecl.cpp:3672
ObjCContainerKind getObjCContainerKind() const
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
void setType(QualType newType)
Definition: Decl.h:648
SourceLocation getBegin() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:710
unsigned size() const
Determine the number of type parameters in this list.
Definition: DeclObjC.h:676
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:2498
The parameter is invariant: must match exactly.
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1599
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:8469
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
Definition: SemaType.cpp:5250
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:366
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2728
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1315
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:1063
ObjCCategoryDecl * FindCategoryDeclaration(IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
Definition: DeclObjC.cpp:1663
A RAII object to temporarily push a declaration context.
Definition: Sema.h:768
res[0]
Definition: emmintrin.h:1141