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