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