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