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