1 //===--- SemaExprObjC.cpp - Semantic Analysis for ObjC Expressions --------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements semantic analysis for Objective-C expressions. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/Sema/SemaInternal.h" 14 #include "clang/AST/ASTContext.h" 15 #include "clang/AST/DeclObjC.h" 16 #include "clang/AST/ExprObjC.h" 17 #include "clang/AST/StmtVisitor.h" 18 #include "clang/AST/TypeLoc.h" 19 #include "clang/Analysis/DomainSpecific/CocoaConventions.h" 20 #include "clang/Edit/Commit.h" 21 #include "clang/Edit/Rewriters.h" 22 #include "clang/Lex/Preprocessor.h" 23 #include "clang/Sema/Initialization.h" 24 #include "clang/Sema/Lookup.h" 25 #include "clang/Sema/Scope.h" 26 #include "clang/Sema/ScopeInfo.h" 27 #include "llvm/ADT/SmallString.h" 28 #include "llvm/Support/ConvertUTF.h" 29 30 using namespace clang; 31 using namespace sema; 32 using llvm::makeArrayRef; 33 34 ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs, 35 ArrayRef<Expr *> Strings) { 36 // Most ObjC strings are formed out of a single piece. However, we *can* 37 // have strings formed out of multiple @ strings with multiple pptokens in 38 // each one, e.g. @"foo" "bar" @"baz" "qux" which need to be turned into one 39 // StringLiteral for ObjCStringLiteral to hold onto. 40 StringLiteral *S = cast<StringLiteral>(Strings[0]); 41 42 // If we have a multi-part string, merge it all together. 43 if (Strings.size() != 1) { 44 // Concatenate objc strings. 45 SmallString<128> StrBuf; 46 SmallVector<SourceLocation, 8> StrLocs; 47 48 for (Expr *E : Strings) { 49 S = cast<StringLiteral>(E); 50 51 // ObjC strings can't be wide or UTF. 52 if (!S->isAscii()) { 53 Diag(S->getBeginLoc(), diag::err_cfstring_literal_not_string_constant) 54 << S->getSourceRange(); 55 return true; 56 } 57 58 // Append the string. 59 StrBuf += S->getString(); 60 61 // Get the locations of the string tokens. 62 StrLocs.append(S->tokloc_begin(), S->tokloc_end()); 63 } 64 65 // Create the aggregate string with the appropriate content and location 66 // information. 67 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType()); 68 assert(CAT && "String literal not of constant array type!"); 69 QualType StrTy = Context.getConstantArrayType( 70 CAT->getElementType(), llvm::APInt(32, StrBuf.size() + 1), 71 CAT->getSizeModifier(), CAT->getIndexTypeCVRQualifiers()); 72 S = StringLiteral::Create(Context, StrBuf, StringLiteral::Ascii, 73 /*Pascal=*/false, StrTy, &StrLocs[0], 74 StrLocs.size()); 75 } 76 77 return BuildObjCStringLiteral(AtLocs[0], S); 78 } 79 80 ExprResult Sema::BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S){ 81 // Verify that this composite string is acceptable for ObjC strings. 82 if (CheckObjCString(S)) 83 return true; 84 85 // Initialize the constant string interface lazily. This assumes 86 // the NSString interface is seen in this translation unit. Note: We 87 // don't use NSConstantString, since the runtime team considers this 88 // interface private (even though it appears in the header files). 89 QualType Ty = Context.getObjCConstantStringInterface(); 90 if (!Ty.isNull()) { 91 Ty = Context.getObjCObjectPointerType(Ty); 92 } else if (getLangOpts().NoConstantCFStrings) { 93 IdentifierInfo *NSIdent=nullptr; 94 std::string StringClass(getLangOpts().ObjCConstantStringClass); 95 96 if (StringClass.empty()) 97 NSIdent = &Context.Idents.get("NSConstantString"); 98 else 99 NSIdent = &Context.Idents.get(StringClass); 100 101 NamedDecl *IF = LookupSingleName(TUScope, NSIdent, AtLoc, 102 LookupOrdinaryName); 103 if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) { 104 Context.setObjCConstantStringInterface(StrIF); 105 Ty = Context.getObjCConstantStringInterface(); 106 Ty = Context.getObjCObjectPointerType(Ty); 107 } else { 108 // If there is no NSConstantString interface defined then treat this 109 // as error and recover from it. 110 Diag(S->getBeginLoc(), diag::err_no_nsconstant_string_class) 111 << NSIdent << S->getSourceRange(); 112 Ty = Context.getObjCIdType(); 113 } 114 } else { 115 IdentifierInfo *NSIdent = NSAPIObj->getNSClassId(NSAPI::ClassId_NSString); 116 NamedDecl *IF = LookupSingleName(TUScope, NSIdent, AtLoc, 117 LookupOrdinaryName); 118 if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) { 119 Context.setObjCConstantStringInterface(StrIF); 120 Ty = Context.getObjCConstantStringInterface(); 121 Ty = Context.getObjCObjectPointerType(Ty); 122 } else { 123 // If there is no NSString interface defined, implicitly declare 124 // a @class NSString; and use that instead. This is to make sure 125 // type of an NSString literal is represented correctly, instead of 126 // being an 'id' type. 127 Ty = Context.getObjCNSStringType(); 128 if (Ty.isNull()) { 129 ObjCInterfaceDecl *NSStringIDecl = 130 ObjCInterfaceDecl::Create (Context, 131 Context.getTranslationUnitDecl(), 132 SourceLocation(), NSIdent, 133 nullptr, nullptr, SourceLocation()); 134 Ty = Context.getObjCInterfaceType(NSStringIDecl); 135 Context.setObjCNSStringType(Ty); 136 } 137 Ty = Context.getObjCObjectPointerType(Ty); 138 } 139 } 140 141 return new (Context) ObjCStringLiteral(S, Ty, AtLoc); 142 } 143 144 /// Emits an error if the given method does not exist, or if the return 145 /// type is not an Objective-C object. 146 static bool validateBoxingMethod(Sema &S, SourceLocation Loc, 147 const ObjCInterfaceDecl *Class, 148 Selector Sel, const ObjCMethodDecl *Method) { 149 if (!Method) { 150 // FIXME: Is there a better way to avoid quotes than using getName()? 151 S.Diag(Loc, diag::err_undeclared_boxing_method) << Sel << Class->getName(); 152 return false; 153 } 154 155 // Make sure the return type is reasonable. 156 QualType ReturnType = Method->getReturnType(); 157 if (!ReturnType->isObjCObjectPointerType()) { 158 S.Diag(Loc, diag::err_objc_literal_method_sig) 159 << Sel; 160 S.Diag(Method->getLocation(), diag::note_objc_literal_method_return) 161 << ReturnType; 162 return false; 163 } 164 165 return true; 166 } 167 168 /// Maps ObjCLiteralKind to NSClassIdKindKind 169 static NSAPI::NSClassIdKindKind ClassKindFromLiteralKind( 170 Sema::ObjCLiteralKind LiteralKind) { 171 switch (LiteralKind) { 172 case Sema::LK_Array: 173 return NSAPI::ClassId_NSArray; 174 case Sema::LK_Dictionary: 175 return NSAPI::ClassId_NSDictionary; 176 case Sema::LK_Numeric: 177 return NSAPI::ClassId_NSNumber; 178 case Sema::LK_String: 179 return NSAPI::ClassId_NSString; 180 case Sema::LK_Boxed: 181 return NSAPI::ClassId_NSValue; 182 183 // there is no corresponding matching 184 // between LK_None/LK_Block and NSClassIdKindKind 185 case Sema::LK_Block: 186 case Sema::LK_None: 187 break; 188 } 189 llvm_unreachable("LiteralKind can't be converted into a ClassKind"); 190 } 191 192 /// Validates ObjCInterfaceDecl availability. 193 /// ObjCInterfaceDecl, used to create ObjC literals, should be defined 194 /// if clang not in a debugger mode. 195 static bool ValidateObjCLiteralInterfaceDecl(Sema &S, ObjCInterfaceDecl *Decl, 196 SourceLocation Loc, 197 Sema::ObjCLiteralKind LiteralKind) { 198 if (!Decl) { 199 NSAPI::NSClassIdKindKind Kind = ClassKindFromLiteralKind(LiteralKind); 200 IdentifierInfo *II = S.NSAPIObj->getNSClassId(Kind); 201 S.Diag(Loc, diag::err_undeclared_objc_literal_class) 202 << II->getName() << LiteralKind; 203 return false; 204 } else if (!Decl->hasDefinition() && !S.getLangOpts().DebuggerObjCLiteral) { 205 S.Diag(Loc, diag::err_undeclared_objc_literal_class) 206 << Decl->getName() << LiteralKind; 207 S.Diag(Decl->getLocation(), diag::note_forward_class); 208 return false; 209 } 210 211 return true; 212 } 213 214 /// Looks up ObjCInterfaceDecl of a given NSClassIdKindKind. 215 /// Used to create ObjC literals, such as NSDictionary (@{}), 216 /// NSArray (@[]) and Boxed Expressions (@()) 217 static ObjCInterfaceDecl *LookupObjCInterfaceDeclForLiteral(Sema &S, 218 SourceLocation Loc, 219 Sema::ObjCLiteralKind LiteralKind) { 220 NSAPI::NSClassIdKindKind ClassKind = ClassKindFromLiteralKind(LiteralKind); 221 IdentifierInfo *II = S.NSAPIObj->getNSClassId(ClassKind); 222 NamedDecl *IF = S.LookupSingleName(S.TUScope, II, Loc, 223 Sema::LookupOrdinaryName); 224 ObjCInterfaceDecl *ID = dyn_cast_or_null<ObjCInterfaceDecl>(IF); 225 if (!ID && S.getLangOpts().DebuggerObjCLiteral) { 226 ASTContext &Context = S.Context; 227 TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 228 ID = ObjCInterfaceDecl::Create (Context, TU, SourceLocation(), II, 229 nullptr, nullptr, SourceLocation()); 230 } 231 232 if (!ValidateObjCLiteralInterfaceDecl(S, ID, Loc, LiteralKind)) { 233 ID = nullptr; 234 } 235 236 return ID; 237 } 238 239 /// Retrieve the NSNumber factory method that should be used to create 240 /// an Objective-C literal for the given type. 241 static ObjCMethodDecl *getNSNumberFactoryMethod(Sema &S, SourceLocation Loc, 242 QualType NumberType, 243 bool isLiteral = false, 244 SourceRange R = SourceRange()) { 245 Optional<NSAPI::NSNumberLiteralMethodKind> Kind = 246 S.NSAPIObj->getNSNumberFactoryMethodKind(NumberType); 247 248 if (!Kind) { 249 if (isLiteral) { 250 S.Diag(Loc, diag::err_invalid_nsnumber_type) 251 << NumberType << R; 252 } 253 return nullptr; 254 } 255 256 // If we already looked up this method, we're done. 257 if (S.NSNumberLiteralMethods[*Kind]) 258 return S.NSNumberLiteralMethods[*Kind]; 259 260 Selector Sel = S.NSAPIObj->getNSNumberLiteralSelector(*Kind, 261 /*Instance=*/false); 262 263 ASTContext &CX = S.Context; 264 265 // Look up the NSNumber class, if we haven't done so already. It's cached 266 // in the Sema instance. 267 if (!S.NSNumberDecl) { 268 S.NSNumberDecl = LookupObjCInterfaceDeclForLiteral(S, Loc, 269 Sema::LK_Numeric); 270 if (!S.NSNumberDecl) { 271 return nullptr; 272 } 273 } 274 275 if (S.NSNumberPointer.isNull()) { 276 // generate the pointer to NSNumber type. 277 QualType NSNumberObject = CX.getObjCInterfaceType(S.NSNumberDecl); 278 S.NSNumberPointer = CX.getObjCObjectPointerType(NSNumberObject); 279 } 280 281 // Look for the appropriate method within NSNumber. 282 ObjCMethodDecl *Method = S.NSNumberDecl->lookupClassMethod(Sel); 283 if (!Method && S.getLangOpts().DebuggerObjCLiteral) { 284 // create a stub definition this NSNumber factory method. 285 TypeSourceInfo *ReturnTInfo = nullptr; 286 Method = 287 ObjCMethodDecl::Create(CX, SourceLocation(), SourceLocation(), Sel, 288 S.NSNumberPointer, ReturnTInfo, S.NSNumberDecl, 289 /*isInstance=*/false, /*isVariadic=*/false, 290 /*isPropertyAccessor=*/false, 291 /*isImplicitlyDeclared=*/true, 292 /*isDefined=*/false, ObjCMethodDecl::Required, 293 /*HasRelatedResultType=*/false); 294 ParmVarDecl *value = ParmVarDecl::Create(S.Context, Method, 295 SourceLocation(), SourceLocation(), 296 &CX.Idents.get("value"), 297 NumberType, /*TInfo=*/nullptr, 298 SC_None, nullptr); 299 Method->setMethodParams(S.Context, value, None); 300 } 301 302 if (!validateBoxingMethod(S, Loc, S.NSNumberDecl, Sel, Method)) 303 return nullptr; 304 305 // Note: if the parameter type is out-of-line, we'll catch it later in the 306 // implicit conversion. 307 308 S.NSNumberLiteralMethods[*Kind] = Method; 309 return Method; 310 } 311 312 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the 313 /// numeric literal expression. Type of the expression will be "NSNumber *". 314 ExprResult Sema::BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number) { 315 // Determine the type of the literal. 316 QualType NumberType = Number->getType(); 317 if (CharacterLiteral *Char = dyn_cast<CharacterLiteral>(Number)) { 318 // In C, character literals have type 'int'. That's not the type we want 319 // to use to determine the Objective-c literal kind. 320 switch (Char->getKind()) { 321 case CharacterLiteral::Ascii: 322 case CharacterLiteral::UTF8: 323 NumberType = Context.CharTy; 324 break; 325 326 case CharacterLiteral::Wide: 327 NumberType = Context.getWideCharType(); 328 break; 329 330 case CharacterLiteral::UTF16: 331 NumberType = Context.Char16Ty; 332 break; 333 334 case CharacterLiteral::UTF32: 335 NumberType = Context.Char32Ty; 336 break; 337 } 338 } 339 340 // Look for the appropriate method within NSNumber. 341 // Construct the literal. 342 SourceRange NR(Number->getSourceRange()); 343 ObjCMethodDecl *Method = getNSNumberFactoryMethod(*this, AtLoc, NumberType, 344 true, NR); 345 if (!Method) 346 return ExprError(); 347 348 // Convert the number to the type that the parameter expects. 349 ParmVarDecl *ParamDecl = Method->parameters()[0]; 350 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context, 351 ParamDecl); 352 ExprResult ConvertedNumber = PerformCopyInitialization(Entity, 353 SourceLocation(), 354 Number); 355 if (ConvertedNumber.isInvalid()) 356 return ExprError(); 357 Number = ConvertedNumber.get(); 358 359 // Use the effective source range of the literal, including the leading '@'. 360 return MaybeBindToTemporary( 361 new (Context) ObjCBoxedExpr(Number, NSNumberPointer, Method, 362 SourceRange(AtLoc, NR.getEnd()))); 363 } 364 365 ExprResult Sema::ActOnObjCBoolLiteral(SourceLocation AtLoc, 366 SourceLocation ValueLoc, 367 bool Value) { 368 ExprResult Inner; 369 if (getLangOpts().CPlusPlus) { 370 Inner = ActOnCXXBoolLiteral(ValueLoc, Value? tok::kw_true : tok::kw_false); 371 } else { 372 // C doesn't actually have a way to represent literal values of type 373 // _Bool. So, we'll use 0/1 and implicit cast to _Bool. 374 Inner = ActOnIntegerConstant(ValueLoc, Value? 1 : 0); 375 Inner = ImpCastExprToType(Inner.get(), Context.BoolTy, 376 CK_IntegralToBoolean); 377 } 378 379 return BuildObjCNumericLiteral(AtLoc, Inner.get()); 380 } 381 382 /// Check that the given expression is a valid element of an Objective-C 383 /// collection literal. 384 static ExprResult CheckObjCCollectionLiteralElement(Sema &S, Expr *Element, 385 QualType T, 386 bool ArrayLiteral = false) { 387 // If the expression is type-dependent, there's nothing for us to do. 388 if (Element->isTypeDependent()) 389 return Element; 390 391 ExprResult Result = S.CheckPlaceholderExpr(Element); 392 if (Result.isInvalid()) 393 return ExprError(); 394 Element = Result.get(); 395 396 // In C++, check for an implicit conversion to an Objective-C object pointer 397 // type. 398 if (S.getLangOpts().CPlusPlus && Element->getType()->isRecordType()) { 399 InitializedEntity Entity 400 = InitializedEntity::InitializeParameter(S.Context, T, 401 /*Consumed=*/false); 402 InitializationKind Kind = InitializationKind::CreateCopy( 403 Element->getBeginLoc(), SourceLocation()); 404 InitializationSequence Seq(S, Entity, Kind, Element); 405 if (!Seq.Failed()) 406 return Seq.Perform(S, Entity, Kind, Element); 407 } 408 409 Expr *OrigElement = Element; 410 411 // Perform lvalue-to-rvalue conversion. 412 Result = S.DefaultLvalueConversion(Element); 413 if (Result.isInvalid()) 414 return ExprError(); 415 Element = Result.get(); 416 417 // Make sure that we have an Objective-C pointer type or block. 418 if (!Element->getType()->isObjCObjectPointerType() && 419 !Element->getType()->isBlockPointerType()) { 420 bool Recovered = false; 421 422 // If this is potentially an Objective-C numeric literal, add the '@'. 423 if (isa<IntegerLiteral>(OrigElement) || 424 isa<CharacterLiteral>(OrigElement) || 425 isa<FloatingLiteral>(OrigElement) || 426 isa<ObjCBoolLiteralExpr>(OrigElement) || 427 isa<CXXBoolLiteralExpr>(OrigElement)) { 428 if (S.NSAPIObj->getNSNumberFactoryMethodKind(OrigElement->getType())) { 429 int Which = isa<CharacterLiteral>(OrigElement) ? 1 430 : (isa<CXXBoolLiteralExpr>(OrigElement) || 431 isa<ObjCBoolLiteralExpr>(OrigElement)) ? 2 432 : 3; 433 434 S.Diag(OrigElement->getBeginLoc(), diag::err_box_literal_collection) 435 << Which << OrigElement->getSourceRange() 436 << FixItHint::CreateInsertion(OrigElement->getBeginLoc(), "@"); 437 438 Result = 439 S.BuildObjCNumericLiteral(OrigElement->getBeginLoc(), OrigElement); 440 if (Result.isInvalid()) 441 return ExprError(); 442 443 Element = Result.get(); 444 Recovered = true; 445 } 446 } 447 // If this is potentially an Objective-C string literal, add the '@'. 448 else if (StringLiteral *String = dyn_cast<StringLiteral>(OrigElement)) { 449 if (String->isAscii()) { 450 S.Diag(OrigElement->getBeginLoc(), diag::err_box_literal_collection) 451 << 0 << OrigElement->getSourceRange() 452 << FixItHint::CreateInsertion(OrigElement->getBeginLoc(), "@"); 453 454 Result = S.BuildObjCStringLiteral(OrigElement->getBeginLoc(), String); 455 if (Result.isInvalid()) 456 return ExprError(); 457 458 Element = Result.get(); 459 Recovered = true; 460 } 461 } 462 463 if (!Recovered) { 464 S.Diag(Element->getBeginLoc(), diag::err_invalid_collection_element) 465 << Element->getType(); 466 return ExprError(); 467 } 468 } 469 if (ArrayLiteral) 470 if (ObjCStringLiteral *getString = 471 dyn_cast<ObjCStringLiteral>(OrigElement)) { 472 if (StringLiteral *SL = getString->getString()) { 473 unsigned numConcat = SL->getNumConcatenated(); 474 if (numConcat > 1) { 475 // Only warn if the concatenated string doesn't come from a macro. 476 bool hasMacro = false; 477 for (unsigned i = 0; i < numConcat ; ++i) 478 if (SL->getStrTokenLoc(i).isMacroID()) { 479 hasMacro = true; 480 break; 481 } 482 if (!hasMacro) 483 S.Diag(Element->getBeginLoc(), 484 diag::warn_concatenated_nsarray_literal) 485 << Element->getType(); 486 } 487 } 488 } 489 490 // Make sure that the element has the type that the container factory 491 // function expects. 492 return S.PerformCopyInitialization( 493 InitializedEntity::InitializeParameter(S.Context, T, 494 /*Consumed=*/false), 495 Element->getBeginLoc(), Element); 496 } 497 498 ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) { 499 if (ValueExpr->isTypeDependent()) { 500 ObjCBoxedExpr *BoxedExpr = 501 new (Context) ObjCBoxedExpr(ValueExpr, Context.DependentTy, nullptr, SR); 502 return BoxedExpr; 503 } 504 ObjCMethodDecl *BoxingMethod = nullptr; 505 QualType BoxedType; 506 // Convert the expression to an RValue, so we can check for pointer types... 507 ExprResult RValue = DefaultFunctionArrayLvalueConversion(ValueExpr); 508 if (RValue.isInvalid()) { 509 return ExprError(); 510 } 511 SourceLocation Loc = SR.getBegin(); 512 ValueExpr = RValue.get(); 513 QualType ValueType(ValueExpr->getType()); 514 if (const PointerType *PT = ValueType->getAs<PointerType>()) { 515 QualType PointeeType = PT->getPointeeType(); 516 if (Context.hasSameUnqualifiedType(PointeeType, Context.CharTy)) { 517 518 if (!NSStringDecl) { 519 NSStringDecl = LookupObjCInterfaceDeclForLiteral(*this, Loc, 520 Sema::LK_String); 521 if (!NSStringDecl) { 522 return ExprError(); 523 } 524 QualType NSStringObject = Context.getObjCInterfaceType(NSStringDecl); 525 NSStringPointer = Context.getObjCObjectPointerType(NSStringObject); 526 } 527 528 // The boxed expression can be emitted as a compile time constant if it is 529 // a string literal whose character encoding is compatible with UTF-8. 530 if (auto *CE = dyn_cast<ImplicitCastExpr>(ValueExpr)) 531 if (CE->getCastKind() == CK_ArrayToPointerDecay) 532 if (auto *SL = 533 dyn_cast<StringLiteral>(CE->getSubExpr()->IgnoreParens())) { 534 assert((SL->isAscii() || SL->isUTF8()) && 535 "unexpected character encoding"); 536 StringRef Str = SL->getString(); 537 const llvm::UTF8 *StrBegin = Str.bytes_begin(); 538 const llvm::UTF8 *StrEnd = Str.bytes_end(); 539 // Check that this is a valid UTF-8 string. 540 if (llvm::isLegalUTF8String(&StrBegin, StrEnd)) { 541 BoxedType = Context.getAttributedType( 542 AttributedType::getNullabilityAttrKind( 543 NullabilityKind::NonNull), 544 NSStringPointer, NSStringPointer); 545 return new (Context) ObjCBoxedExpr(CE, BoxedType, nullptr, SR); 546 } 547 548 Diag(SL->getBeginLoc(), diag::warn_objc_boxing_invalid_utf8_string) 549 << NSStringPointer << SL->getSourceRange(); 550 } 551 552 if (!StringWithUTF8StringMethod) { 553 IdentifierInfo *II = &Context.Idents.get("stringWithUTF8String"); 554 Selector stringWithUTF8String = Context.Selectors.getUnarySelector(II); 555 556 // Look for the appropriate method within NSString. 557 BoxingMethod = NSStringDecl->lookupClassMethod(stringWithUTF8String); 558 if (!BoxingMethod && getLangOpts().DebuggerObjCLiteral) { 559 // Debugger needs to work even if NSString hasn't been defined. 560 TypeSourceInfo *ReturnTInfo = nullptr; 561 ObjCMethodDecl *M = ObjCMethodDecl::Create( 562 Context, SourceLocation(), SourceLocation(), stringWithUTF8String, 563 NSStringPointer, ReturnTInfo, NSStringDecl, 564 /*isInstance=*/false, /*isVariadic=*/false, 565 /*isPropertyAccessor=*/false, 566 /*isImplicitlyDeclared=*/true, 567 /*isDefined=*/false, ObjCMethodDecl::Required, 568 /*HasRelatedResultType=*/false); 569 QualType ConstCharType = Context.CharTy.withConst(); 570 ParmVarDecl *value = 571 ParmVarDecl::Create(Context, M, 572 SourceLocation(), SourceLocation(), 573 &Context.Idents.get("value"), 574 Context.getPointerType(ConstCharType), 575 /*TInfo=*/nullptr, 576 SC_None, nullptr); 577 M->setMethodParams(Context, value, None); 578 BoxingMethod = M; 579 } 580 581 if (!validateBoxingMethod(*this, Loc, NSStringDecl, 582 stringWithUTF8String, BoxingMethod)) 583 return ExprError(); 584 585 StringWithUTF8StringMethod = BoxingMethod; 586 } 587 588 BoxingMethod = StringWithUTF8StringMethod; 589 BoxedType = NSStringPointer; 590 // Transfer the nullability from method's return type. 591 Optional<NullabilityKind> Nullability = 592 BoxingMethod->getReturnType()->getNullability(Context); 593 if (Nullability) 594 BoxedType = Context.getAttributedType( 595 AttributedType::getNullabilityAttrKind(*Nullability), BoxedType, 596 BoxedType); 597 } 598 } else if (ValueType->isBuiltinType()) { 599 // The other types we support are numeric, char and BOOL/bool. We could also 600 // provide limited support for structure types, such as NSRange, NSRect, and 601 // NSSize. See NSValue (NSValueGeometryExtensions) in <Foundation/NSGeometry.h> 602 // for more details. 603 604 // Check for a top-level character literal. 605 if (const CharacterLiteral *Char = 606 dyn_cast<CharacterLiteral>(ValueExpr->IgnoreParens())) { 607 // In C, character literals have type 'int'. That's not the type we want 608 // to use to determine the Objective-c literal kind. 609 switch (Char->getKind()) { 610 case CharacterLiteral::Ascii: 611 case CharacterLiteral::UTF8: 612 ValueType = Context.CharTy; 613 break; 614 615 case CharacterLiteral::Wide: 616 ValueType = Context.getWideCharType(); 617 break; 618 619 case CharacterLiteral::UTF16: 620 ValueType = Context.Char16Ty; 621 break; 622 623 case CharacterLiteral::UTF32: 624 ValueType = Context.Char32Ty; 625 break; 626 } 627 } 628 // FIXME: Do I need to do anything special with BoolTy expressions? 629 630 // Look for the appropriate method within NSNumber. 631 BoxingMethod = getNSNumberFactoryMethod(*this, Loc, ValueType); 632 BoxedType = NSNumberPointer; 633 } else if (const EnumType *ET = ValueType->getAs<EnumType>()) { 634 if (!ET->getDecl()->isComplete()) { 635 Diag(Loc, diag::err_objc_incomplete_boxed_expression_type) 636 << ValueType << ValueExpr->getSourceRange(); 637 return ExprError(); 638 } 639 640 BoxingMethod = getNSNumberFactoryMethod(*this, Loc, 641 ET->getDecl()->getIntegerType()); 642 BoxedType = NSNumberPointer; 643 } else if (ValueType->isObjCBoxableRecordType()) { 644 // Support for structure types, that marked as objc_boxable 645 // struct __attribute__((objc_boxable)) s { ... }; 646 647 // Look up the NSValue class, if we haven't done so already. It's cached 648 // in the Sema instance. 649 if (!NSValueDecl) { 650 NSValueDecl = LookupObjCInterfaceDeclForLiteral(*this, Loc, 651 Sema::LK_Boxed); 652 if (!NSValueDecl) { 653 return ExprError(); 654 } 655 656 // generate the pointer to NSValue type. 657 QualType NSValueObject = Context.getObjCInterfaceType(NSValueDecl); 658 NSValuePointer = Context.getObjCObjectPointerType(NSValueObject); 659 } 660 661 if (!ValueWithBytesObjCTypeMethod) { 662 IdentifierInfo *II[] = { 663 &Context.Idents.get("valueWithBytes"), 664 &Context.Idents.get("objCType") 665 }; 666 Selector ValueWithBytesObjCType = Context.Selectors.getSelector(2, II); 667 668 // Look for the appropriate method within NSValue. 669 BoxingMethod = NSValueDecl->lookupClassMethod(ValueWithBytesObjCType); 670 if (!BoxingMethod && getLangOpts().DebuggerObjCLiteral) { 671 // Debugger needs to work even if NSValue hasn't been defined. 672 TypeSourceInfo *ReturnTInfo = nullptr; 673 ObjCMethodDecl *M = ObjCMethodDecl::Create( 674 Context, 675 SourceLocation(), 676 SourceLocation(), 677 ValueWithBytesObjCType, 678 NSValuePointer, 679 ReturnTInfo, 680 NSValueDecl, 681 /*isInstance=*/false, 682 /*isVariadic=*/false, 683 /*isPropertyAccessor=*/false, 684 /*isImplicitlyDeclared=*/true, 685 /*isDefined=*/false, 686 ObjCMethodDecl::Required, 687 /*HasRelatedResultType=*/false); 688 689 SmallVector<ParmVarDecl *, 2> Params; 690 691 ParmVarDecl *bytes = 692 ParmVarDecl::Create(Context, M, 693 SourceLocation(), SourceLocation(), 694 &Context.Idents.get("bytes"), 695 Context.VoidPtrTy.withConst(), 696 /*TInfo=*/nullptr, 697 SC_None, nullptr); 698 Params.push_back(bytes); 699 700 QualType ConstCharType = Context.CharTy.withConst(); 701 ParmVarDecl *type = 702 ParmVarDecl::Create(Context, M, 703 SourceLocation(), SourceLocation(), 704 &Context.Idents.get("type"), 705 Context.getPointerType(ConstCharType), 706 /*TInfo=*/nullptr, 707 SC_None, nullptr); 708 Params.push_back(type); 709 710 M->setMethodParams(Context, Params, None); 711 BoxingMethod = M; 712 } 713 714 if (!validateBoxingMethod(*this, Loc, NSValueDecl, 715 ValueWithBytesObjCType, BoxingMethod)) 716 return ExprError(); 717 718 ValueWithBytesObjCTypeMethod = BoxingMethod; 719 } 720 721 if (!ValueType.isTriviallyCopyableType(Context)) { 722 Diag(Loc, diag::err_objc_non_trivially_copyable_boxed_expression_type) 723 << ValueType << ValueExpr->getSourceRange(); 724 return ExprError(); 725 } 726 727 BoxingMethod = ValueWithBytesObjCTypeMethod; 728 BoxedType = NSValuePointer; 729 } 730 731 if (!BoxingMethod) { 732 Diag(Loc, diag::err_objc_illegal_boxed_expression_type) 733 << ValueType << ValueExpr->getSourceRange(); 734 return ExprError(); 735 } 736 737 DiagnoseUseOfDecl(BoxingMethod, Loc); 738 739 ExprResult ConvertedValueExpr; 740 if (ValueType->isObjCBoxableRecordType()) { 741 InitializedEntity IE = InitializedEntity::InitializeTemporary(ValueType); 742 ConvertedValueExpr = PerformCopyInitialization(IE, ValueExpr->getExprLoc(), 743 ValueExpr); 744 } else { 745 // Convert the expression to the type that the parameter requires. 746 ParmVarDecl *ParamDecl = BoxingMethod->parameters()[0]; 747 InitializedEntity IE = InitializedEntity::InitializeParameter(Context, 748 ParamDecl); 749 ConvertedValueExpr = PerformCopyInitialization(IE, SourceLocation(), 750 ValueExpr); 751 } 752 753 if (ConvertedValueExpr.isInvalid()) 754 return ExprError(); 755 ValueExpr = ConvertedValueExpr.get(); 756 757 ObjCBoxedExpr *BoxedExpr = 758 new (Context) ObjCBoxedExpr(ValueExpr, BoxedType, 759 BoxingMethod, SR); 760 return MaybeBindToTemporary(BoxedExpr); 761 } 762 763 /// Build an ObjC subscript pseudo-object expression, given that 764 /// that's supported by the runtime. 765 ExprResult Sema::BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr, 766 Expr *IndexExpr, 767 ObjCMethodDecl *getterMethod, 768 ObjCMethodDecl *setterMethod) { 769 assert(!LangOpts.isSubscriptPointerArithmetic()); 770 771 // We can't get dependent types here; our callers should have 772 // filtered them out. 773 assert((!BaseExpr->isTypeDependent() && !IndexExpr->isTypeDependent()) && 774 "base or index cannot have dependent type here"); 775 776 // Filter out placeholders in the index. In theory, overloads could 777 // be preserved here, although that might not actually work correctly. 778 ExprResult Result = CheckPlaceholderExpr(IndexExpr); 779 if (Result.isInvalid()) 780 return ExprError(); 781 IndexExpr = Result.get(); 782 783 // Perform lvalue-to-rvalue conversion on the base. 784 Result = DefaultLvalueConversion(BaseExpr); 785 if (Result.isInvalid()) 786 return ExprError(); 787 BaseExpr = Result.get(); 788 789 // Build the pseudo-object expression. 790 return new (Context) ObjCSubscriptRefExpr( 791 BaseExpr, IndexExpr, Context.PseudoObjectTy, VK_LValue, OK_ObjCSubscript, 792 getterMethod, setterMethod, RB); 793 } 794 795 ExprResult Sema::BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements) { 796 SourceLocation Loc = SR.getBegin(); 797 798 if (!NSArrayDecl) { 799 NSArrayDecl = LookupObjCInterfaceDeclForLiteral(*this, Loc, 800 Sema::LK_Array); 801 if (!NSArrayDecl) { 802 return ExprError(); 803 } 804 } 805 806 // Find the arrayWithObjects:count: method, if we haven't done so already. 807 QualType IdT = Context.getObjCIdType(); 808 if (!ArrayWithObjectsMethod) { 809 Selector 810 Sel = NSAPIObj->getNSArraySelector(NSAPI::NSArr_arrayWithObjectsCount); 811 ObjCMethodDecl *Method = NSArrayDecl->lookupClassMethod(Sel); 812 if (!Method && getLangOpts().DebuggerObjCLiteral) { 813 TypeSourceInfo *ReturnTInfo = nullptr; 814 Method = ObjCMethodDecl::Create( 815 Context, SourceLocation(), SourceLocation(), Sel, IdT, ReturnTInfo, 816 Context.getTranslationUnitDecl(), false /*Instance*/, 817 false /*isVariadic*/, 818 /*isPropertyAccessor=*/false, 819 /*isImplicitlyDeclared=*/true, /*isDefined=*/false, 820 ObjCMethodDecl::Required, false); 821 SmallVector<ParmVarDecl *, 2> Params; 822 ParmVarDecl *objects = ParmVarDecl::Create(Context, Method, 823 SourceLocation(), 824 SourceLocation(), 825 &Context.Idents.get("objects"), 826 Context.getPointerType(IdT), 827 /*TInfo=*/nullptr, 828 SC_None, nullptr); 829 Params.push_back(objects); 830 ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method, 831 SourceLocation(), 832 SourceLocation(), 833 &Context.Idents.get("cnt"), 834 Context.UnsignedLongTy, 835 /*TInfo=*/nullptr, SC_None, 836 nullptr); 837 Params.push_back(cnt); 838 Method->setMethodParams(Context, Params, None); 839 } 840 841 if (!validateBoxingMethod(*this, Loc, NSArrayDecl, Sel, Method)) 842 return ExprError(); 843 844 // Dig out the type that all elements should be converted to. 845 QualType T = Method->parameters()[0]->getType(); 846 const PointerType *PtrT = T->getAs<PointerType>(); 847 if (!PtrT || 848 !Context.hasSameUnqualifiedType(PtrT->getPointeeType(), IdT)) { 849 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 850 << Sel; 851 Diag(Method->parameters()[0]->getLocation(), 852 diag::note_objc_literal_method_param) 853 << 0 << T 854 << Context.getPointerType(IdT.withConst()); 855 return ExprError(); 856 } 857 858 // Check that the 'count' parameter is integral. 859 if (!Method->parameters()[1]->getType()->isIntegerType()) { 860 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 861 << Sel; 862 Diag(Method->parameters()[1]->getLocation(), 863 diag::note_objc_literal_method_param) 864 << 1 865 << Method->parameters()[1]->getType() 866 << "integral"; 867 return ExprError(); 868 } 869 870 // We've found a good +arrayWithObjects:count: method. Save it! 871 ArrayWithObjectsMethod = Method; 872 } 873 874 QualType ObjectsType = ArrayWithObjectsMethod->parameters()[0]->getType(); 875 QualType RequiredType = ObjectsType->castAs<PointerType>()->getPointeeType(); 876 877 // Check that each of the elements provided is valid in a collection literal, 878 // performing conversions as necessary. 879 Expr **ElementsBuffer = Elements.data(); 880 for (unsigned I = 0, N = Elements.size(); I != N; ++I) { 881 ExprResult Converted = CheckObjCCollectionLiteralElement(*this, 882 ElementsBuffer[I], 883 RequiredType, true); 884 if (Converted.isInvalid()) 885 return ExprError(); 886 887 ElementsBuffer[I] = Converted.get(); 888 } 889 890 QualType Ty 891 = Context.getObjCObjectPointerType( 892 Context.getObjCInterfaceType(NSArrayDecl)); 893 894 return MaybeBindToTemporary( 895 ObjCArrayLiteral::Create(Context, Elements, Ty, 896 ArrayWithObjectsMethod, SR)); 897 } 898 899 ExprResult Sema::BuildObjCDictionaryLiteral(SourceRange SR, 900 MutableArrayRef<ObjCDictionaryElement> Elements) { 901 SourceLocation Loc = SR.getBegin(); 902 903 if (!NSDictionaryDecl) { 904 NSDictionaryDecl = LookupObjCInterfaceDeclForLiteral(*this, Loc, 905 Sema::LK_Dictionary); 906 if (!NSDictionaryDecl) { 907 return ExprError(); 908 } 909 } 910 911 // Find the dictionaryWithObjects:forKeys:count: method, if we haven't done 912 // so already. 913 QualType IdT = Context.getObjCIdType(); 914 if (!DictionaryWithObjectsMethod) { 915 Selector Sel = NSAPIObj->getNSDictionarySelector( 916 NSAPI::NSDict_dictionaryWithObjectsForKeysCount); 917 ObjCMethodDecl *Method = NSDictionaryDecl->lookupClassMethod(Sel); 918 if (!Method && getLangOpts().DebuggerObjCLiteral) { 919 Method = ObjCMethodDecl::Create(Context, 920 SourceLocation(), SourceLocation(), Sel, 921 IdT, 922 nullptr /*TypeSourceInfo */, 923 Context.getTranslationUnitDecl(), 924 false /*Instance*/, false/*isVariadic*/, 925 /*isPropertyAccessor=*/false, 926 /*isImplicitlyDeclared=*/true, /*isDefined=*/false, 927 ObjCMethodDecl::Required, 928 false); 929 SmallVector<ParmVarDecl *, 3> Params; 930 ParmVarDecl *objects = ParmVarDecl::Create(Context, Method, 931 SourceLocation(), 932 SourceLocation(), 933 &Context.Idents.get("objects"), 934 Context.getPointerType(IdT), 935 /*TInfo=*/nullptr, SC_None, 936 nullptr); 937 Params.push_back(objects); 938 ParmVarDecl *keys = ParmVarDecl::Create(Context, Method, 939 SourceLocation(), 940 SourceLocation(), 941 &Context.Idents.get("keys"), 942 Context.getPointerType(IdT), 943 /*TInfo=*/nullptr, SC_None, 944 nullptr); 945 Params.push_back(keys); 946 ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method, 947 SourceLocation(), 948 SourceLocation(), 949 &Context.Idents.get("cnt"), 950 Context.UnsignedLongTy, 951 /*TInfo=*/nullptr, SC_None, 952 nullptr); 953 Params.push_back(cnt); 954 Method->setMethodParams(Context, Params, None); 955 } 956 957 if (!validateBoxingMethod(*this, SR.getBegin(), NSDictionaryDecl, Sel, 958 Method)) 959 return ExprError(); 960 961 // Dig out the type that all values should be converted to. 962 QualType ValueT = Method->parameters()[0]->getType(); 963 const PointerType *PtrValue = ValueT->getAs<PointerType>(); 964 if (!PtrValue || 965 !Context.hasSameUnqualifiedType(PtrValue->getPointeeType(), IdT)) { 966 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 967 << Sel; 968 Diag(Method->parameters()[0]->getLocation(), 969 diag::note_objc_literal_method_param) 970 << 0 << ValueT 971 << Context.getPointerType(IdT.withConst()); 972 return ExprError(); 973 } 974 975 // Dig out the type that all keys should be converted to. 976 QualType KeyT = Method->parameters()[1]->getType(); 977 const PointerType *PtrKey = KeyT->getAs<PointerType>(); 978 if (!PtrKey || 979 !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(), 980 IdT)) { 981 bool err = true; 982 if (PtrKey) { 983 if (QIDNSCopying.isNull()) { 984 // key argument of selector is id<NSCopying>? 985 if (ObjCProtocolDecl *NSCopyingPDecl = 986 LookupProtocol(&Context.Idents.get("NSCopying"), SR.getBegin())) { 987 ObjCProtocolDecl *PQ[] = {NSCopyingPDecl}; 988 QIDNSCopying = 989 Context.getObjCObjectType(Context.ObjCBuiltinIdTy, { }, 990 llvm::makeArrayRef( 991 (ObjCProtocolDecl**) PQ, 992 1), 993 false); 994 QIDNSCopying = Context.getObjCObjectPointerType(QIDNSCopying); 995 } 996 } 997 if (!QIDNSCopying.isNull()) 998 err = !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(), 999 QIDNSCopying); 1000 } 1001 1002 if (err) { 1003 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 1004 << Sel; 1005 Diag(Method->parameters()[1]->getLocation(), 1006 diag::note_objc_literal_method_param) 1007 << 1 << KeyT 1008 << Context.getPointerType(IdT.withConst()); 1009 return ExprError(); 1010 } 1011 } 1012 1013 // Check that the 'count' parameter is integral. 1014 QualType CountType = Method->parameters()[2]->getType(); 1015 if (!CountType->isIntegerType()) { 1016 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 1017 << Sel; 1018 Diag(Method->parameters()[2]->getLocation(), 1019 diag::note_objc_literal_method_param) 1020 << 2 << CountType 1021 << "integral"; 1022 return ExprError(); 1023 } 1024 1025 // We've found a good +dictionaryWithObjects:keys:count: method; save it! 1026 DictionaryWithObjectsMethod = Method; 1027 } 1028 1029 QualType ValuesT = DictionaryWithObjectsMethod->parameters()[0]->getType(); 1030 QualType ValueT = ValuesT->castAs<PointerType>()->getPointeeType(); 1031 QualType KeysT = DictionaryWithObjectsMethod->parameters()[1]->getType(); 1032 QualType KeyT = KeysT->castAs<PointerType>()->getPointeeType(); 1033 1034 // Check that each of the keys and values provided is valid in a collection 1035 // literal, performing conversions as necessary. 1036 bool HasPackExpansions = false; 1037 for (ObjCDictionaryElement &Element : Elements) { 1038 // Check the key. 1039 ExprResult Key = CheckObjCCollectionLiteralElement(*this, Element.Key, 1040 KeyT); 1041 if (Key.isInvalid()) 1042 return ExprError(); 1043 1044 // Check the value. 1045 ExprResult Value 1046 = CheckObjCCollectionLiteralElement(*this, Element.Value, ValueT); 1047 if (Value.isInvalid()) 1048 return ExprError(); 1049 1050 Element.Key = Key.get(); 1051 Element.Value = Value.get(); 1052 1053 if (Element.EllipsisLoc.isInvalid()) 1054 continue; 1055 1056 if (!Element.Key->containsUnexpandedParameterPack() && 1057 !Element.Value->containsUnexpandedParameterPack()) { 1058 Diag(Element.EllipsisLoc, 1059 diag::err_pack_expansion_without_parameter_packs) 1060 << SourceRange(Element.Key->getBeginLoc(), 1061 Element.Value->getEndLoc()); 1062 return ExprError(); 1063 } 1064 1065 HasPackExpansions = true; 1066 } 1067 1068 QualType Ty 1069 = Context.getObjCObjectPointerType( 1070 Context.getObjCInterfaceType(NSDictionaryDecl)); 1071 return MaybeBindToTemporary(ObjCDictionaryLiteral::Create( 1072 Context, Elements, HasPackExpansions, Ty, 1073 DictionaryWithObjectsMethod, SR)); 1074 } 1075 1076 ExprResult Sema::BuildObjCEncodeExpression(SourceLocation AtLoc, 1077 TypeSourceInfo *EncodedTypeInfo, 1078 SourceLocation RParenLoc) { 1079 QualType EncodedType = EncodedTypeInfo->getType(); 1080 QualType StrTy; 1081 if (EncodedType->isDependentType()) 1082 StrTy = Context.DependentTy; 1083 else { 1084 if (!EncodedType->getAsArrayTypeUnsafe() && //// Incomplete array is handled. 1085 !EncodedType->isVoidType()) // void is handled too. 1086 if (RequireCompleteType(AtLoc, EncodedType, 1087 diag::err_incomplete_type_objc_at_encode, 1088 EncodedTypeInfo->getTypeLoc())) 1089 return ExprError(); 1090 1091 std::string Str; 1092 QualType NotEncodedT; 1093 Context.getObjCEncodingForType(EncodedType, Str, nullptr, &NotEncodedT); 1094 if (!NotEncodedT.isNull()) 1095 Diag(AtLoc, diag::warn_incomplete_encoded_type) 1096 << EncodedType << NotEncodedT; 1097 1098 // The type of @encode is the same as the type of the corresponding string, 1099 // which is an array type. 1100 StrTy = Context.CharTy; 1101 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 1102 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings) 1103 StrTy.addConst(); 1104 StrTy = Context.getConstantArrayType(StrTy, llvm::APInt(32, Str.size()+1), 1105 ArrayType::Normal, 0); 1106 } 1107 1108 return new (Context) ObjCEncodeExpr(StrTy, EncodedTypeInfo, AtLoc, RParenLoc); 1109 } 1110 1111 ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc, 1112 SourceLocation EncodeLoc, 1113 SourceLocation LParenLoc, 1114 ParsedType ty, 1115 SourceLocation RParenLoc) { 1116 // FIXME: Preserve type source info ? 1117 TypeSourceInfo *TInfo; 1118 QualType EncodedType = GetTypeFromParser(ty, &TInfo); 1119 if (!TInfo) 1120 TInfo = Context.getTrivialTypeSourceInfo(EncodedType, 1121 getLocForEndOfToken(LParenLoc)); 1122 1123 return BuildObjCEncodeExpression(AtLoc, TInfo, RParenLoc); 1124 } 1125 1126 static bool HelperToDiagnoseMismatchedMethodsInGlobalPool(Sema &S, 1127 SourceLocation AtLoc, 1128 SourceLocation LParenLoc, 1129 SourceLocation RParenLoc, 1130 ObjCMethodDecl *Method, 1131 ObjCMethodList &MethList) { 1132 ObjCMethodList *M = &MethList; 1133 bool Warned = false; 1134 for (M = M->getNext(); M; M=M->getNext()) { 1135 ObjCMethodDecl *MatchingMethodDecl = M->getMethod(); 1136 if (MatchingMethodDecl == Method || 1137 isa<ObjCImplDecl>(MatchingMethodDecl->getDeclContext()) || 1138 MatchingMethodDecl->getSelector() != Method->getSelector()) 1139 continue; 1140 if (!S.MatchTwoMethodDeclarations(Method, 1141 MatchingMethodDecl, Sema::MMS_loose)) { 1142 if (!Warned) { 1143 Warned = true; 1144 S.Diag(AtLoc, diag::warn_multiple_selectors) 1145 << Method->getSelector() << FixItHint::CreateInsertion(LParenLoc, "(") 1146 << FixItHint::CreateInsertion(RParenLoc, ")"); 1147 S.Diag(Method->getLocation(), diag::note_method_declared_at) 1148 << Method->getDeclName(); 1149 } 1150 S.Diag(MatchingMethodDecl->getLocation(), diag::note_method_declared_at) 1151 << MatchingMethodDecl->getDeclName(); 1152 } 1153 } 1154 return Warned; 1155 } 1156 1157 static void DiagnoseMismatchedSelectors(Sema &S, SourceLocation AtLoc, 1158 ObjCMethodDecl *Method, 1159 SourceLocation LParenLoc, 1160 SourceLocation RParenLoc, 1161 bool WarnMultipleSelectors) { 1162 if (!WarnMultipleSelectors || 1163 S.Diags.isIgnored(diag::warn_multiple_selectors, SourceLocation())) 1164 return; 1165 bool Warned = false; 1166 for (Sema::GlobalMethodPool::iterator b = S.MethodPool.begin(), 1167 e = S.MethodPool.end(); b != e; b++) { 1168 // first, instance methods 1169 ObjCMethodList &InstMethList = b->second.first; 1170 if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc, 1171 Method, InstMethList)) 1172 Warned = true; 1173 1174 // second, class methods 1175 ObjCMethodList &ClsMethList = b->second.second; 1176 if (HelperToDiagnoseMismatchedMethodsInGlobalPool(S, AtLoc, LParenLoc, RParenLoc, 1177 Method, ClsMethList) || Warned) 1178 return; 1179 } 1180 } 1181 1182 ExprResult Sema::ParseObjCSelectorExpression(Selector Sel, 1183 SourceLocation AtLoc, 1184 SourceLocation SelLoc, 1185 SourceLocation LParenLoc, 1186 SourceLocation RParenLoc, 1187 bool WarnMultipleSelectors) { 1188 ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(Sel, 1189 SourceRange(LParenLoc, RParenLoc)); 1190 if (!Method) 1191 Method = LookupFactoryMethodInGlobalPool(Sel, 1192 SourceRange(LParenLoc, RParenLoc)); 1193 if (!Method) { 1194 if (const ObjCMethodDecl *OM = SelectorsForTypoCorrection(Sel)) { 1195 Selector MatchedSel = OM->getSelector(); 1196 SourceRange SelectorRange(LParenLoc.getLocWithOffset(1), 1197 RParenLoc.getLocWithOffset(-1)); 1198 Diag(SelLoc, diag::warn_undeclared_selector_with_typo) 1199 << Sel << MatchedSel 1200 << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString()); 1201 1202 } else 1203 Diag(SelLoc, diag::warn_undeclared_selector) << Sel; 1204 } else 1205 DiagnoseMismatchedSelectors(*this, AtLoc, Method, LParenLoc, RParenLoc, 1206 WarnMultipleSelectors); 1207 1208 if (Method && 1209 Method->getImplementationControl() != ObjCMethodDecl::Optional && 1210 !getSourceManager().isInSystemHeader(Method->getLocation())) 1211 ReferencedSelectors.insert(std::make_pair(Sel, AtLoc)); 1212 1213 // In ARC, forbid the user from using @selector for 1214 // retain/release/autorelease/dealloc/retainCount. 1215 if (getLangOpts().ObjCAutoRefCount) { 1216 switch (Sel.getMethodFamily()) { 1217 case OMF_retain: 1218 case OMF_release: 1219 case OMF_autorelease: 1220 case OMF_retainCount: 1221 case OMF_dealloc: 1222 Diag(AtLoc, diag::err_arc_illegal_selector) << 1223 Sel << SourceRange(LParenLoc, RParenLoc); 1224 break; 1225 1226 case OMF_None: 1227 case OMF_alloc: 1228 case OMF_copy: 1229 case OMF_finalize: 1230 case OMF_init: 1231 case OMF_mutableCopy: 1232 case OMF_new: 1233 case OMF_self: 1234 case OMF_initialize: 1235 case OMF_performSelector: 1236 break; 1237 } 1238 } 1239 QualType Ty = Context.getObjCSelType(); 1240 return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc); 1241 } 1242 1243 ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId, 1244 SourceLocation AtLoc, 1245 SourceLocation ProtoLoc, 1246 SourceLocation LParenLoc, 1247 SourceLocation ProtoIdLoc, 1248 SourceLocation RParenLoc) { 1249 ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId, ProtoIdLoc); 1250 if (!PDecl) { 1251 Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId; 1252 return true; 1253 } 1254 if (!PDecl->hasDefinition()) { 1255 Diag(ProtoLoc, diag::err_atprotocol_protocol) << PDecl; 1256 Diag(PDecl->getLocation(), diag::note_entity_declared_at) << PDecl; 1257 } else { 1258 PDecl = PDecl->getDefinition(); 1259 } 1260 1261 QualType Ty = Context.getObjCProtoType(); 1262 if (Ty.isNull()) 1263 return true; 1264 Ty = Context.getObjCObjectPointerType(Ty); 1265 return new (Context) ObjCProtocolExpr(Ty, PDecl, AtLoc, ProtoIdLoc, RParenLoc); 1266 } 1267 1268 /// Try to capture an implicit reference to 'self'. 1269 ObjCMethodDecl *Sema::tryCaptureObjCSelf(SourceLocation Loc) { 1270 DeclContext *DC = getFunctionLevelDeclContext(); 1271 1272 // If we're not in an ObjC method, error out. Note that, unlike the 1273 // C++ case, we don't require an instance method --- class methods 1274 // still have a 'self', and we really do still need to capture it! 1275 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(DC); 1276 if (!method) 1277 return nullptr; 1278 1279 tryCaptureVariable(method->getSelfDecl(), Loc); 1280 1281 return method; 1282 } 1283 1284 static QualType stripObjCInstanceType(ASTContext &Context, QualType T) { 1285 QualType origType = T; 1286 if (auto nullability = AttributedType::stripOuterNullability(T)) { 1287 if (T == Context.getObjCInstanceType()) { 1288 return Context.getAttributedType( 1289 AttributedType::getNullabilityAttrKind(*nullability), 1290 Context.getObjCIdType(), 1291 Context.getObjCIdType()); 1292 } 1293 1294 return origType; 1295 } 1296 1297 if (T == Context.getObjCInstanceType()) 1298 return Context.getObjCIdType(); 1299 1300 return origType; 1301 } 1302 1303 /// Determine the result type of a message send based on the receiver type, 1304 /// method, and the kind of message send. 1305 /// 1306 /// This is the "base" result type, which will still need to be adjusted 1307 /// to account for nullability. 1308 static QualType getBaseMessageSendResultType(Sema &S, 1309 QualType ReceiverType, 1310 ObjCMethodDecl *Method, 1311 bool isClassMessage, 1312 bool isSuperMessage) { 1313 assert(Method && "Must have a method"); 1314 if (!Method->hasRelatedResultType()) 1315 return Method->getSendResultType(ReceiverType); 1316 1317 ASTContext &Context = S.Context; 1318 1319 // Local function that transfers the nullability of the method's 1320 // result type to the returned result. 1321 auto transferNullability = [&](QualType type) -> QualType { 1322 // If the method's result type has nullability, extract it. 1323 if (auto nullability = Method->getSendResultType(ReceiverType) 1324 ->getNullability(Context)){ 1325 // Strip off any outer nullability sugar from the provided type. 1326 (void)AttributedType::stripOuterNullability(type); 1327 1328 // Form a new attributed type using the method result type's nullability. 1329 return Context.getAttributedType( 1330 AttributedType::getNullabilityAttrKind(*nullability), 1331 type, 1332 type); 1333 } 1334 1335 return type; 1336 }; 1337 1338 // If a method has a related return type: 1339 // - if the method found is an instance method, but the message send 1340 // was a class message send, T is the declared return type of the method 1341 // found 1342 if (Method->isInstanceMethod() && isClassMessage) 1343 return stripObjCInstanceType(Context, 1344 Method->getSendResultType(ReceiverType)); 1345 1346 // - if the receiver is super, T is a pointer to the class of the 1347 // enclosing method definition 1348 if (isSuperMessage) { 1349 if (ObjCMethodDecl *CurMethod = S.getCurMethodDecl()) 1350 if (ObjCInterfaceDecl *Class = CurMethod->getClassInterface()) { 1351 return transferNullability( 1352 Context.getObjCObjectPointerType( 1353 Context.getObjCInterfaceType(Class))); 1354 } 1355 } 1356 1357 // - if the receiver is the name of a class U, T is a pointer to U 1358 if (ReceiverType->getAsObjCInterfaceType()) 1359 return transferNullability(Context.getObjCObjectPointerType(ReceiverType)); 1360 // - if the receiver is of type Class or qualified Class type, 1361 // T is the declared return type of the method. 1362 if (ReceiverType->isObjCClassType() || 1363 ReceiverType->isObjCQualifiedClassType()) 1364 return stripObjCInstanceType(Context, 1365 Method->getSendResultType(ReceiverType)); 1366 1367 // - if the receiver is id, qualified id, Class, or qualified Class, T 1368 // is the receiver type, otherwise 1369 // - T is the type of the receiver expression. 1370 return transferNullability(ReceiverType); 1371 } 1372 1373 QualType Sema::getMessageSendResultType(const Expr *Receiver, 1374 QualType ReceiverType, 1375 ObjCMethodDecl *Method, 1376 bool isClassMessage, 1377 bool isSuperMessage) { 1378 // Produce the result type. 1379 QualType resultType = getBaseMessageSendResultType(*this, ReceiverType, 1380 Method, 1381 isClassMessage, 1382 isSuperMessage); 1383 1384 // If this is a class message, ignore the nullability of the receiver. 1385 if (isClassMessage) { 1386 // In a class method, class messages to 'self' that return instancetype can 1387 // be typed as the current class. We can safely do this in ARC because self 1388 // can't be reassigned, and we do it unsafely outside of ARC because in 1389 // practice people never reassign self in class methods and there's some 1390 // virtue in not being aggressively pedantic. 1391 if (Receiver && Receiver->isObjCSelfExpr()) { 1392 assert(ReceiverType->isObjCClassType() && "expected a Class self"); 1393 QualType T = Method->getSendResultType(ReceiverType); 1394 AttributedType::stripOuterNullability(T); 1395 if (T == Context.getObjCInstanceType()) { 1396 const ObjCMethodDecl *MD = cast<ObjCMethodDecl>( 1397 cast<ImplicitParamDecl>( 1398 cast<DeclRefExpr>(Receiver->IgnoreParenImpCasts())->getDecl()) 1399 ->getDeclContext()); 1400 assert(MD->isClassMethod() && "expected a class method"); 1401 QualType NewResultType = Context.getObjCObjectPointerType( 1402 Context.getObjCInterfaceType(MD->getClassInterface())); 1403 if (auto Nullability = resultType->getNullability(Context)) 1404 NewResultType = Context.getAttributedType( 1405 AttributedType::getNullabilityAttrKind(*Nullability), 1406 NewResultType, NewResultType); 1407 return NewResultType; 1408 } 1409 } 1410 return resultType; 1411 } 1412 1413 // There is nothing left to do if the result type cannot have a nullability 1414 // specifier. 1415 if (!resultType->canHaveNullability()) 1416 return resultType; 1417 1418 // Map the nullability of the result into a table index. 1419 unsigned receiverNullabilityIdx = 0; 1420 if (auto nullability = ReceiverType->getNullability(Context)) 1421 receiverNullabilityIdx = 1 + static_cast<unsigned>(*nullability); 1422 1423 unsigned resultNullabilityIdx = 0; 1424 if (auto nullability = resultType->getNullability(Context)) 1425 resultNullabilityIdx = 1 + static_cast<unsigned>(*nullability); 1426 1427 // The table of nullability mappings, indexed by the receiver's nullability 1428 // and then the result type's nullability. 1429 static const uint8_t None = 0; 1430 static const uint8_t NonNull = 1; 1431 static const uint8_t Nullable = 2; 1432 static const uint8_t Unspecified = 3; 1433 static const uint8_t nullabilityMap[4][4] = { 1434 // None NonNull Nullable Unspecified 1435 /* None */ { None, None, Nullable, None }, 1436 /* NonNull */ { None, NonNull, Nullable, Unspecified }, 1437 /* Nullable */ { Nullable, Nullable, Nullable, Nullable }, 1438 /* Unspecified */ { None, Unspecified, Nullable, Unspecified } 1439 }; 1440 1441 unsigned newResultNullabilityIdx 1442 = nullabilityMap[receiverNullabilityIdx][resultNullabilityIdx]; 1443 if (newResultNullabilityIdx == resultNullabilityIdx) 1444 return resultType; 1445 1446 // Strip off the existing nullability. This removes as little type sugar as 1447 // possible. 1448 do { 1449 if (auto attributed = dyn_cast<AttributedType>(resultType.getTypePtr())) { 1450 resultType = attributed->getModifiedType(); 1451 } else { 1452 resultType = resultType.getDesugaredType(Context); 1453 } 1454 } while (resultType->getNullability(Context)); 1455 1456 // Add nullability back if needed. 1457 if (newResultNullabilityIdx > 0) { 1458 auto newNullability 1459 = static_cast<NullabilityKind>(newResultNullabilityIdx-1); 1460 return Context.getAttributedType( 1461 AttributedType::getNullabilityAttrKind(newNullability), 1462 resultType, resultType); 1463 } 1464 1465 return resultType; 1466 } 1467 1468 /// Look for an ObjC method whose result type exactly matches the given type. 1469 static const ObjCMethodDecl * 1470 findExplicitInstancetypeDeclarer(const ObjCMethodDecl *MD, 1471 QualType instancetype) { 1472 if (MD->getReturnType() == instancetype) 1473 return MD; 1474 1475 // For these purposes, a method in an @implementation overrides a 1476 // declaration in the @interface. 1477 if (const ObjCImplDecl *impl = 1478 dyn_cast<ObjCImplDecl>(MD->getDeclContext())) { 1479 const ObjCContainerDecl *iface; 1480 if (const ObjCCategoryImplDecl *catImpl = 1481 dyn_cast<ObjCCategoryImplDecl>(impl)) { 1482 iface = catImpl->getCategoryDecl(); 1483 } else { 1484 iface = impl->getClassInterface(); 1485 } 1486 1487 const ObjCMethodDecl *ifaceMD = 1488 iface->getMethod(MD->getSelector(), MD->isInstanceMethod()); 1489 if (ifaceMD) return findExplicitInstancetypeDeclarer(ifaceMD, instancetype); 1490 } 1491 1492 SmallVector<const ObjCMethodDecl *, 4> overrides; 1493 MD->getOverriddenMethods(overrides); 1494 for (unsigned i = 0, e = overrides.size(); i != e; ++i) { 1495 if (const ObjCMethodDecl *result = 1496 findExplicitInstancetypeDeclarer(overrides[i], instancetype)) 1497 return result; 1498 } 1499 1500 return nullptr; 1501 } 1502 1503 void Sema::EmitRelatedResultTypeNoteForReturn(QualType destType) { 1504 // Only complain if we're in an ObjC method and the required return 1505 // type doesn't match the method's declared return type. 1506 ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurContext); 1507 if (!MD || !MD->hasRelatedResultType() || 1508 Context.hasSameUnqualifiedType(destType, MD->getReturnType())) 1509 return; 1510 1511 // Look for a method overridden by this method which explicitly uses 1512 // 'instancetype'. 1513 if (const ObjCMethodDecl *overridden = 1514 findExplicitInstancetypeDeclarer(MD, Context.getObjCInstanceType())) { 1515 SourceRange range = overridden->getReturnTypeSourceRange(); 1516 SourceLocation loc = range.getBegin(); 1517 if (loc.isInvalid()) 1518 loc = overridden->getLocation(); 1519 Diag(loc, diag::note_related_result_type_explicit) 1520 << /*current method*/ 1 << range; 1521 return; 1522 } 1523 1524 // Otherwise, if we have an interesting method family, note that. 1525 // This should always trigger if the above didn't. 1526 if (ObjCMethodFamily family = MD->getMethodFamily()) 1527 Diag(MD->getLocation(), diag::note_related_result_type_family) 1528 << /*current method*/ 1 1529 << family; 1530 } 1531 1532 void Sema::EmitRelatedResultTypeNote(const Expr *E) { 1533 E = E->IgnoreParenImpCasts(); 1534 const ObjCMessageExpr *MsgSend = dyn_cast<ObjCMessageExpr>(E); 1535 if (!MsgSend) 1536 return; 1537 1538 const ObjCMethodDecl *Method = MsgSend->getMethodDecl(); 1539 if (!Method) 1540 return; 1541 1542 if (!Method->hasRelatedResultType()) 1543 return; 1544 1545 if (Context.hasSameUnqualifiedType( 1546 Method->getReturnType().getNonReferenceType(), MsgSend->getType())) 1547 return; 1548 1549 if (!Context.hasSameUnqualifiedType(Method->getReturnType(), 1550 Context.getObjCInstanceType())) 1551 return; 1552 1553 Diag(Method->getLocation(), diag::note_related_result_type_inferred) 1554 << Method->isInstanceMethod() << Method->getSelector() 1555 << MsgSend->getType(); 1556 } 1557 1558 bool Sema::CheckMessageArgumentTypes( 1559 const Expr *Receiver, QualType ReceiverType, MultiExprArg Args, 1560 Selector Sel, ArrayRef<SourceLocation> SelectorLocs, ObjCMethodDecl *Method, 1561 bool isClassMessage, bool isSuperMessage, SourceLocation lbrac, 1562 SourceLocation rbrac, SourceRange RecRange, QualType &ReturnType, 1563 ExprValueKind &VK) { 1564 SourceLocation SelLoc; 1565 if (!SelectorLocs.empty() && SelectorLocs.front().isValid()) 1566 SelLoc = SelectorLocs.front(); 1567 else 1568 SelLoc = lbrac; 1569 1570 if (!Method) { 1571 // Apply default argument promotion as for (C99 6.5.2.2p6). 1572 for (unsigned i = 0, e = Args.size(); i != e; i++) { 1573 if (Args[i]->isTypeDependent()) 1574 continue; 1575 1576 ExprResult result; 1577 if (getLangOpts().DebuggerSupport) { 1578 QualType paramTy; // ignored 1579 result = checkUnknownAnyArg(SelLoc, Args[i], paramTy); 1580 } else { 1581 result = DefaultArgumentPromotion(Args[i]); 1582 } 1583 if (result.isInvalid()) 1584 return true; 1585 Args[i] = result.get(); 1586 } 1587 1588 unsigned DiagID; 1589 if (getLangOpts().ObjCAutoRefCount) 1590 DiagID = diag::err_arc_method_not_found; 1591 else 1592 DiagID = isClassMessage ? diag::warn_class_method_not_found 1593 : diag::warn_inst_method_not_found; 1594 if (!getLangOpts().DebuggerSupport) { 1595 const ObjCMethodDecl *OMD = SelectorsForTypoCorrection(Sel, ReceiverType); 1596 if (OMD && !OMD->isInvalidDecl()) { 1597 if (getLangOpts().ObjCAutoRefCount) 1598 DiagID = diag::err_method_not_found_with_typo; 1599 else 1600 DiagID = isClassMessage ? diag::warn_class_method_not_found_with_typo 1601 : diag::warn_instance_method_not_found_with_typo; 1602 Selector MatchedSel = OMD->getSelector(); 1603 SourceRange SelectorRange(SelectorLocs.front(), SelectorLocs.back()); 1604 if (MatchedSel.isUnarySelector()) 1605 Diag(SelLoc, DiagID) 1606 << Sel<< isClassMessage << MatchedSel 1607 << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString()); 1608 else 1609 Diag(SelLoc, DiagID) << Sel<< isClassMessage << MatchedSel; 1610 } 1611 else 1612 Diag(SelLoc, DiagID) 1613 << Sel << isClassMessage << SourceRange(SelectorLocs.front(), 1614 SelectorLocs.back()); 1615 // Find the class to which we are sending this message. 1616 if (ReceiverType->isObjCObjectPointerType()) { 1617 if (ObjCInterfaceDecl *ThisClass = 1618 ReceiverType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()) { 1619 Diag(ThisClass->getLocation(), diag::note_receiver_class_declared); 1620 if (!RecRange.isInvalid()) 1621 if (ThisClass->lookupClassMethod(Sel)) 1622 Diag(RecRange.getBegin(),diag::note_receiver_expr_here) 1623 << FixItHint::CreateReplacement(RecRange, 1624 ThisClass->getNameAsString()); 1625 } 1626 } 1627 } 1628 1629 // In debuggers, we want to use __unknown_anytype for these 1630 // results so that clients can cast them. 1631 if (getLangOpts().DebuggerSupport) { 1632 ReturnType = Context.UnknownAnyTy; 1633 } else { 1634 ReturnType = Context.getObjCIdType(); 1635 } 1636 VK = VK_RValue; 1637 return false; 1638 } 1639 1640 ReturnType = getMessageSendResultType(Receiver, ReceiverType, Method, 1641 isClassMessage, isSuperMessage); 1642 VK = Expr::getValueKindForType(Method->getReturnType()); 1643 1644 unsigned NumNamedArgs = Sel.getNumArgs(); 1645 // Method might have more arguments than selector indicates. This is due 1646 // to addition of c-style arguments in method. 1647 if (Method->param_size() > Sel.getNumArgs()) 1648 NumNamedArgs = Method->param_size(); 1649 // FIXME. This need be cleaned up. 1650 if (Args.size() < NumNamedArgs) { 1651 Diag(SelLoc, diag::err_typecheck_call_too_few_args) 1652 << 2 << NumNamedArgs << static_cast<unsigned>(Args.size()); 1653 return false; 1654 } 1655 1656 // Compute the set of type arguments to be substituted into each parameter 1657 // type. 1658 Optional<ArrayRef<QualType>> typeArgs 1659 = ReceiverType->getObjCSubstitutions(Method->getDeclContext()); 1660 bool IsError = false; 1661 for (unsigned i = 0; i < NumNamedArgs; i++) { 1662 // We can't do any type-checking on a type-dependent argument. 1663 if (Args[i]->isTypeDependent()) 1664 continue; 1665 1666 Expr *argExpr = Args[i]; 1667 1668 ParmVarDecl *param = Method->parameters()[i]; 1669 assert(argExpr && "CheckMessageArgumentTypes(): missing expression"); 1670 1671 if (param->hasAttr<NoEscapeAttr>()) 1672 if (auto *BE = dyn_cast<BlockExpr>( 1673 argExpr->IgnoreParenNoopCasts(Context))) 1674 BE->getBlockDecl()->setDoesNotEscape(); 1675 1676 // Strip the unbridged-cast placeholder expression off unless it's 1677 // a consumed argument. 1678 if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) && 1679 !param->hasAttr<CFConsumedAttr>()) 1680 argExpr = stripARCUnbridgedCast(argExpr); 1681 1682 // If the parameter is __unknown_anytype, infer its type 1683 // from the argument. 1684 if (param->getType() == Context.UnknownAnyTy) { 1685 QualType paramType; 1686 ExprResult argE = checkUnknownAnyArg(SelLoc, argExpr, paramType); 1687 if (argE.isInvalid()) { 1688 IsError = true; 1689 } else { 1690 Args[i] = argE.get(); 1691 1692 // Update the parameter type in-place. 1693 param->setType(paramType); 1694 } 1695 continue; 1696 } 1697 1698 QualType origParamType = param->getType(); 1699 QualType paramType = param->getType(); 1700 if (typeArgs) 1701 paramType = paramType.substObjCTypeArgs( 1702 Context, 1703 *typeArgs, 1704 ObjCSubstitutionContext::Parameter); 1705 1706 if (RequireCompleteType(argExpr->getSourceRange().getBegin(), 1707 paramType, 1708 diag::err_call_incomplete_argument, argExpr)) 1709 return true; 1710 1711 InitializedEntity Entity 1712 = InitializedEntity::InitializeParameter(Context, param, paramType); 1713 ExprResult ArgE = PerformCopyInitialization(Entity, SourceLocation(), argExpr); 1714 if (ArgE.isInvalid()) 1715 IsError = true; 1716 else { 1717 Args[i] = ArgE.getAs<Expr>(); 1718 1719 // If we are type-erasing a block to a block-compatible 1720 // Objective-C pointer type, we may need to extend the lifetime 1721 // of the block object. 1722 if (typeArgs && Args[i]->isRValue() && paramType->isBlockPointerType() && 1723 Args[i]->getType()->isBlockPointerType() && 1724 origParamType->isObjCObjectPointerType()) { 1725 ExprResult arg = Args[i]; 1726 maybeExtendBlockObject(arg); 1727 Args[i] = arg.get(); 1728 } 1729 } 1730 } 1731 1732 // Promote additional arguments to variadic methods. 1733 if (Method->isVariadic()) { 1734 for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) { 1735 if (Args[i]->isTypeDependent()) 1736 continue; 1737 1738 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod, 1739 nullptr); 1740 IsError |= Arg.isInvalid(); 1741 Args[i] = Arg.get(); 1742 } 1743 } else { 1744 // Check for extra arguments to non-variadic methods. 1745 if (Args.size() != NumNamedArgs) { 1746 Diag(Args[NumNamedArgs]->getBeginLoc(), 1747 diag::err_typecheck_call_too_many_args) 1748 << 2 /*method*/ << NumNamedArgs << static_cast<unsigned>(Args.size()) 1749 << Method->getSourceRange() 1750 << SourceRange(Args[NumNamedArgs]->getBeginLoc(), 1751 Args.back()->getEndLoc()); 1752 } 1753 } 1754 1755 DiagnoseSentinelCalls(Method, SelLoc, Args); 1756 1757 // Do additional checkings on method. 1758 IsError |= CheckObjCMethodCall( 1759 Method, SelLoc, makeArrayRef(Args.data(), Args.size())); 1760 1761 return IsError; 1762 } 1763 1764 bool Sema::isSelfExpr(Expr *RExpr) { 1765 // 'self' is objc 'self' in an objc method only. 1766 ObjCMethodDecl *Method = 1767 dyn_cast_or_null<ObjCMethodDecl>(CurContext->getNonClosureAncestor()); 1768 return isSelfExpr(RExpr, Method); 1769 } 1770 1771 bool Sema::isSelfExpr(Expr *receiver, const ObjCMethodDecl *method) { 1772 if (!method) return false; 1773 1774 receiver = receiver->IgnoreParenLValueCasts(); 1775 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(receiver)) 1776 if (DRE->getDecl() == method->getSelfDecl()) 1777 return true; 1778 return false; 1779 } 1780 1781 /// LookupMethodInType - Look up a method in an ObjCObjectType. 1782 ObjCMethodDecl *Sema::LookupMethodInObjectType(Selector sel, QualType type, 1783 bool isInstance) { 1784 const ObjCObjectType *objType = type->castAs<ObjCObjectType>(); 1785 if (ObjCInterfaceDecl *iface = objType->getInterface()) { 1786 // Look it up in the main interface (and categories, etc.) 1787 if (ObjCMethodDecl *method = iface->lookupMethod(sel, isInstance)) 1788 return method; 1789 1790 // Okay, look for "private" methods declared in any 1791 // @implementations we've seen. 1792 if (ObjCMethodDecl *method = iface->lookupPrivateMethod(sel, isInstance)) 1793 return method; 1794 } 1795 1796 // Check qualifiers. 1797 for (const auto *I : objType->quals()) 1798 if (ObjCMethodDecl *method = I->lookupMethod(sel, isInstance)) 1799 return method; 1800 1801 return nullptr; 1802 } 1803 1804 /// LookupMethodInQualifiedType - Lookups up a method in protocol qualifier 1805 /// list of a qualified objective pointer type. 1806 ObjCMethodDecl *Sema::LookupMethodInQualifiedType(Selector Sel, 1807 const ObjCObjectPointerType *OPT, 1808 bool Instance) 1809 { 1810 ObjCMethodDecl *MD = nullptr; 1811 for (const auto *PROTO : OPT->quals()) { 1812 if ((MD = PROTO->lookupMethod(Sel, Instance))) { 1813 return MD; 1814 } 1815 } 1816 return nullptr; 1817 } 1818 1819 /// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an 1820 /// objective C interface. This is a property reference expression. 1821 ExprResult Sema:: 1822 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, 1823 Expr *BaseExpr, SourceLocation OpLoc, 1824 DeclarationName MemberName, 1825 SourceLocation MemberLoc, 1826 SourceLocation SuperLoc, QualType SuperType, 1827 bool Super) { 1828 const ObjCInterfaceType *IFaceT = OPT->getInterfaceType(); 1829 ObjCInterfaceDecl *IFace = IFaceT->getDecl(); 1830 1831 if (!MemberName.isIdentifier()) { 1832 Diag(MemberLoc, diag::err_invalid_property_name) 1833 << MemberName << QualType(OPT, 0); 1834 return ExprError(); 1835 } 1836 1837 IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); 1838 1839 SourceRange BaseRange = Super? SourceRange(SuperLoc) 1840 : BaseExpr->getSourceRange(); 1841 if (RequireCompleteType(MemberLoc, OPT->getPointeeType(), 1842 diag::err_property_not_found_forward_class, 1843 MemberName, BaseRange)) 1844 return ExprError(); 1845 1846 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration( 1847 Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) { 1848 // Check whether we can reference this property. 1849 if (DiagnoseUseOfDecl(PD, MemberLoc)) 1850 return ExprError(); 1851 if (Super) 1852 return new (Context) 1853 ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, VK_LValue, 1854 OK_ObjCProperty, MemberLoc, SuperLoc, SuperType); 1855 else 1856 return new (Context) 1857 ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, VK_LValue, 1858 OK_ObjCProperty, MemberLoc, BaseExpr); 1859 } 1860 // Check protocols on qualified interfaces. 1861 for (const auto *I : OPT->quals()) 1862 if (ObjCPropertyDecl *PD = I->FindPropertyDeclaration( 1863 Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) { 1864 // Check whether we can reference this property. 1865 if (DiagnoseUseOfDecl(PD, MemberLoc)) 1866 return ExprError(); 1867 1868 if (Super) 1869 return new (Context) ObjCPropertyRefExpr( 1870 PD, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty, MemberLoc, 1871 SuperLoc, SuperType); 1872 else 1873 return new (Context) 1874 ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, VK_LValue, 1875 OK_ObjCProperty, MemberLoc, BaseExpr); 1876 } 1877 // If that failed, look for an "implicit" property by seeing if the nullary 1878 // selector is implemented. 1879 1880 // FIXME: The logic for looking up nullary and unary selectors should be 1881 // shared with the code in ActOnInstanceMessage. 1882 1883 Selector Sel = PP.getSelectorTable().getNullarySelector(Member); 1884 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel); 1885 1886 // May be found in property's qualified list. 1887 if (!Getter) 1888 Getter = LookupMethodInQualifiedType(Sel, OPT, true); 1889 1890 // If this reference is in an @implementation, check for 'private' methods. 1891 if (!Getter) 1892 Getter = IFace->lookupPrivateMethod(Sel); 1893 1894 if (Getter) { 1895 // Check if we can reference this property. 1896 if (DiagnoseUseOfDecl(Getter, MemberLoc)) 1897 return ExprError(); 1898 } 1899 // If we found a getter then this may be a valid dot-reference, we 1900 // will look for the matching setter, in case it is needed. 1901 Selector SetterSel = 1902 SelectorTable::constructSetterSelector(PP.getIdentifierTable(), 1903 PP.getSelectorTable(), Member); 1904 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel); 1905 1906 // May be found in property's qualified list. 1907 if (!Setter) 1908 Setter = LookupMethodInQualifiedType(SetterSel, OPT, true); 1909 1910 if (!Setter) { 1911 // If this reference is in an @implementation, also check for 'private' 1912 // methods. 1913 Setter = IFace->lookupPrivateMethod(SetterSel); 1914 } 1915 1916 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc)) 1917 return ExprError(); 1918 1919 // Special warning if member name used in a property-dot for a setter accessor 1920 // does not use a property with same name; e.g. obj.X = ... for a property with 1921 // name 'x'. 1922 if (Setter && Setter->isImplicit() && Setter->isPropertyAccessor() && 1923 !IFace->FindPropertyDeclaration( 1924 Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) { 1925 if (const ObjCPropertyDecl *PDecl = Setter->findPropertyDecl()) { 1926 // Do not warn if user is using property-dot syntax to make call to 1927 // user named setter. 1928 if (!(PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter)) 1929 Diag(MemberLoc, 1930 diag::warn_property_access_suggest) 1931 << MemberName << QualType(OPT, 0) << PDecl->getName() 1932 << FixItHint::CreateReplacement(MemberLoc, PDecl->getName()); 1933 } 1934 } 1935 1936 if (Getter || Setter) { 1937 if (Super) 1938 return new (Context) 1939 ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue, 1940 OK_ObjCProperty, MemberLoc, SuperLoc, SuperType); 1941 else 1942 return new (Context) 1943 ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue, 1944 OK_ObjCProperty, MemberLoc, BaseExpr); 1945 1946 } 1947 1948 // Attempt to correct for typos in property names. 1949 DeclFilterCCC<ObjCPropertyDecl> CCC{}; 1950 if (TypoCorrection Corrected = CorrectTypo( 1951 DeclarationNameInfo(MemberName, MemberLoc), LookupOrdinaryName, 1952 nullptr, nullptr, CCC, CTK_ErrorRecovery, IFace, false, OPT)) { 1953 DeclarationName TypoResult = Corrected.getCorrection(); 1954 if (TypoResult.isIdentifier() && 1955 TypoResult.getAsIdentifierInfo() == Member) { 1956 // There is no need to try the correction if it is the same. 1957 NamedDecl *ChosenDecl = 1958 Corrected.isKeyword() ? nullptr : Corrected.getFoundDecl(); 1959 if (ChosenDecl && isa<ObjCPropertyDecl>(ChosenDecl)) 1960 if (cast<ObjCPropertyDecl>(ChosenDecl)->isClassProperty()) { 1961 // This is a class property, we should not use the instance to 1962 // access it. 1963 Diag(MemberLoc, diag::err_class_property_found) << MemberName 1964 << OPT->getInterfaceDecl()->getName() 1965 << FixItHint::CreateReplacement(BaseExpr->getSourceRange(), 1966 OPT->getInterfaceDecl()->getName()); 1967 return ExprError(); 1968 } 1969 } else { 1970 diagnoseTypo(Corrected, PDiag(diag::err_property_not_found_suggest) 1971 << MemberName << QualType(OPT, 0)); 1972 return HandleExprPropertyRefExpr(OPT, BaseExpr, OpLoc, 1973 TypoResult, MemberLoc, 1974 SuperLoc, SuperType, Super); 1975 } 1976 } 1977 ObjCInterfaceDecl *ClassDeclared; 1978 if (ObjCIvarDecl *Ivar = 1979 IFace->lookupInstanceVariable(Member, ClassDeclared)) { 1980 QualType T = Ivar->getType(); 1981 if (const ObjCObjectPointerType * OBJPT = 1982 T->getAsObjCInterfacePointerType()) { 1983 if (RequireCompleteType(MemberLoc, OBJPT->getPointeeType(), 1984 diag::err_property_not_as_forward_class, 1985 MemberName, BaseExpr)) 1986 return ExprError(); 1987 } 1988 Diag(MemberLoc, 1989 diag::err_ivar_access_using_property_syntax_suggest) 1990 << MemberName << QualType(OPT, 0) << Ivar->getDeclName() 1991 << FixItHint::CreateReplacement(OpLoc, "->"); 1992 return ExprError(); 1993 } 1994 1995 Diag(MemberLoc, diag::err_property_not_found) 1996 << MemberName << QualType(OPT, 0); 1997 if (Setter) 1998 Diag(Setter->getLocation(), diag::note_getter_unavailable) 1999 << MemberName << BaseExpr->getSourceRange(); 2000 return ExprError(); 2001 } 2002 2003 ExprResult Sema:: 2004 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName, 2005 IdentifierInfo &propertyName, 2006 SourceLocation receiverNameLoc, 2007 SourceLocation propertyNameLoc) { 2008 2009 IdentifierInfo *receiverNamePtr = &receiverName; 2010 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(receiverNamePtr, 2011 receiverNameLoc); 2012 2013 QualType SuperType; 2014 if (!IFace) { 2015 // If the "receiver" is 'super' in a method, handle it as an expression-like 2016 // property reference. 2017 if (receiverNamePtr->isStr("super")) { 2018 if (ObjCMethodDecl *CurMethod = tryCaptureObjCSelf(receiverNameLoc)) { 2019 if (auto classDecl = CurMethod->getClassInterface()) { 2020 SuperType = QualType(classDecl->getSuperClassType(), 0); 2021 if (CurMethod->isInstanceMethod()) { 2022 if (SuperType.isNull()) { 2023 // The current class does not have a superclass. 2024 Diag(receiverNameLoc, diag::err_root_class_cannot_use_super) 2025 << CurMethod->getClassInterface()->getIdentifier(); 2026 return ExprError(); 2027 } 2028 QualType T = Context.getObjCObjectPointerType(SuperType); 2029 2030 return HandleExprPropertyRefExpr(T->castAs<ObjCObjectPointerType>(), 2031 /*BaseExpr*/nullptr, 2032 SourceLocation()/*OpLoc*/, 2033 &propertyName, 2034 propertyNameLoc, 2035 receiverNameLoc, T, true); 2036 } 2037 2038 // Otherwise, if this is a class method, try dispatching to our 2039 // superclass. 2040 IFace = CurMethod->getClassInterface()->getSuperClass(); 2041 } 2042 } 2043 } 2044 2045 if (!IFace) { 2046 Diag(receiverNameLoc, diag::err_expected_either) << tok::identifier 2047 << tok::l_paren; 2048 return ExprError(); 2049 } 2050 } 2051 2052 Selector GetterSel; 2053 Selector SetterSel; 2054 if (auto PD = IFace->FindPropertyDeclaration( 2055 &propertyName, ObjCPropertyQueryKind::OBJC_PR_query_class)) { 2056 GetterSel = PD->getGetterName(); 2057 SetterSel = PD->getSetterName(); 2058 } else { 2059 GetterSel = PP.getSelectorTable().getNullarySelector(&propertyName); 2060 SetterSel = SelectorTable::constructSetterSelector( 2061 PP.getIdentifierTable(), PP.getSelectorTable(), &propertyName); 2062 } 2063 2064 // Search for a declared property first. 2065 ObjCMethodDecl *Getter = IFace->lookupClassMethod(GetterSel); 2066 2067 // If this reference is in an @implementation, check for 'private' methods. 2068 if (!Getter) 2069 Getter = IFace->lookupPrivateClassMethod(GetterSel); 2070 2071 if (Getter) { 2072 // FIXME: refactor/share with ActOnMemberReference(). 2073 // Check if we can reference this property. 2074 if (DiagnoseUseOfDecl(Getter, propertyNameLoc)) 2075 return ExprError(); 2076 } 2077 2078 // Look for the matching setter, in case it is needed. 2079 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel); 2080 if (!Setter) { 2081 // If this reference is in an @implementation, also check for 'private' 2082 // methods. 2083 Setter = IFace->lookupPrivateClassMethod(SetterSel); 2084 } 2085 // Look through local category implementations associated with the class. 2086 if (!Setter) 2087 Setter = IFace->getCategoryClassMethod(SetterSel); 2088 2089 if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc)) 2090 return ExprError(); 2091 2092 if (Getter || Setter) { 2093 if (!SuperType.isNull()) 2094 return new (Context) 2095 ObjCPropertyRefExpr(Getter, Setter, Context.PseudoObjectTy, VK_LValue, 2096 OK_ObjCProperty, propertyNameLoc, receiverNameLoc, 2097 SuperType); 2098 2099 return new (Context) ObjCPropertyRefExpr( 2100 Getter, Setter, Context.PseudoObjectTy, VK_LValue, OK_ObjCProperty, 2101 propertyNameLoc, receiverNameLoc, IFace); 2102 } 2103 return ExprError(Diag(propertyNameLoc, diag::err_property_not_found) 2104 << &propertyName << Context.getObjCInterfaceType(IFace)); 2105 } 2106 2107 namespace { 2108 2109 class ObjCInterfaceOrSuperCCC final : public CorrectionCandidateCallback { 2110 public: 2111 ObjCInterfaceOrSuperCCC(ObjCMethodDecl *Method) { 2112 // Determine whether "super" is acceptable in the current context. 2113 if (Method && Method->getClassInterface()) 2114 WantObjCSuper = Method->getClassInterface()->getSuperClass(); 2115 } 2116 2117 bool ValidateCandidate(const TypoCorrection &candidate) override { 2118 return candidate.getCorrectionDeclAs<ObjCInterfaceDecl>() || 2119 candidate.isKeyword("super"); 2120 } 2121 2122 std::unique_ptr<CorrectionCandidateCallback> clone() override { 2123 return llvm::make_unique<ObjCInterfaceOrSuperCCC>(*this); 2124 } 2125 }; 2126 2127 } // end anonymous namespace 2128 2129 Sema::ObjCMessageKind Sema::getObjCMessageKind(Scope *S, 2130 IdentifierInfo *Name, 2131 SourceLocation NameLoc, 2132 bool IsSuper, 2133 bool HasTrailingDot, 2134 ParsedType &ReceiverType) { 2135 ReceiverType = nullptr; 2136 2137 // If the identifier is "super" and there is no trailing dot, we're 2138 // messaging super. If the identifier is "super" and there is a 2139 // trailing dot, it's an instance message. 2140 if (IsSuper && S->isInObjcMethodScope()) 2141 return HasTrailingDot? ObjCInstanceMessage : ObjCSuperMessage; 2142 2143 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName); 2144 LookupName(Result, S); 2145 2146 switch (Result.getResultKind()) { 2147 case LookupResult::NotFound: 2148 // Normal name lookup didn't find anything. If we're in an 2149 // Objective-C method, look for ivars. If we find one, we're done! 2150 // FIXME: This is a hack. Ivar lookup should be part of normal 2151 // lookup. 2152 if (ObjCMethodDecl *Method = getCurMethodDecl()) { 2153 if (!Method->getClassInterface()) { 2154 // Fall back: let the parser try to parse it as an instance message. 2155 return ObjCInstanceMessage; 2156 } 2157 2158 ObjCInterfaceDecl *ClassDeclared; 2159 if (Method->getClassInterface()->lookupInstanceVariable(Name, 2160 ClassDeclared)) 2161 return ObjCInstanceMessage; 2162 } 2163 2164 // Break out; we'll perform typo correction below. 2165 break; 2166 2167 case LookupResult::NotFoundInCurrentInstantiation: 2168 case LookupResult::FoundOverloaded: 2169 case LookupResult::FoundUnresolvedValue: 2170 case LookupResult::Ambiguous: 2171 Result.suppressDiagnostics(); 2172 return ObjCInstanceMessage; 2173 2174 case LookupResult::Found: { 2175 // If the identifier is a class or not, and there is a trailing dot, 2176 // it's an instance message. 2177 if (HasTrailingDot) 2178 return ObjCInstanceMessage; 2179 // We found something. If it's a type, then we have a class 2180 // message. Otherwise, it's an instance message. 2181 NamedDecl *ND = Result.getFoundDecl(); 2182 QualType T; 2183 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(ND)) 2184 T = Context.getObjCInterfaceType(Class); 2185 else if (TypeDecl *Type = dyn_cast<TypeDecl>(ND)) { 2186 T = Context.getTypeDeclType(Type); 2187 DiagnoseUseOfDecl(Type, NameLoc); 2188 } 2189 else 2190 return ObjCInstanceMessage; 2191 2192 // We have a class message, and T is the type we're 2193 // messaging. Build source-location information for it. 2194 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc); 2195 ReceiverType = CreateParsedType(T, TSInfo); 2196 return ObjCClassMessage; 2197 } 2198 } 2199 2200 ObjCInterfaceOrSuperCCC CCC(getCurMethodDecl()); 2201 if (TypoCorrection Corrected = CorrectTypo( 2202 Result.getLookupNameInfo(), Result.getLookupKind(), S, nullptr, CCC, 2203 CTK_ErrorRecovery, nullptr, false, nullptr, false)) { 2204 if (Corrected.isKeyword()) { 2205 // If we've found the keyword "super" (the only keyword that would be 2206 // returned by CorrectTypo), this is a send to super. 2207 diagnoseTypo(Corrected, 2208 PDiag(diag::err_unknown_receiver_suggest) << Name); 2209 return ObjCSuperMessage; 2210 } else if (ObjCInterfaceDecl *Class = 2211 Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) { 2212 // If we found a declaration, correct when it refers to an Objective-C 2213 // class. 2214 diagnoseTypo(Corrected, 2215 PDiag(diag::err_unknown_receiver_suggest) << Name); 2216 QualType T = Context.getObjCInterfaceType(Class); 2217 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc); 2218 ReceiverType = CreateParsedType(T, TSInfo); 2219 return ObjCClassMessage; 2220 } 2221 } 2222 2223 // Fall back: let the parser try to parse it as an instance message. 2224 return ObjCInstanceMessage; 2225 } 2226 2227 ExprResult Sema::ActOnSuperMessage(Scope *S, 2228 SourceLocation SuperLoc, 2229 Selector Sel, 2230 SourceLocation LBracLoc, 2231 ArrayRef<SourceLocation> SelectorLocs, 2232 SourceLocation RBracLoc, 2233 MultiExprArg Args) { 2234 // Determine whether we are inside a method or not. 2235 ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc); 2236 if (!Method) { 2237 Diag(SuperLoc, diag::err_invalid_receiver_to_message_super); 2238 return ExprError(); 2239 } 2240 2241 ObjCInterfaceDecl *Class = Method->getClassInterface(); 2242 if (!Class) { 2243 Diag(SuperLoc, diag::err_no_super_class_message) 2244 << Method->getDeclName(); 2245 return ExprError(); 2246 } 2247 2248 QualType SuperTy(Class->getSuperClassType(), 0); 2249 if (SuperTy.isNull()) { 2250 // The current class does not have a superclass. 2251 Diag(SuperLoc, diag::err_root_class_cannot_use_super) 2252 << Class->getIdentifier(); 2253 return ExprError(); 2254 } 2255 2256 // We are in a method whose class has a superclass, so 'super' 2257 // is acting as a keyword. 2258 if (Method->getSelector() == Sel) 2259 getCurFunction()->ObjCShouldCallSuper = false; 2260 2261 if (Method->isInstanceMethod()) { 2262 // Since we are in an instance method, this is an instance 2263 // message to the superclass instance. 2264 SuperTy = Context.getObjCObjectPointerType(SuperTy); 2265 return BuildInstanceMessage(nullptr, SuperTy, SuperLoc, 2266 Sel, /*Method=*/nullptr, 2267 LBracLoc, SelectorLocs, RBracLoc, Args); 2268 } 2269 2270 // Since we are in a class method, this is a class message to 2271 // the superclass. 2272 return BuildClassMessage(/*ReceiverTypeInfo=*/nullptr, 2273 SuperTy, 2274 SuperLoc, Sel, /*Method=*/nullptr, 2275 LBracLoc, SelectorLocs, RBracLoc, Args); 2276 } 2277 2278 ExprResult Sema::BuildClassMessageImplicit(QualType ReceiverType, 2279 bool isSuperReceiver, 2280 SourceLocation Loc, 2281 Selector Sel, 2282 ObjCMethodDecl *Method, 2283 MultiExprArg Args) { 2284 TypeSourceInfo *receiverTypeInfo = nullptr; 2285 if (!ReceiverType.isNull()) 2286 receiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType); 2287 2288 return BuildClassMessage(receiverTypeInfo, ReceiverType, 2289 /*SuperLoc=*/isSuperReceiver ? Loc : SourceLocation(), 2290 Sel, Method, Loc, Loc, Loc, Args, 2291 /*isImplicit=*/true); 2292 } 2293 2294 static void applyCocoaAPICheck(Sema &S, const ObjCMessageExpr *Msg, 2295 unsigned DiagID, 2296 bool (*refactor)(const ObjCMessageExpr *, 2297 const NSAPI &, edit::Commit &)) { 2298 SourceLocation MsgLoc = Msg->getExprLoc(); 2299 if (S.Diags.isIgnored(DiagID, MsgLoc)) 2300 return; 2301 2302 SourceManager &SM = S.SourceMgr; 2303 edit::Commit ECommit(SM, S.LangOpts); 2304 if (refactor(Msg,*S.NSAPIObj, ECommit)) { 2305 DiagnosticBuilder Builder = S.Diag(MsgLoc, DiagID) 2306 << Msg->getSelector() << Msg->getSourceRange(); 2307 // FIXME: Don't emit diagnostic at all if fixits are non-commitable. 2308 if (!ECommit.isCommitable()) 2309 return; 2310 for (edit::Commit::edit_iterator 2311 I = ECommit.edit_begin(), E = ECommit.edit_end(); I != E; ++I) { 2312 const edit::Commit::Edit &Edit = *I; 2313 switch (Edit.Kind) { 2314 case edit::Commit::Act_Insert: 2315 Builder.AddFixItHint(FixItHint::CreateInsertion(Edit.OrigLoc, 2316 Edit.Text, 2317 Edit.BeforePrev)); 2318 break; 2319 case edit::Commit::Act_InsertFromRange: 2320 Builder.AddFixItHint( 2321 FixItHint::CreateInsertionFromRange(Edit.OrigLoc, 2322 Edit.getInsertFromRange(SM), 2323 Edit.BeforePrev)); 2324 break; 2325 case edit::Commit::Act_Remove: 2326 Builder.AddFixItHint(FixItHint::CreateRemoval(Edit.getFileRange(SM))); 2327 break; 2328 } 2329 } 2330 } 2331 } 2332 2333 static void checkCocoaAPI(Sema &S, const ObjCMessageExpr *Msg) { 2334 applyCocoaAPICheck(S, Msg, diag::warn_objc_redundant_literal_use, 2335 edit::rewriteObjCRedundantCallWithLiteral); 2336 } 2337 2338 static void checkFoundationAPI(Sema &S, SourceLocation Loc, 2339 const ObjCMethodDecl *Method, 2340 ArrayRef<Expr *> Args, QualType ReceiverType, 2341 bool IsClassObjectCall) { 2342 // Check if this is a performSelector method that uses a selector that returns 2343 // a record or a vector type. 2344 if (Method->getSelector().getMethodFamily() != OMF_performSelector || 2345 Args.empty()) 2346 return; 2347 const auto *SE = dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens()); 2348 if (!SE) 2349 return; 2350 ObjCMethodDecl *ImpliedMethod; 2351 if (!IsClassObjectCall) { 2352 const auto *OPT = ReceiverType->getAs<ObjCObjectPointerType>(); 2353 if (!OPT || !OPT->getInterfaceDecl()) 2354 return; 2355 ImpliedMethod = 2356 OPT->getInterfaceDecl()->lookupInstanceMethod(SE->getSelector()); 2357 if (!ImpliedMethod) 2358 ImpliedMethod = 2359 OPT->getInterfaceDecl()->lookupPrivateMethod(SE->getSelector()); 2360 } else { 2361 const auto *IT = ReceiverType->getAs<ObjCInterfaceType>(); 2362 if (!IT) 2363 return; 2364 ImpliedMethod = IT->getDecl()->lookupClassMethod(SE->getSelector()); 2365 if (!ImpliedMethod) 2366 ImpliedMethod = 2367 IT->getDecl()->lookupPrivateClassMethod(SE->getSelector()); 2368 } 2369 if (!ImpliedMethod) 2370 return; 2371 QualType Ret = ImpliedMethod->getReturnType(); 2372 if (Ret->isRecordType() || Ret->isVectorType() || Ret->isExtVectorType()) { 2373 QualType Ret = ImpliedMethod->getReturnType(); 2374 S.Diag(Loc, diag::warn_objc_unsafe_perform_selector) 2375 << Method->getSelector() 2376 << (!Ret->isRecordType() 2377 ? /*Vector*/ 2 2378 : Ret->isUnionType() ? /*Union*/ 1 : /*Struct*/ 0); 2379 S.Diag(ImpliedMethod->getBeginLoc(), 2380 diag::note_objc_unsafe_perform_selector_method_declared_here) 2381 << ImpliedMethod->getSelector() << Ret; 2382 } 2383 } 2384 2385 /// Diagnose use of %s directive in an NSString which is being passed 2386 /// as formatting string to formatting method. 2387 static void 2388 DiagnoseCStringFormatDirectiveInObjCAPI(Sema &S, 2389 ObjCMethodDecl *Method, 2390 Selector Sel, 2391 Expr **Args, unsigned NumArgs) { 2392 unsigned Idx = 0; 2393 bool Format = false; 2394 ObjCStringFormatFamily SFFamily = Sel.getStringFormatFamily(); 2395 if (SFFamily == ObjCStringFormatFamily::SFF_NSString) { 2396 Idx = 0; 2397 Format = true; 2398 } 2399 else if (Method) { 2400 for (const auto *I : Method->specific_attrs<FormatAttr>()) { 2401 if (S.GetFormatNSStringIdx(I, Idx)) { 2402 Format = true; 2403 break; 2404 } 2405 } 2406 } 2407 if (!Format || NumArgs <= Idx) 2408 return; 2409 2410 Expr *FormatExpr = Args[Idx]; 2411 if (ObjCStringLiteral *OSL = 2412 dyn_cast<ObjCStringLiteral>(FormatExpr->IgnoreParenImpCasts())) { 2413 StringLiteral *FormatString = OSL->getString(); 2414 if (S.FormatStringHasSArg(FormatString)) { 2415 S.Diag(FormatExpr->getExprLoc(), diag::warn_objc_cdirective_format_string) 2416 << "%s" << 0 << 0; 2417 if (Method) 2418 S.Diag(Method->getLocation(), diag::note_method_declared_at) 2419 << Method->getDeclName(); 2420 } 2421 } 2422 } 2423 2424 /// Build an Objective-C class message expression. 2425 /// 2426 /// This routine takes care of both normal class messages and 2427 /// class messages to the superclass. 2428 /// 2429 /// \param ReceiverTypeInfo Type source information that describes the 2430 /// receiver of this message. This may be NULL, in which case we are 2431 /// sending to the superclass and \p SuperLoc must be a valid source 2432 /// location. 2433 2434 /// \param ReceiverType The type of the object receiving the 2435 /// message. When \p ReceiverTypeInfo is non-NULL, this is the same 2436 /// type as that refers to. For a superclass send, this is the type of 2437 /// the superclass. 2438 /// 2439 /// \param SuperLoc The location of the "super" keyword in a 2440 /// superclass message. 2441 /// 2442 /// \param Sel The selector to which the message is being sent. 2443 /// 2444 /// \param Method The method that this class message is invoking, if 2445 /// already known. 2446 /// 2447 /// \param LBracLoc The location of the opening square bracket ']'. 2448 /// 2449 /// \param RBracLoc The location of the closing square bracket ']'. 2450 /// 2451 /// \param ArgsIn The message arguments. 2452 ExprResult Sema::BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo, 2453 QualType ReceiverType, 2454 SourceLocation SuperLoc, 2455 Selector Sel, 2456 ObjCMethodDecl *Method, 2457 SourceLocation LBracLoc, 2458 ArrayRef<SourceLocation> SelectorLocs, 2459 SourceLocation RBracLoc, 2460 MultiExprArg ArgsIn, 2461 bool isImplicit) { 2462 SourceLocation Loc = SuperLoc.isValid()? SuperLoc 2463 : ReceiverTypeInfo->getTypeLoc().getSourceRange().getBegin(); 2464 if (LBracLoc.isInvalid()) { 2465 Diag(Loc, diag::err_missing_open_square_message_send) 2466 << FixItHint::CreateInsertion(Loc, "["); 2467 LBracLoc = Loc; 2468 } 2469 ArrayRef<SourceLocation> SelectorSlotLocs; 2470 if (!SelectorLocs.empty() && SelectorLocs.front().isValid()) 2471 SelectorSlotLocs = SelectorLocs; 2472 else 2473 SelectorSlotLocs = Loc; 2474 SourceLocation SelLoc = SelectorSlotLocs.front(); 2475 2476 if (ReceiverType->isDependentType()) { 2477 // If the receiver type is dependent, we can't type-check anything 2478 // at this point. Build a dependent expression. 2479 unsigned NumArgs = ArgsIn.size(); 2480 Expr **Args = ArgsIn.data(); 2481 assert(SuperLoc.isInvalid() && "Message to super with dependent type"); 2482 return ObjCMessageExpr::Create( 2483 Context, ReceiverType, VK_RValue, LBracLoc, ReceiverTypeInfo, Sel, 2484 SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs), RBracLoc, 2485 isImplicit); 2486 } 2487 2488 // Find the class to which we are sending this message. 2489 ObjCInterfaceDecl *Class = nullptr; 2490 const ObjCObjectType *ClassType = ReceiverType->getAs<ObjCObjectType>(); 2491 if (!ClassType || !(Class = ClassType->getInterface())) { 2492 Diag(Loc, diag::err_invalid_receiver_class_message) 2493 << ReceiverType; 2494 return ExprError(); 2495 } 2496 assert(Class && "We don't know which class we're messaging?"); 2497 // objc++ diagnoses during typename annotation. 2498 if (!getLangOpts().CPlusPlus) 2499 (void)DiagnoseUseOfDecl(Class, SelectorSlotLocs); 2500 // Find the method we are messaging. 2501 if (!Method) { 2502 SourceRange TypeRange 2503 = SuperLoc.isValid()? SourceRange(SuperLoc) 2504 : ReceiverTypeInfo->getTypeLoc().getSourceRange(); 2505 if (RequireCompleteType(Loc, Context.getObjCInterfaceType(Class), 2506 (getLangOpts().ObjCAutoRefCount 2507 ? diag::err_arc_receiver_forward_class 2508 : diag::warn_receiver_forward_class), 2509 TypeRange)) { 2510 // A forward class used in messaging is treated as a 'Class' 2511 Method = LookupFactoryMethodInGlobalPool(Sel, 2512 SourceRange(LBracLoc, RBracLoc)); 2513 if (Method && !getLangOpts().ObjCAutoRefCount) 2514 Diag(Method->getLocation(), diag::note_method_sent_forward_class) 2515 << Method->getDeclName(); 2516 } 2517 if (!Method) 2518 Method = Class->lookupClassMethod(Sel); 2519 2520 // If we have an implementation in scope, check "private" methods. 2521 if (!Method) 2522 Method = Class->lookupPrivateClassMethod(Sel); 2523 2524 if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs, 2525 nullptr, false, false, Class)) 2526 return ExprError(); 2527 } 2528 2529 // Check the argument types and determine the result type. 2530 QualType ReturnType; 2531 ExprValueKind VK = VK_RValue; 2532 2533 unsigned NumArgs = ArgsIn.size(); 2534 Expr **Args = ArgsIn.data(); 2535 if (CheckMessageArgumentTypes(/*Receiver=*/nullptr, ReceiverType, 2536 MultiExprArg(Args, NumArgs), Sel, SelectorLocs, 2537 Method, true, SuperLoc.isValid(), LBracLoc, 2538 RBracLoc, SourceRange(), ReturnType, VK)) 2539 return ExprError(); 2540 2541 if (Method && !Method->getReturnType()->isVoidType() && 2542 RequireCompleteType(LBracLoc, Method->getReturnType(), 2543 diag::err_illegal_message_expr_incomplete_type)) 2544 return ExprError(); 2545 2546 // Warn about explicit call of +initialize on its own class. But not on 'super'. 2547 if (Method && Method->getMethodFamily() == OMF_initialize) { 2548 if (!SuperLoc.isValid()) { 2549 const ObjCInterfaceDecl *ID = 2550 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext()); 2551 if (ID == Class) { 2552 Diag(Loc, diag::warn_direct_initialize_call); 2553 Diag(Method->getLocation(), diag::note_method_declared_at) 2554 << Method->getDeclName(); 2555 } 2556 } 2557 else if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) { 2558 // [super initialize] is allowed only within an +initialize implementation 2559 if (CurMeth->getMethodFamily() != OMF_initialize) { 2560 Diag(Loc, diag::warn_direct_super_initialize_call); 2561 Diag(Method->getLocation(), diag::note_method_declared_at) 2562 << Method->getDeclName(); 2563 Diag(CurMeth->getLocation(), diag::note_method_declared_at) 2564 << CurMeth->getDeclName(); 2565 } 2566 } 2567 } 2568 2569 DiagnoseCStringFormatDirectiveInObjCAPI(*this, Method, Sel, Args, NumArgs); 2570 2571 // Construct the appropriate ObjCMessageExpr. 2572 ObjCMessageExpr *Result; 2573 if (SuperLoc.isValid()) 2574 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, 2575 SuperLoc, /*IsInstanceSuper=*/false, 2576 ReceiverType, Sel, SelectorLocs, 2577 Method, makeArrayRef(Args, NumArgs), 2578 RBracLoc, isImplicit); 2579 else { 2580 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, 2581 ReceiverTypeInfo, Sel, SelectorLocs, 2582 Method, makeArrayRef(Args, NumArgs), 2583 RBracLoc, isImplicit); 2584 if (!isImplicit) 2585 checkCocoaAPI(*this, Result); 2586 } 2587 if (Method) 2588 checkFoundationAPI(*this, SelLoc, Method, makeArrayRef(Args, NumArgs), 2589 ReceiverType, /*IsClassObjectCall=*/true); 2590 return MaybeBindToTemporary(Result); 2591 } 2592 2593 // ActOnClassMessage - used for both unary and keyword messages. 2594 // ArgExprs is optional - if it is present, the number of expressions 2595 // is obtained from Sel.getNumArgs(). 2596 ExprResult Sema::ActOnClassMessage(Scope *S, 2597 ParsedType Receiver, 2598 Selector Sel, 2599 SourceLocation LBracLoc, 2600 ArrayRef<SourceLocation> SelectorLocs, 2601 SourceLocation RBracLoc, 2602 MultiExprArg Args) { 2603 TypeSourceInfo *ReceiverTypeInfo; 2604 QualType ReceiverType = GetTypeFromParser(Receiver, &ReceiverTypeInfo); 2605 if (ReceiverType.isNull()) 2606 return ExprError(); 2607 2608 if (!ReceiverTypeInfo) 2609 ReceiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType, LBracLoc); 2610 2611 return BuildClassMessage(ReceiverTypeInfo, ReceiverType, 2612 /*SuperLoc=*/SourceLocation(), Sel, 2613 /*Method=*/nullptr, LBracLoc, SelectorLocs, RBracLoc, 2614 Args); 2615 } 2616 2617 ExprResult Sema::BuildInstanceMessageImplicit(Expr *Receiver, 2618 QualType ReceiverType, 2619 SourceLocation Loc, 2620 Selector Sel, 2621 ObjCMethodDecl *Method, 2622 MultiExprArg Args) { 2623 return BuildInstanceMessage(Receiver, ReceiverType, 2624 /*SuperLoc=*/!Receiver ? Loc : SourceLocation(), 2625 Sel, Method, Loc, Loc, Loc, Args, 2626 /*isImplicit=*/true); 2627 } 2628 2629 static bool isMethodDeclaredInRootProtocol(Sema &S, const ObjCMethodDecl *M) { 2630 if (!S.NSAPIObj) 2631 return false; 2632 const auto *Protocol = dyn_cast<ObjCProtocolDecl>(M->getDeclContext()); 2633 if (!Protocol) 2634 return false; 2635 const IdentifierInfo *II = S.NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject); 2636 if (const auto *RootClass = dyn_cast_or_null<ObjCInterfaceDecl>( 2637 S.LookupSingleName(S.TUScope, II, Protocol->getBeginLoc(), 2638 Sema::LookupOrdinaryName))) { 2639 for (const ObjCProtocolDecl *P : RootClass->all_referenced_protocols()) { 2640 if (P->getCanonicalDecl() == Protocol->getCanonicalDecl()) 2641 return true; 2642 } 2643 } 2644 return false; 2645 } 2646 2647 /// Build an Objective-C instance message expression. 2648 /// 2649 /// This routine takes care of both normal instance messages and 2650 /// instance messages to the superclass instance. 2651 /// 2652 /// \param Receiver The expression that computes the object that will 2653 /// receive this message. This may be empty, in which case we are 2654 /// sending to the superclass instance and \p SuperLoc must be a valid 2655 /// source location. 2656 /// 2657 /// \param ReceiverType The (static) type of the object receiving the 2658 /// message. When a \p Receiver expression is provided, this is the 2659 /// same type as that expression. For a superclass instance send, this 2660 /// is a pointer to the type of the superclass. 2661 /// 2662 /// \param SuperLoc The location of the "super" keyword in a 2663 /// superclass instance message. 2664 /// 2665 /// \param Sel The selector to which the message is being sent. 2666 /// 2667 /// \param Method The method that this instance message is invoking, if 2668 /// already known. 2669 /// 2670 /// \param LBracLoc The location of the opening square bracket ']'. 2671 /// 2672 /// \param RBracLoc The location of the closing square bracket ']'. 2673 /// 2674 /// \param ArgsIn The message arguments. 2675 ExprResult Sema::BuildInstanceMessage(Expr *Receiver, 2676 QualType ReceiverType, 2677 SourceLocation SuperLoc, 2678 Selector Sel, 2679 ObjCMethodDecl *Method, 2680 SourceLocation LBracLoc, 2681 ArrayRef<SourceLocation> SelectorLocs, 2682 SourceLocation RBracLoc, 2683 MultiExprArg ArgsIn, 2684 bool isImplicit) { 2685 assert((Receiver || SuperLoc.isValid()) && "If the Receiver is null, the " 2686 "SuperLoc must be valid so we can " 2687 "use it instead."); 2688 2689 // The location of the receiver. 2690 SourceLocation Loc = SuperLoc.isValid() ? SuperLoc : Receiver->getBeginLoc(); 2691 SourceRange RecRange = 2692 SuperLoc.isValid()? SuperLoc : Receiver->getSourceRange(); 2693 ArrayRef<SourceLocation> SelectorSlotLocs; 2694 if (!SelectorLocs.empty() && SelectorLocs.front().isValid()) 2695 SelectorSlotLocs = SelectorLocs; 2696 else 2697 SelectorSlotLocs = Loc; 2698 SourceLocation SelLoc = SelectorSlotLocs.front(); 2699 2700 if (LBracLoc.isInvalid()) { 2701 Diag(Loc, diag::err_missing_open_square_message_send) 2702 << FixItHint::CreateInsertion(Loc, "["); 2703 LBracLoc = Loc; 2704 } 2705 2706 // If we have a receiver expression, perform appropriate promotions 2707 // and determine receiver type. 2708 if (Receiver) { 2709 if (Receiver->hasPlaceholderType()) { 2710 ExprResult Result; 2711 if (Receiver->getType() == Context.UnknownAnyTy) 2712 Result = forceUnknownAnyToType(Receiver, Context.getObjCIdType()); 2713 else 2714 Result = CheckPlaceholderExpr(Receiver); 2715 if (Result.isInvalid()) return ExprError(); 2716 Receiver = Result.get(); 2717 } 2718 2719 if (Receiver->isTypeDependent()) { 2720 // If the receiver is type-dependent, we can't type-check anything 2721 // at this point. Build a dependent expression. 2722 unsigned NumArgs = ArgsIn.size(); 2723 Expr **Args = ArgsIn.data(); 2724 assert(SuperLoc.isInvalid() && "Message to super with dependent type"); 2725 return ObjCMessageExpr::Create( 2726 Context, Context.DependentTy, VK_RValue, LBracLoc, Receiver, Sel, 2727 SelectorLocs, /*Method=*/nullptr, makeArrayRef(Args, NumArgs), 2728 RBracLoc, isImplicit); 2729 } 2730 2731 // If necessary, apply function/array conversion to the receiver. 2732 // C99 6.7.5.3p[7,8]. 2733 ExprResult Result = DefaultFunctionArrayLvalueConversion(Receiver); 2734 if (Result.isInvalid()) 2735 return ExprError(); 2736 Receiver = Result.get(); 2737 ReceiverType = Receiver->getType(); 2738 2739 // If the receiver is an ObjC pointer, a block pointer, or an 2740 // __attribute__((NSObject)) pointer, we don't need to do any 2741 // special conversion in order to look up a receiver. 2742 if (ReceiverType->isObjCRetainableType()) { 2743 // do nothing 2744 } else if (!getLangOpts().ObjCAutoRefCount && 2745 !Context.getObjCIdType().isNull() && 2746 (ReceiverType->isPointerType() || 2747 ReceiverType->isIntegerType())) { 2748 // Implicitly convert integers and pointers to 'id' but emit a warning. 2749 // But not in ARC. 2750 Diag(Loc, diag::warn_bad_receiver_type) 2751 << ReceiverType 2752 << Receiver->getSourceRange(); 2753 if (ReceiverType->isPointerType()) { 2754 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(), 2755 CK_CPointerToObjCPointerCast).get(); 2756 } else { 2757 // TODO: specialized warning on null receivers? 2758 bool IsNull = Receiver->isNullPointerConstant(Context, 2759 Expr::NPC_ValueDependentIsNull); 2760 CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer; 2761 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(), 2762 Kind).get(); 2763 } 2764 ReceiverType = Receiver->getType(); 2765 } else if (getLangOpts().CPlusPlus) { 2766 // The receiver must be a complete type. 2767 if (RequireCompleteType(Loc, Receiver->getType(), 2768 diag::err_incomplete_receiver_type)) 2769 return ExprError(); 2770 2771 ExprResult result = PerformContextuallyConvertToObjCPointer(Receiver); 2772 if (result.isUsable()) { 2773 Receiver = result.get(); 2774 ReceiverType = Receiver->getType(); 2775 } 2776 } 2777 } 2778 2779 if (ReceiverType->isObjCIdType() && !isImplicit) 2780 Diag(Receiver->getExprLoc(), diag::warn_messaging_unqualified_id); 2781 2782 // There's a somewhat weird interaction here where we assume that we 2783 // won't actually have a method unless we also don't need to do some 2784 // of the more detailed type-checking on the receiver. 2785 2786 if (!Method) { 2787 // Handle messages to id and __kindof types (where we use the 2788 // global method pool). 2789 const ObjCObjectType *typeBound = nullptr; 2790 bool receiverIsIdLike = ReceiverType->isObjCIdOrObjectKindOfType(Context, 2791 typeBound); 2792 if (receiverIsIdLike || ReceiverType->isBlockPointerType() || 2793 (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) { 2794 SmallVector<ObjCMethodDecl*, 4> Methods; 2795 // If we have a type bound, further filter the methods. 2796 CollectMultipleMethodsInGlobalPool(Sel, Methods, true/*InstanceFirst*/, 2797 true/*CheckTheOther*/, typeBound); 2798 if (!Methods.empty()) { 2799 // We choose the first method as the initial candidate, then try to 2800 // select a better one. 2801 Method = Methods[0]; 2802 2803 if (ObjCMethodDecl *BestMethod = 2804 SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(), Methods)) 2805 Method = BestMethod; 2806 2807 if (!AreMultipleMethodsInGlobalPool(Sel, Method, 2808 SourceRange(LBracLoc, RBracLoc), 2809 receiverIsIdLike, Methods)) 2810 DiagnoseUseOfDecl(Method, SelectorSlotLocs); 2811 } 2812 } else if (ReceiverType->isObjCClassOrClassKindOfType() || 2813 ReceiverType->isObjCQualifiedClassType()) { 2814 // Handle messages to Class. 2815 // We allow sending a message to a qualified Class ("Class<foo>"), which 2816 // is ok as long as one of the protocols implements the selector (if not, 2817 // warn). 2818 if (!ReceiverType->isObjCClassOrClassKindOfType()) { 2819 const ObjCObjectPointerType *QClassTy 2820 = ReceiverType->getAsObjCQualifiedClassType(); 2821 // Search protocols for class methods. 2822 Method = LookupMethodInQualifiedType(Sel, QClassTy, false); 2823 if (!Method) { 2824 Method = LookupMethodInQualifiedType(Sel, QClassTy, true); 2825 // warn if instance method found for a Class message. 2826 if (Method && !isMethodDeclaredInRootProtocol(*this, Method)) { 2827 Diag(SelLoc, diag::warn_instance_method_on_class_found) 2828 << Method->getSelector() << Sel; 2829 Diag(Method->getLocation(), diag::note_method_declared_at) 2830 << Method->getDeclName(); 2831 } 2832 } 2833 } else { 2834 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) { 2835 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) { 2836 // As a guess, try looking for the method in the current interface. 2837 // This very well may not produce the "right" method. 2838 2839 // First check the public methods in the class interface. 2840 Method = ClassDecl->lookupClassMethod(Sel); 2841 2842 if (!Method) 2843 Method = ClassDecl->lookupPrivateClassMethod(Sel); 2844 2845 if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs)) 2846 return ExprError(); 2847 } 2848 } 2849 if (!Method) { 2850 // If not messaging 'self', look for any factory method named 'Sel'. 2851 if (!Receiver || !isSelfExpr(Receiver)) { 2852 // If no class (factory) method was found, check if an _instance_ 2853 // method of the same name exists in the root class only. 2854 SmallVector<ObjCMethodDecl*, 4> Methods; 2855 CollectMultipleMethodsInGlobalPool(Sel, Methods, 2856 false/*InstanceFirst*/, 2857 true/*CheckTheOther*/); 2858 if (!Methods.empty()) { 2859 // We choose the first method as the initial candidate, then try 2860 // to select a better one. 2861 Method = Methods[0]; 2862 2863 // If we find an instance method, emit warning. 2864 if (Method->isInstanceMethod()) { 2865 if (const ObjCInterfaceDecl *ID = 2866 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) { 2867 if (ID->getSuperClass()) 2868 Diag(SelLoc, diag::warn_root_inst_method_not_found) 2869 << Sel << SourceRange(LBracLoc, RBracLoc); 2870 } 2871 } 2872 2873 if (ObjCMethodDecl *BestMethod = 2874 SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(), 2875 Methods)) 2876 Method = BestMethod; 2877 } 2878 } 2879 } 2880 } 2881 } else { 2882 ObjCInterfaceDecl *ClassDecl = nullptr; 2883 2884 // We allow sending a message to a qualified ID ("id<foo>"), which is ok as 2885 // long as one of the protocols implements the selector (if not, warn). 2886 // And as long as message is not deprecated/unavailable (warn if it is). 2887 if (const ObjCObjectPointerType *QIdTy 2888 = ReceiverType->getAsObjCQualifiedIdType()) { 2889 // Search protocols for instance methods. 2890 Method = LookupMethodInQualifiedType(Sel, QIdTy, true); 2891 if (!Method) 2892 Method = LookupMethodInQualifiedType(Sel, QIdTy, false); 2893 if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs)) 2894 return ExprError(); 2895 } else if (const ObjCObjectPointerType *OCIType 2896 = ReceiverType->getAsObjCInterfacePointerType()) { 2897 // We allow sending a message to a pointer to an interface (an object). 2898 ClassDecl = OCIType->getInterfaceDecl(); 2899 2900 // Try to complete the type. Under ARC, this is a hard error from which 2901 // we don't try to recover. 2902 // FIXME: In the non-ARC case, this will still be a hard error if the 2903 // definition is found in a module that's not visible. 2904 const ObjCInterfaceDecl *forwardClass = nullptr; 2905 if (RequireCompleteType(Loc, OCIType->getPointeeType(), 2906 getLangOpts().ObjCAutoRefCount 2907 ? diag::err_arc_receiver_forward_instance 2908 : diag::warn_receiver_forward_instance, 2909 Receiver? Receiver->getSourceRange() 2910 : SourceRange(SuperLoc))) { 2911 if (getLangOpts().ObjCAutoRefCount) 2912 return ExprError(); 2913 2914 forwardClass = OCIType->getInterfaceDecl(); 2915 Diag(Receiver ? Receiver->getBeginLoc() : SuperLoc, 2916 diag::note_receiver_is_id); 2917 Method = nullptr; 2918 } else { 2919 Method = ClassDecl->lookupInstanceMethod(Sel); 2920 } 2921 2922 if (!Method) 2923 // Search protocol qualifiers. 2924 Method = LookupMethodInQualifiedType(Sel, OCIType, true); 2925 2926 if (!Method) { 2927 // If we have implementations in scope, check "private" methods. 2928 Method = ClassDecl->lookupPrivateMethod(Sel); 2929 2930 if (!Method && getLangOpts().ObjCAutoRefCount) { 2931 Diag(SelLoc, diag::err_arc_may_not_respond) 2932 << OCIType->getPointeeType() << Sel << RecRange 2933 << SourceRange(SelectorLocs.front(), SelectorLocs.back()); 2934 return ExprError(); 2935 } 2936 2937 if (!Method && (!Receiver || !isSelfExpr(Receiver))) { 2938 // If we still haven't found a method, look in the global pool. This 2939 // behavior isn't very desirable, however we need it for GCC 2940 // compatibility. FIXME: should we deviate?? 2941 if (OCIType->qual_empty()) { 2942 SmallVector<ObjCMethodDecl*, 4> Methods; 2943 CollectMultipleMethodsInGlobalPool(Sel, Methods, 2944 true/*InstanceFirst*/, 2945 false/*CheckTheOther*/); 2946 if (!Methods.empty()) { 2947 // We choose the first method as the initial candidate, then try 2948 // to select a better one. 2949 Method = Methods[0]; 2950 2951 if (ObjCMethodDecl *BestMethod = 2952 SelectBestMethod(Sel, ArgsIn, Method->isInstanceMethod(), 2953 Methods)) 2954 Method = BestMethod; 2955 2956 AreMultipleMethodsInGlobalPool(Sel, Method, 2957 SourceRange(LBracLoc, RBracLoc), 2958 true/*receiverIdOrClass*/, 2959 Methods); 2960 } 2961 if (Method && !forwardClass) 2962 Diag(SelLoc, diag::warn_maynot_respond) 2963 << OCIType->getInterfaceDecl()->getIdentifier() 2964 << Sel << RecRange; 2965 } 2966 } 2967 } 2968 if (Method && DiagnoseUseOfDecl(Method, SelectorSlotLocs, forwardClass)) 2969 return ExprError(); 2970 } else { 2971 // Reject other random receiver types (e.g. structs). 2972 Diag(Loc, diag::err_bad_receiver_type) 2973 << ReceiverType << Receiver->getSourceRange(); 2974 return ExprError(); 2975 } 2976 } 2977 } 2978 2979 FunctionScopeInfo *DIFunctionScopeInfo = 2980 (Method && Method->getMethodFamily() == OMF_init) 2981 ? getEnclosingFunction() : nullptr; 2982 2983 if (DIFunctionScopeInfo && 2984 DIFunctionScopeInfo->ObjCIsDesignatedInit && 2985 (SuperLoc.isValid() || isSelfExpr(Receiver))) { 2986 bool isDesignatedInitChain = false; 2987 if (SuperLoc.isValid()) { 2988 if (const ObjCObjectPointerType * 2989 OCIType = ReceiverType->getAsObjCInterfacePointerType()) { 2990 if (const ObjCInterfaceDecl *ID = OCIType->getInterfaceDecl()) { 2991 // Either we know this is a designated initializer or we 2992 // conservatively assume it because we don't know for sure. 2993 if (!ID->declaresOrInheritsDesignatedInitializers() || 2994 ID->isDesignatedInitializer(Sel)) { 2995 isDesignatedInitChain = true; 2996 DIFunctionScopeInfo->ObjCWarnForNoDesignatedInitChain = false; 2997 } 2998 } 2999 } 3000 } 3001 if (!isDesignatedInitChain) { 3002 const ObjCMethodDecl *InitMethod = nullptr; 3003 bool isDesignated = 3004 getCurMethodDecl()->isDesignatedInitializerForTheInterface(&InitMethod); 3005 assert(isDesignated && InitMethod); 3006 (void)isDesignated; 3007 Diag(SelLoc, SuperLoc.isValid() ? 3008 diag::warn_objc_designated_init_non_designated_init_call : 3009 diag::warn_objc_designated_init_non_super_designated_init_call); 3010 Diag(InitMethod->getLocation(), 3011 diag::note_objc_designated_init_marked_here); 3012 } 3013 } 3014 3015 if (DIFunctionScopeInfo && 3016 DIFunctionScopeInfo->ObjCIsSecondaryInit && 3017 (SuperLoc.isValid() || isSelfExpr(Receiver))) { 3018 if (SuperLoc.isValid()) { 3019 Diag(SelLoc, diag::warn_objc_secondary_init_super_init_call); 3020 } else { 3021 DIFunctionScopeInfo->ObjCWarnForNoInitDelegation = false; 3022 } 3023 } 3024 3025 // Check the message arguments. 3026 unsigned NumArgs = ArgsIn.size(); 3027 Expr **Args = ArgsIn.data(); 3028 QualType ReturnType; 3029 ExprValueKind VK = VK_RValue; 3030 bool ClassMessage = (ReceiverType->isObjCClassType() || 3031 ReceiverType->isObjCQualifiedClassType()); 3032 if (CheckMessageArgumentTypes(Receiver, ReceiverType, 3033 MultiExprArg(Args, NumArgs), Sel, SelectorLocs, 3034 Method, ClassMessage, SuperLoc.isValid(), 3035 LBracLoc, RBracLoc, RecRange, ReturnType, VK)) 3036 return ExprError(); 3037 3038 if (Method && !Method->getReturnType()->isVoidType() && 3039 RequireCompleteType(LBracLoc, Method->getReturnType(), 3040 diag::err_illegal_message_expr_incomplete_type)) 3041 return ExprError(); 3042 3043 // In ARC, forbid the user from sending messages to 3044 // retain/release/autorelease/dealloc/retainCount explicitly. 3045 if (getLangOpts().ObjCAutoRefCount) { 3046 ObjCMethodFamily family = 3047 (Method ? Method->getMethodFamily() : Sel.getMethodFamily()); 3048 switch (family) { 3049 case OMF_init: 3050 if (Method) 3051 checkInitMethod(Method, ReceiverType); 3052 break; 3053 3054 case OMF_None: 3055 case OMF_alloc: 3056 case OMF_copy: 3057 case OMF_finalize: 3058 case OMF_mutableCopy: 3059 case OMF_new: 3060 case OMF_self: 3061 case OMF_initialize: 3062 break; 3063 3064 case OMF_dealloc: 3065 case OMF_retain: 3066 case OMF_release: 3067 case OMF_autorelease: 3068 case OMF_retainCount: 3069 Diag(SelLoc, diag::err_arc_illegal_explicit_message) 3070 << Sel << RecRange; 3071 break; 3072 3073 case OMF_performSelector: 3074 if (Method && NumArgs >= 1) { 3075 if (const auto *SelExp = 3076 dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens())) { 3077 Selector ArgSel = SelExp->getSelector(); 3078 ObjCMethodDecl *SelMethod = 3079 LookupInstanceMethodInGlobalPool(ArgSel, 3080 SelExp->getSourceRange()); 3081 if (!SelMethod) 3082 SelMethod = 3083 LookupFactoryMethodInGlobalPool(ArgSel, 3084 SelExp->getSourceRange()); 3085 if (SelMethod) { 3086 ObjCMethodFamily SelFamily = SelMethod->getMethodFamily(); 3087 switch (SelFamily) { 3088 case OMF_alloc: 3089 case OMF_copy: 3090 case OMF_mutableCopy: 3091 case OMF_new: 3092 case OMF_init: 3093 // Issue error, unless ns_returns_not_retained. 3094 if (!SelMethod->hasAttr<NSReturnsNotRetainedAttr>()) { 3095 // selector names a +1 method 3096 Diag(SelLoc, 3097 diag::err_arc_perform_selector_retains); 3098 Diag(SelMethod->getLocation(), diag::note_method_declared_at) 3099 << SelMethod->getDeclName(); 3100 } 3101 break; 3102 default: 3103 // +0 call. OK. unless ns_returns_retained. 3104 if (SelMethod->hasAttr<NSReturnsRetainedAttr>()) { 3105 // selector names a +1 method 3106 Diag(SelLoc, 3107 diag::err_arc_perform_selector_retains); 3108 Diag(SelMethod->getLocation(), diag::note_method_declared_at) 3109 << SelMethod->getDeclName(); 3110 } 3111 break; 3112 } 3113 } 3114 } else { 3115 // error (may leak). 3116 Diag(SelLoc, diag::warn_arc_perform_selector_leaks); 3117 Diag(Args[0]->getExprLoc(), diag::note_used_here); 3118 } 3119 } 3120 break; 3121 } 3122 } 3123 3124 DiagnoseCStringFormatDirectiveInObjCAPI(*this, Method, Sel, Args, NumArgs); 3125 3126 // Construct the appropriate ObjCMessageExpr instance. 3127 ObjCMessageExpr *Result; 3128 if (SuperLoc.isValid()) 3129 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, 3130 SuperLoc, /*IsInstanceSuper=*/true, 3131 ReceiverType, Sel, SelectorLocs, Method, 3132 makeArrayRef(Args, NumArgs), RBracLoc, 3133 isImplicit); 3134 else { 3135 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, 3136 Receiver, Sel, SelectorLocs, Method, 3137 makeArrayRef(Args, NumArgs), RBracLoc, 3138 isImplicit); 3139 if (!isImplicit) 3140 checkCocoaAPI(*this, Result); 3141 } 3142 if (Method) { 3143 bool IsClassObjectCall = ClassMessage; 3144 // 'self' message receivers in class methods should be treated as message 3145 // sends to the class object in order for the semantic checks to be 3146 // performed correctly. Messages to 'super' already count as class messages, 3147 // so they don't need to be handled here. 3148 if (Receiver && isSelfExpr(Receiver)) { 3149 if (const auto *OPT = ReceiverType->getAs<ObjCObjectPointerType>()) { 3150 if (OPT->getObjectType()->isObjCClass()) { 3151 if (const auto *CurMeth = getCurMethodDecl()) { 3152 IsClassObjectCall = true; 3153 ReceiverType = 3154 Context.getObjCInterfaceType(CurMeth->getClassInterface()); 3155 } 3156 } 3157 } 3158 } 3159 checkFoundationAPI(*this, SelLoc, Method, makeArrayRef(Args, NumArgs), 3160 ReceiverType, IsClassObjectCall); 3161 } 3162 3163 if (getLangOpts().ObjCAutoRefCount) { 3164 // In ARC, annotate delegate init calls. 3165 if (Result->getMethodFamily() == OMF_init && 3166 (SuperLoc.isValid() || isSelfExpr(Receiver))) { 3167 // Only consider init calls *directly* in init implementations, 3168 // not within blocks. 3169 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(CurContext); 3170 if (method && method->getMethodFamily() == OMF_init) { 3171 // The implicit assignment to self means we also don't want to 3172 // consume the result. 3173 Result->setDelegateInitCall(true); 3174 return Result; 3175 } 3176 } 3177 3178 // In ARC, check for message sends which are likely to introduce 3179 // retain cycles. 3180 checkRetainCycles(Result); 3181 } 3182 3183 if (getLangOpts().ObjCWeak) { 3184 if (!isImplicit && Method) { 3185 if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) { 3186 bool IsWeak = 3187 Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak; 3188 if (!IsWeak && Sel.isUnarySelector()) 3189 IsWeak = ReturnType.getObjCLifetime() & Qualifiers::OCL_Weak; 3190 if (IsWeak && !isUnevaluatedContext() && 3191 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, LBracLoc)) 3192 getCurFunction()->recordUseOfWeak(Result, Prop); 3193 } 3194 } 3195 } 3196 3197 CheckObjCCircularContainer(Result); 3198 3199 return MaybeBindToTemporary(Result); 3200 } 3201 3202 static void RemoveSelectorFromWarningCache(Sema &S, Expr* Arg) { 3203 if (ObjCSelectorExpr *OSE = 3204 dyn_cast<ObjCSelectorExpr>(Arg->IgnoreParenCasts())) { 3205 Selector Sel = OSE->getSelector(); 3206 SourceLocation Loc = OSE->getAtLoc(); 3207 auto Pos = S.ReferencedSelectors.find(Sel); 3208 if (Pos != S.ReferencedSelectors.end() && Pos->second == Loc) 3209 S.ReferencedSelectors.erase(Pos); 3210 } 3211 } 3212 3213 // ActOnInstanceMessage - used for both unary and keyword messages. 3214 // ArgExprs is optional - if it is present, the number of expressions 3215 // is obtained from Sel.getNumArgs(). 3216 ExprResult Sema::ActOnInstanceMessage(Scope *S, 3217 Expr *Receiver, 3218 Selector Sel, 3219 SourceLocation LBracLoc, 3220 ArrayRef<SourceLocation> SelectorLocs, 3221 SourceLocation RBracLoc, 3222 MultiExprArg Args) { 3223 if (!Receiver) 3224 return ExprError(); 3225 3226 // A ParenListExpr can show up while doing error recovery with invalid code. 3227 if (isa<ParenListExpr>(Receiver)) { 3228 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Receiver); 3229 if (Result.isInvalid()) return ExprError(); 3230 Receiver = Result.get(); 3231 } 3232 3233 if (RespondsToSelectorSel.isNull()) { 3234 IdentifierInfo *SelectorId = &Context.Idents.get("respondsToSelector"); 3235 RespondsToSelectorSel = Context.Selectors.getUnarySelector(SelectorId); 3236 } 3237 if (Sel == RespondsToSelectorSel) 3238 RemoveSelectorFromWarningCache(*this, Args[0]); 3239 3240 return BuildInstanceMessage(Receiver, Receiver->getType(), 3241 /*SuperLoc=*/SourceLocation(), Sel, 3242 /*Method=*/nullptr, LBracLoc, SelectorLocs, 3243 RBracLoc, Args); 3244 } 3245 3246 enum ARCConversionTypeClass { 3247 /// int, void, struct A 3248 ACTC_none, 3249 3250 /// id, void (^)() 3251 ACTC_retainable, 3252 3253 /// id*, id***, void (^*)(), 3254 ACTC_indirectRetainable, 3255 3256 /// void* might be a normal C type, or it might a CF type. 3257 ACTC_voidPtr, 3258 3259 /// struct A* 3260 ACTC_coreFoundation 3261 }; 3262 3263 static bool isAnyRetainable(ARCConversionTypeClass ACTC) { 3264 return (ACTC == ACTC_retainable || 3265 ACTC == ACTC_coreFoundation || 3266 ACTC == ACTC_voidPtr); 3267 } 3268 3269 static bool isAnyCLike(ARCConversionTypeClass ACTC) { 3270 return ACTC == ACTC_none || 3271 ACTC == ACTC_voidPtr || 3272 ACTC == ACTC_coreFoundation; 3273 } 3274 3275 static ARCConversionTypeClass classifyTypeForARCConversion(QualType type) { 3276 bool isIndirect = false; 3277 3278 // Ignore an outermost reference type. 3279 if (const ReferenceType *ref = type->getAs<ReferenceType>()) { 3280 type = ref->getPointeeType(); 3281 isIndirect = true; 3282 } 3283 3284 // Drill through pointers and arrays recursively. 3285 while (true) { 3286 if (const PointerType *ptr = type->getAs<PointerType>()) { 3287 type = ptr->getPointeeType(); 3288 3289 // The first level of pointer may be the innermost pointer on a CF type. 3290 if (!isIndirect) { 3291 if (type->isVoidType()) return ACTC_voidPtr; 3292 if (type->isRecordType()) return ACTC_coreFoundation; 3293 } 3294 } else if (const ArrayType *array = type->getAsArrayTypeUnsafe()) { 3295 type = QualType(array->getElementType()->getBaseElementTypeUnsafe(), 0); 3296 } else { 3297 break; 3298 } 3299 isIndirect = true; 3300 } 3301 3302 if (isIndirect) { 3303 if (type->isObjCARCBridgableType()) 3304 return ACTC_indirectRetainable; 3305 return ACTC_none; 3306 } 3307 3308 if (type->isObjCARCBridgableType()) 3309 return ACTC_retainable; 3310 3311 return ACTC_none; 3312 } 3313 3314 namespace { 3315 /// A result from the cast checker. 3316 enum ACCResult { 3317 /// Cannot be casted. 3318 ACC_invalid, 3319 3320 /// Can be safely retained or not retained. 3321 ACC_bottom, 3322 3323 /// Can be casted at +0. 3324 ACC_plusZero, 3325 3326 /// Can be casted at +1. 3327 ACC_plusOne 3328 }; 3329 ACCResult merge(ACCResult left, ACCResult right) { 3330 if (left == right) return left; 3331 if (left == ACC_bottom) return right; 3332 if (right == ACC_bottom) return left; 3333 return ACC_invalid; 3334 } 3335 3336 /// A checker which white-lists certain expressions whose conversion 3337 /// to or from retainable type would otherwise be forbidden in ARC. 3338 class ARCCastChecker : public StmtVisitor<ARCCastChecker, ACCResult> { 3339 typedef StmtVisitor<ARCCastChecker, ACCResult> super; 3340 3341 ASTContext &Context; 3342 ARCConversionTypeClass SourceClass; 3343 ARCConversionTypeClass TargetClass; 3344 bool Diagnose; 3345 3346 static bool isCFType(QualType type) { 3347 // Someday this can use ns_bridged. For now, it has to do this. 3348 return type->isCARCBridgableType(); 3349 } 3350 3351 public: 3352 ARCCastChecker(ASTContext &Context, ARCConversionTypeClass source, 3353 ARCConversionTypeClass target, bool diagnose) 3354 : Context(Context), SourceClass(source), TargetClass(target), 3355 Diagnose(diagnose) {} 3356 3357 using super::Visit; 3358 ACCResult Visit(Expr *e) { 3359 return super::Visit(e->IgnoreParens()); 3360 } 3361 3362 ACCResult VisitStmt(Stmt *s) { 3363 return ACC_invalid; 3364 } 3365 3366 /// Null pointer constants can be casted however you please. 3367 ACCResult VisitExpr(Expr *e) { 3368 if (e->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull)) 3369 return ACC_bottom; 3370 return ACC_invalid; 3371 } 3372 3373 /// Objective-C string literals can be safely casted. 3374 ACCResult VisitObjCStringLiteral(ObjCStringLiteral *e) { 3375 // If we're casting to any retainable type, go ahead. Global 3376 // strings are immune to retains, so this is bottom. 3377 if (isAnyRetainable(TargetClass)) return ACC_bottom; 3378 3379 return ACC_invalid; 3380 } 3381 3382 /// Look through certain implicit and explicit casts. 3383 ACCResult VisitCastExpr(CastExpr *e) { 3384 switch (e->getCastKind()) { 3385 case CK_NullToPointer: 3386 return ACC_bottom; 3387 3388 case CK_NoOp: 3389 case CK_LValueToRValue: 3390 case CK_BitCast: 3391 case CK_CPointerToObjCPointerCast: 3392 case CK_BlockPointerToObjCPointerCast: 3393 case CK_AnyPointerToBlockPointerCast: 3394 return Visit(e->getSubExpr()); 3395 3396 default: 3397 return ACC_invalid; 3398 } 3399 } 3400 3401 /// Look through unary extension. 3402 ACCResult VisitUnaryExtension(UnaryOperator *e) { 3403 return Visit(e->getSubExpr()); 3404 } 3405 3406 /// Ignore the LHS of a comma operator. 3407 ACCResult VisitBinComma(BinaryOperator *e) { 3408 return Visit(e->getRHS()); 3409 } 3410 3411 /// Conditional operators are okay if both sides are okay. 3412 ACCResult VisitConditionalOperator(ConditionalOperator *e) { 3413 ACCResult left = Visit(e->getTrueExpr()); 3414 if (left == ACC_invalid) return ACC_invalid; 3415 return merge(left, Visit(e->getFalseExpr())); 3416 } 3417 3418 /// Look through pseudo-objects. 3419 ACCResult VisitPseudoObjectExpr(PseudoObjectExpr *e) { 3420 // If we're getting here, we should always have a result. 3421 return Visit(e->getResultExpr()); 3422 } 3423 3424 /// Statement expressions are okay if their result expression is okay. 3425 ACCResult VisitStmtExpr(StmtExpr *e) { 3426 return Visit(e->getSubStmt()->body_back()); 3427 } 3428 3429 /// Some declaration references are okay. 3430 ACCResult VisitDeclRefExpr(DeclRefExpr *e) { 3431 VarDecl *var = dyn_cast<VarDecl>(e->getDecl()); 3432 // References to global constants are okay. 3433 if (isAnyRetainable(TargetClass) && 3434 isAnyRetainable(SourceClass) && 3435 var && 3436 !var->hasDefinition(Context) && 3437 var->getType().isConstQualified()) { 3438 3439 // In system headers, they can also be assumed to be immune to retains. 3440 // These are things like 'kCFStringTransformToLatin'. 3441 if (Context.getSourceManager().isInSystemHeader(var->getLocation())) 3442 return ACC_bottom; 3443 3444 return ACC_plusZero; 3445 } 3446 3447 // Nothing else. 3448 return ACC_invalid; 3449 } 3450 3451 /// Some calls are okay. 3452 ACCResult VisitCallExpr(CallExpr *e) { 3453 if (FunctionDecl *fn = e->getDirectCallee()) 3454 if (ACCResult result = checkCallToFunction(fn)) 3455 return result; 3456 3457 return super::VisitCallExpr(e); 3458 } 3459 3460 ACCResult checkCallToFunction(FunctionDecl *fn) { 3461 // Require a CF*Ref return type. 3462 if (!isCFType(fn->getReturnType())) 3463 return ACC_invalid; 3464 3465 if (!isAnyRetainable(TargetClass)) 3466 return ACC_invalid; 3467 3468 // Honor an explicit 'not retained' attribute. 3469 if (fn->hasAttr<CFReturnsNotRetainedAttr>()) 3470 return ACC_plusZero; 3471 3472 // Honor an explicit 'retained' attribute, except that for 3473 // now we're not going to permit implicit handling of +1 results, 3474 // because it's a bit frightening. 3475 if (fn->hasAttr<CFReturnsRetainedAttr>()) 3476 return Diagnose ? ACC_plusOne 3477 : ACC_invalid; // ACC_plusOne if we start accepting this 3478 3479 // Recognize this specific builtin function, which is used by CFSTR. 3480 unsigned builtinID = fn->getBuiltinID(); 3481 if (builtinID == Builtin::BI__builtin___CFStringMakeConstantString) 3482 return ACC_bottom; 3483 3484 // Otherwise, don't do anything implicit with an unaudited function. 3485 if (!fn->hasAttr<CFAuditedTransferAttr>()) 3486 return ACC_invalid; 3487 3488 // Otherwise, it's +0 unless it follows the create convention. 3489 if (ento::coreFoundation::followsCreateRule(fn)) 3490 return Diagnose ? ACC_plusOne 3491 : ACC_invalid; // ACC_plusOne if we start accepting this 3492 3493 return ACC_plusZero; 3494 } 3495 3496 ACCResult VisitObjCMessageExpr(ObjCMessageExpr *e) { 3497 return checkCallToMethod(e->getMethodDecl()); 3498 } 3499 3500 ACCResult VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *e) { 3501 ObjCMethodDecl *method; 3502 if (e->isExplicitProperty()) 3503 method = e->getExplicitProperty()->getGetterMethodDecl(); 3504 else 3505 method = e->getImplicitPropertyGetter(); 3506 return checkCallToMethod(method); 3507 } 3508 3509 ACCResult checkCallToMethod(ObjCMethodDecl *method) { 3510 if (!method) return ACC_invalid; 3511 3512 // Check for message sends to functions returning CF types. We 3513 // just obey the Cocoa conventions with these, even though the 3514 // return type is CF. 3515 if (!isAnyRetainable(TargetClass) || !isCFType(method->getReturnType())) 3516 return ACC_invalid; 3517 3518 // If the method is explicitly marked not-retained, it's +0. 3519 if (method->hasAttr<CFReturnsNotRetainedAttr>()) 3520 return ACC_plusZero; 3521 3522 // If the method is explicitly marked as returning retained, or its 3523 // selector follows a +1 Cocoa convention, treat it as +1. 3524 if (method->hasAttr<CFReturnsRetainedAttr>()) 3525 return ACC_plusOne; 3526 3527 switch (method->getSelector().getMethodFamily()) { 3528 case OMF_alloc: 3529 case OMF_copy: 3530 case OMF_mutableCopy: 3531 case OMF_new: 3532 return ACC_plusOne; 3533 3534 default: 3535 // Otherwise, treat it as +0. 3536 return ACC_plusZero; 3537 } 3538 } 3539 }; 3540 } // end anonymous namespace 3541 3542 bool Sema::isKnownName(StringRef name) { 3543 if (name.empty()) 3544 return false; 3545 LookupResult R(*this, &Context.Idents.get(name), SourceLocation(), 3546 Sema::LookupOrdinaryName); 3547 return LookupName(R, TUScope, false); 3548 } 3549 3550 static void addFixitForObjCARCConversion(Sema &S, 3551 DiagnosticBuilder &DiagB, 3552 Sema::CheckedConversionKind CCK, 3553 SourceLocation afterLParen, 3554 QualType castType, 3555 Expr *castExpr, 3556 Expr *realCast, 3557 const char *bridgeKeyword, 3558 const char *CFBridgeName) { 3559 // We handle C-style and implicit casts here. 3560 switch (CCK) { 3561 case Sema::CCK_ImplicitConversion: 3562 case Sema::CCK_ForBuiltinOverloadedOp: 3563 case Sema::CCK_CStyleCast: 3564 case Sema::CCK_OtherCast: 3565 break; 3566 case Sema::CCK_FunctionalCast: 3567 return; 3568 } 3569 3570 if (CFBridgeName) { 3571 if (CCK == Sema::CCK_OtherCast) { 3572 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) { 3573 SourceRange range(NCE->getOperatorLoc(), 3574 NCE->getAngleBrackets().getEnd()); 3575 SmallString<32> BridgeCall; 3576 3577 SourceManager &SM = S.getSourceManager(); 3578 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1)); 3579 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts())) 3580 BridgeCall += ' '; 3581 3582 BridgeCall += CFBridgeName; 3583 DiagB.AddFixItHint(FixItHint::CreateReplacement(range, BridgeCall)); 3584 } 3585 return; 3586 } 3587 Expr *castedE = castExpr; 3588 if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(castedE)) 3589 castedE = CCE->getSubExpr(); 3590 castedE = castedE->IgnoreImpCasts(); 3591 SourceRange range = castedE->getSourceRange(); 3592 3593 SmallString<32> BridgeCall; 3594 3595 SourceManager &SM = S.getSourceManager(); 3596 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1)); 3597 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts())) 3598 BridgeCall += ' '; 3599 3600 BridgeCall += CFBridgeName; 3601 3602 if (isa<ParenExpr>(castedE)) { 3603 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(), 3604 BridgeCall)); 3605 } else { 3606 BridgeCall += '('; 3607 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(), 3608 BridgeCall)); 3609 DiagB.AddFixItHint(FixItHint::CreateInsertion( 3610 S.getLocForEndOfToken(range.getEnd()), 3611 ")")); 3612 } 3613 return; 3614 } 3615 3616 if (CCK == Sema::CCK_CStyleCast) { 3617 DiagB.AddFixItHint(FixItHint::CreateInsertion(afterLParen, bridgeKeyword)); 3618 } else if (CCK == Sema::CCK_OtherCast) { 3619 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) { 3620 std::string castCode = "("; 3621 castCode += bridgeKeyword; 3622 castCode += castType.getAsString(); 3623 castCode += ")"; 3624 SourceRange Range(NCE->getOperatorLoc(), 3625 NCE->getAngleBrackets().getEnd()); 3626 DiagB.AddFixItHint(FixItHint::CreateReplacement(Range, castCode)); 3627 } 3628 } else { 3629 std::string castCode = "("; 3630 castCode += bridgeKeyword; 3631 castCode += castType.getAsString(); 3632 castCode += ")"; 3633 Expr *castedE = castExpr->IgnoreImpCasts(); 3634 SourceRange range = castedE->getSourceRange(); 3635 if (isa<ParenExpr>(castedE)) { 3636 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(), 3637 castCode)); 3638 } else { 3639 castCode += "("; 3640 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(), 3641 castCode)); 3642 DiagB.AddFixItHint(FixItHint::CreateInsertion( 3643 S.getLocForEndOfToken(range.getEnd()), 3644 ")")); 3645 } 3646 } 3647 } 3648 3649 template <typename T> 3650 static inline T *getObjCBridgeAttr(const TypedefType *TD) { 3651 TypedefNameDecl *TDNDecl = TD->getDecl(); 3652 QualType QT = TDNDecl->getUnderlyingType(); 3653 if (QT->isPointerType()) { 3654 QT = QT->getPointeeType(); 3655 if (const RecordType *RT = QT->getAs<RecordType>()) 3656 if (RecordDecl *RD = RT->getDecl()->getMostRecentDecl()) 3657 return RD->getAttr<T>(); 3658 } 3659 return nullptr; 3660 } 3661 3662 static ObjCBridgeRelatedAttr *ObjCBridgeRelatedAttrFromType(QualType T, 3663 TypedefNameDecl *&TDNDecl) { 3664 while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) { 3665 TDNDecl = TD->getDecl(); 3666 if (ObjCBridgeRelatedAttr *ObjCBAttr = 3667 getObjCBridgeAttr<ObjCBridgeRelatedAttr>(TD)) 3668 return ObjCBAttr; 3669 T = TDNDecl->getUnderlyingType(); 3670 } 3671 return nullptr; 3672 } 3673 3674 static void 3675 diagnoseObjCARCConversion(Sema &S, SourceRange castRange, 3676 QualType castType, ARCConversionTypeClass castACTC, 3677 Expr *castExpr, Expr *realCast, 3678 ARCConversionTypeClass exprACTC, 3679 Sema::CheckedConversionKind CCK) { 3680 SourceLocation loc = 3681 (castRange.isValid() ? castRange.getBegin() : castExpr->getExprLoc()); 3682 3683 if (S.makeUnavailableInSystemHeader(loc, 3684 UnavailableAttr::IR_ARCForbiddenConversion)) 3685 return; 3686 3687 QualType castExprType = castExpr->getType(); 3688 // Defer emitting a diagnostic for bridge-related casts; that will be 3689 // handled by CheckObjCBridgeRelatedConversions. 3690 TypedefNameDecl *TDNDecl = nullptr; 3691 if ((castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable && 3692 ObjCBridgeRelatedAttrFromType(castType, TDNDecl)) || 3693 (exprACTC == ACTC_coreFoundation && castACTC == ACTC_retainable && 3694 ObjCBridgeRelatedAttrFromType(castExprType, TDNDecl))) 3695 return; 3696 3697 unsigned srcKind = 0; 3698 switch (exprACTC) { 3699 case ACTC_none: 3700 case ACTC_coreFoundation: 3701 case ACTC_voidPtr: 3702 srcKind = (castExprType->isPointerType() ? 1 : 0); 3703 break; 3704 case ACTC_retainable: 3705 srcKind = (castExprType->isBlockPointerType() ? 2 : 3); 3706 break; 3707 case ACTC_indirectRetainable: 3708 srcKind = 4; 3709 break; 3710 } 3711 3712 // Check whether this could be fixed with a bridge cast. 3713 SourceLocation afterLParen = S.getLocForEndOfToken(castRange.getBegin()); 3714 SourceLocation noteLoc = afterLParen.isValid() ? afterLParen : loc; 3715 3716 unsigned convKindForDiag = Sema::isCast(CCK) ? 0 : 1; 3717 3718 // Bridge from an ARC type to a CF type. 3719 if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) { 3720 3721 S.Diag(loc, diag::err_arc_cast_requires_bridge) 3722 << convKindForDiag 3723 << 2 // of C pointer type 3724 << castExprType 3725 << unsigned(castType->isBlockPointerType()) // to ObjC|block type 3726 << castType 3727 << castRange 3728 << castExpr->getSourceRange(); 3729 bool br = S.isKnownName("CFBridgingRelease"); 3730 ACCResult CreateRule = 3731 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr); 3732 assert(CreateRule != ACC_bottom && "This cast should already be accepted."); 3733 if (CreateRule != ACC_plusOne) 3734 { 3735 DiagnosticBuilder DiagB = 3736 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge) 3737 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge); 3738 3739 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen, 3740 castType, castExpr, realCast, "__bridge ", 3741 nullptr); 3742 } 3743 if (CreateRule != ACC_plusZero) 3744 { 3745 DiagnosticBuilder DiagB = 3746 (CCK == Sema::CCK_OtherCast && !br) ? 3747 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_transfer) << castExprType : 3748 S.Diag(br ? castExpr->getExprLoc() : noteLoc, 3749 diag::note_arc_bridge_transfer) 3750 << castExprType << br; 3751 3752 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen, 3753 castType, castExpr, realCast, "__bridge_transfer ", 3754 br ? "CFBridgingRelease" : nullptr); 3755 } 3756 3757 return; 3758 } 3759 3760 // Bridge from a CF type to an ARC type. 3761 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) { 3762 bool br = S.isKnownName("CFBridgingRetain"); 3763 S.Diag(loc, diag::err_arc_cast_requires_bridge) 3764 << convKindForDiag 3765 << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type 3766 << castExprType 3767 << 2 // to C pointer type 3768 << castType 3769 << castRange 3770 << castExpr->getSourceRange(); 3771 ACCResult CreateRule = 3772 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr); 3773 assert(CreateRule != ACC_bottom && "This cast should already be accepted."); 3774 if (CreateRule != ACC_plusOne) 3775 { 3776 DiagnosticBuilder DiagB = 3777 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge) 3778 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge); 3779 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen, 3780 castType, castExpr, realCast, "__bridge ", 3781 nullptr); 3782 } 3783 if (CreateRule != ACC_plusZero) 3784 { 3785 DiagnosticBuilder DiagB = 3786 (CCK == Sema::CCK_OtherCast && !br) ? 3787 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained) << castType : 3788 S.Diag(br ? castExpr->getExprLoc() : noteLoc, 3789 diag::note_arc_bridge_retained) 3790 << castType << br; 3791 3792 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen, 3793 castType, castExpr, realCast, "__bridge_retained ", 3794 br ? "CFBridgingRetain" : nullptr); 3795 } 3796 3797 return; 3798 } 3799 3800 S.Diag(loc, diag::err_arc_mismatched_cast) 3801 << !convKindForDiag 3802 << srcKind << castExprType << castType 3803 << castRange << castExpr->getSourceRange(); 3804 } 3805 3806 template <typename TB> 3807 static bool CheckObjCBridgeNSCast(Sema &S, QualType castType, Expr *castExpr, 3808 bool &HadTheAttribute, bool warn) { 3809 QualType T = castExpr->getType(); 3810 HadTheAttribute = false; 3811 while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) { 3812 TypedefNameDecl *TDNDecl = TD->getDecl(); 3813 if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) { 3814 if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) { 3815 HadTheAttribute = true; 3816 if (Parm->isStr("id")) 3817 return true; 3818 3819 NamedDecl *Target = nullptr; 3820 // Check for an existing type with this name. 3821 LookupResult R(S, DeclarationName(Parm), SourceLocation(), 3822 Sema::LookupOrdinaryName); 3823 if (S.LookupName(R, S.TUScope)) { 3824 Target = R.getFoundDecl(); 3825 if (Target && isa<ObjCInterfaceDecl>(Target)) { 3826 ObjCInterfaceDecl *ExprClass = cast<ObjCInterfaceDecl>(Target); 3827 if (const ObjCObjectPointerType *InterfacePointerType = 3828 castType->getAsObjCInterfacePointerType()) { 3829 ObjCInterfaceDecl *CastClass 3830 = InterfacePointerType->getObjectType()->getInterface(); 3831 if ((CastClass == ExprClass) || 3832 (CastClass && CastClass->isSuperClassOf(ExprClass))) 3833 return true; 3834 if (warn) 3835 S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge) 3836 << T << Target->getName() << castType->getPointeeType(); 3837 return false; 3838 } else if (castType->isObjCIdType() || 3839 (S.Context.ObjCObjectAdoptsQTypeProtocols( 3840 castType, ExprClass))) 3841 // ok to cast to 'id'. 3842 // casting to id<p-list> is ok if bridge type adopts all of 3843 // p-list protocols. 3844 return true; 3845 else { 3846 if (warn) { 3847 S.Diag(castExpr->getBeginLoc(), diag::warn_objc_invalid_bridge) 3848 << T << Target->getName() << castType; 3849 S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 3850 S.Diag(Target->getBeginLoc(), diag::note_declared_at); 3851 } 3852 return false; 3853 } 3854 } 3855 } else if (!castType->isObjCIdType()) { 3856 S.Diag(castExpr->getBeginLoc(), 3857 diag::err_objc_cf_bridged_not_interface) 3858 << castExpr->getType() << Parm; 3859 S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 3860 if (Target) 3861 S.Diag(Target->getBeginLoc(), diag::note_declared_at); 3862 } 3863 return true; 3864 } 3865 return false; 3866 } 3867 T = TDNDecl->getUnderlyingType(); 3868 } 3869 return true; 3870 } 3871 3872 template <typename TB> 3873 static bool CheckObjCBridgeCFCast(Sema &S, QualType castType, Expr *castExpr, 3874 bool &HadTheAttribute, bool warn) { 3875 QualType T = castType; 3876 HadTheAttribute = false; 3877 while (const TypedefType *TD = dyn_cast<TypedefType>(T.getTypePtr())) { 3878 TypedefNameDecl *TDNDecl = TD->getDecl(); 3879 if (TB *ObjCBAttr = getObjCBridgeAttr<TB>(TD)) { 3880 if (IdentifierInfo *Parm = ObjCBAttr->getBridgedType()) { 3881 HadTheAttribute = true; 3882 if (Parm->isStr("id")) 3883 return true; 3884 3885 NamedDecl *Target = nullptr; 3886 // Check for an existing type with this name. 3887 LookupResult R(S, DeclarationName(Parm), SourceLocation(), 3888 Sema::LookupOrdinaryName); 3889 if (S.LookupName(R, S.TUScope)) { 3890 Target = R.getFoundDecl(); 3891 if (Target && isa<ObjCInterfaceDecl>(Target)) { 3892 ObjCInterfaceDecl *CastClass = cast<ObjCInterfaceDecl>(Target); 3893 if (const ObjCObjectPointerType *InterfacePointerType = 3894 castExpr->getType()->getAsObjCInterfacePointerType()) { 3895 ObjCInterfaceDecl *ExprClass 3896 = InterfacePointerType->getObjectType()->getInterface(); 3897 if ((CastClass == ExprClass) || 3898 (ExprClass && CastClass->isSuperClassOf(ExprClass))) 3899 return true; 3900 if (warn) { 3901 S.Diag(castExpr->getBeginLoc(), 3902 diag::warn_objc_invalid_bridge_to_cf) 3903 << castExpr->getType()->getPointeeType() << T; 3904 S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 3905 } 3906 return false; 3907 } else if (castExpr->getType()->isObjCIdType() || 3908 (S.Context.QIdProtocolsAdoptObjCObjectProtocols( 3909 castExpr->getType(), CastClass))) 3910 // ok to cast an 'id' expression to a CFtype. 3911 // ok to cast an 'id<plist>' expression to CFtype provided plist 3912 // adopts all of CFtype's ObjetiveC's class plist. 3913 return true; 3914 else { 3915 if (warn) { 3916 S.Diag(castExpr->getBeginLoc(), 3917 diag::warn_objc_invalid_bridge_to_cf) 3918 << castExpr->getType() << castType; 3919 S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 3920 S.Diag(Target->getBeginLoc(), diag::note_declared_at); 3921 } 3922 return false; 3923 } 3924 } 3925 } 3926 S.Diag(castExpr->getBeginLoc(), 3927 diag::err_objc_ns_bridged_invalid_cfobject) 3928 << castExpr->getType() << castType; 3929 S.Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 3930 if (Target) 3931 S.Diag(Target->getBeginLoc(), diag::note_declared_at); 3932 return true; 3933 } 3934 return false; 3935 } 3936 T = TDNDecl->getUnderlyingType(); 3937 } 3938 return true; 3939 } 3940 3941 void Sema::CheckTollFreeBridgeCast(QualType castType, Expr *castExpr) { 3942 if (!getLangOpts().ObjC) 3943 return; 3944 // warn in presence of __bridge casting to or from a toll free bridge cast. 3945 ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExpr->getType()); 3946 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(castType); 3947 if (castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) { 3948 bool HasObjCBridgeAttr; 3949 bool ObjCBridgeAttrWillNotWarn = 3950 CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr, 3951 false); 3952 if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr) 3953 return; 3954 bool HasObjCBridgeMutableAttr; 3955 bool ObjCBridgeMutableAttrWillNotWarn = 3956 CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr, 3957 HasObjCBridgeMutableAttr, false); 3958 if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr) 3959 return; 3960 3961 if (HasObjCBridgeAttr) 3962 CheckObjCBridgeNSCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr, 3963 true); 3964 else if (HasObjCBridgeMutableAttr) 3965 CheckObjCBridgeNSCast<ObjCBridgeMutableAttr>(*this, castType, castExpr, 3966 HasObjCBridgeMutableAttr, true); 3967 } 3968 else if (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable) { 3969 bool HasObjCBridgeAttr; 3970 bool ObjCBridgeAttrWillNotWarn = 3971 CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr, 3972 false); 3973 if (ObjCBridgeAttrWillNotWarn && HasObjCBridgeAttr) 3974 return; 3975 bool HasObjCBridgeMutableAttr; 3976 bool ObjCBridgeMutableAttrWillNotWarn = 3977 CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr, 3978 HasObjCBridgeMutableAttr, false); 3979 if (ObjCBridgeMutableAttrWillNotWarn && HasObjCBridgeMutableAttr) 3980 return; 3981 3982 if (HasObjCBridgeAttr) 3983 CheckObjCBridgeCFCast<ObjCBridgeAttr>(*this, castType, castExpr, HasObjCBridgeAttr, 3984 true); 3985 else if (HasObjCBridgeMutableAttr) 3986 CheckObjCBridgeCFCast<ObjCBridgeMutableAttr>(*this, castType, castExpr, 3987 HasObjCBridgeMutableAttr, true); 3988 } 3989 } 3990 3991 void Sema::CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr) { 3992 QualType SrcType = castExpr->getType(); 3993 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(castExpr)) { 3994 if (PRE->isExplicitProperty()) { 3995 if (ObjCPropertyDecl *PDecl = PRE->getExplicitProperty()) 3996 SrcType = PDecl->getType(); 3997 } 3998 else if (PRE->isImplicitProperty()) { 3999 if (ObjCMethodDecl *Getter = PRE->getImplicitPropertyGetter()) 4000 SrcType = Getter->getReturnType(); 4001 } 4002 } 4003 4004 ARCConversionTypeClass srcExprACTC = classifyTypeForARCConversion(SrcType); 4005 ARCConversionTypeClass castExprACTC = classifyTypeForARCConversion(castType); 4006 if (srcExprACTC != ACTC_retainable || castExprACTC != ACTC_coreFoundation) 4007 return; 4008 CheckObjCBridgeRelatedConversions(castExpr->getBeginLoc(), castType, SrcType, 4009 castExpr); 4010 } 4011 4012 bool Sema::CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr, 4013 CastKind &Kind) { 4014 if (!getLangOpts().ObjC) 4015 return false; 4016 ARCConversionTypeClass exprACTC = 4017 classifyTypeForARCConversion(castExpr->getType()); 4018 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(castType); 4019 if ((castACTC == ACTC_retainable && exprACTC == ACTC_coreFoundation) || 4020 (castACTC == ACTC_coreFoundation && exprACTC == ACTC_retainable)) { 4021 CheckTollFreeBridgeCast(castType, castExpr); 4022 Kind = (castACTC == ACTC_coreFoundation) ? CK_BitCast 4023 : CK_CPointerToObjCPointerCast; 4024 return true; 4025 } 4026 return false; 4027 } 4028 4029 bool Sema::checkObjCBridgeRelatedComponents(SourceLocation Loc, 4030 QualType DestType, QualType SrcType, 4031 ObjCInterfaceDecl *&RelatedClass, 4032 ObjCMethodDecl *&ClassMethod, 4033 ObjCMethodDecl *&InstanceMethod, 4034 TypedefNameDecl *&TDNDecl, 4035 bool CfToNs, bool Diagnose) { 4036 QualType T = CfToNs ? SrcType : DestType; 4037 ObjCBridgeRelatedAttr *ObjCBAttr = ObjCBridgeRelatedAttrFromType(T, TDNDecl); 4038 if (!ObjCBAttr) 4039 return false; 4040 4041 IdentifierInfo *RCId = ObjCBAttr->getRelatedClass(); 4042 IdentifierInfo *CMId = ObjCBAttr->getClassMethod(); 4043 IdentifierInfo *IMId = ObjCBAttr->getInstanceMethod(); 4044 if (!RCId) 4045 return false; 4046 NamedDecl *Target = nullptr; 4047 // Check for an existing type with this name. 4048 LookupResult R(*this, DeclarationName(RCId), SourceLocation(), 4049 Sema::LookupOrdinaryName); 4050 if (!LookupName(R, TUScope)) { 4051 if (Diagnose) { 4052 Diag(Loc, diag::err_objc_bridged_related_invalid_class) << RCId 4053 << SrcType << DestType; 4054 Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 4055 } 4056 return false; 4057 } 4058 Target = R.getFoundDecl(); 4059 if (Target && isa<ObjCInterfaceDecl>(Target)) 4060 RelatedClass = cast<ObjCInterfaceDecl>(Target); 4061 else { 4062 if (Diagnose) { 4063 Diag(Loc, diag::err_objc_bridged_related_invalid_class_name) << RCId 4064 << SrcType << DestType; 4065 Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 4066 if (Target) 4067 Diag(Target->getBeginLoc(), diag::note_declared_at); 4068 } 4069 return false; 4070 } 4071 4072 // Check for an existing class method with the given selector name. 4073 if (CfToNs && CMId) { 4074 Selector Sel = Context.Selectors.getUnarySelector(CMId); 4075 ClassMethod = RelatedClass->lookupMethod(Sel, false); 4076 if (!ClassMethod) { 4077 if (Diagnose) { 4078 Diag(Loc, diag::err_objc_bridged_related_known_method) 4079 << SrcType << DestType << Sel << false; 4080 Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 4081 } 4082 return false; 4083 } 4084 } 4085 4086 // Check for an existing instance method with the given selector name. 4087 if (!CfToNs && IMId) { 4088 Selector Sel = Context.Selectors.getNullarySelector(IMId); 4089 InstanceMethod = RelatedClass->lookupMethod(Sel, true); 4090 if (!InstanceMethod) { 4091 if (Diagnose) { 4092 Diag(Loc, diag::err_objc_bridged_related_known_method) 4093 << SrcType << DestType << Sel << true; 4094 Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 4095 } 4096 return false; 4097 } 4098 } 4099 return true; 4100 } 4101 4102 bool 4103 Sema::CheckObjCBridgeRelatedConversions(SourceLocation Loc, 4104 QualType DestType, QualType SrcType, 4105 Expr *&SrcExpr, bool Diagnose) { 4106 ARCConversionTypeClass rhsExprACTC = classifyTypeForARCConversion(SrcType); 4107 ARCConversionTypeClass lhsExprACTC = classifyTypeForARCConversion(DestType); 4108 bool CfToNs = (rhsExprACTC == ACTC_coreFoundation && lhsExprACTC == ACTC_retainable); 4109 bool NsToCf = (rhsExprACTC == ACTC_retainable && lhsExprACTC == ACTC_coreFoundation); 4110 if (!CfToNs && !NsToCf) 4111 return false; 4112 4113 ObjCInterfaceDecl *RelatedClass; 4114 ObjCMethodDecl *ClassMethod = nullptr; 4115 ObjCMethodDecl *InstanceMethod = nullptr; 4116 TypedefNameDecl *TDNDecl = nullptr; 4117 if (!checkObjCBridgeRelatedComponents(Loc, DestType, SrcType, RelatedClass, 4118 ClassMethod, InstanceMethod, TDNDecl, 4119 CfToNs, Diagnose)) 4120 return false; 4121 4122 if (CfToNs) { 4123 // Implicit conversion from CF to ObjC object is needed. 4124 if (ClassMethod) { 4125 if (Diagnose) { 4126 std::string ExpressionString = "["; 4127 ExpressionString += RelatedClass->getNameAsString(); 4128 ExpressionString += " "; 4129 ExpressionString += ClassMethod->getSelector().getAsString(); 4130 SourceLocation SrcExprEndLoc = 4131 getLocForEndOfToken(SrcExpr->getEndLoc()); 4132 // Provide a fixit: [RelatedClass ClassMethod SrcExpr] 4133 Diag(Loc, diag::err_objc_bridged_related_known_method) 4134 << SrcType << DestType << ClassMethod->getSelector() << false 4135 << FixItHint::CreateInsertion(SrcExpr->getBeginLoc(), 4136 ExpressionString) 4137 << FixItHint::CreateInsertion(SrcExprEndLoc, "]"); 4138 Diag(RelatedClass->getBeginLoc(), diag::note_declared_at); 4139 Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 4140 4141 QualType receiverType = Context.getObjCInterfaceType(RelatedClass); 4142 // Argument. 4143 Expr *args[] = { SrcExpr }; 4144 ExprResult msg = BuildClassMessageImplicit(receiverType, false, 4145 ClassMethod->getLocation(), 4146 ClassMethod->getSelector(), ClassMethod, 4147 MultiExprArg(args, 1)); 4148 SrcExpr = msg.get(); 4149 } 4150 return true; 4151 } 4152 } 4153 else { 4154 // Implicit conversion from ObjC type to CF object is needed. 4155 if (InstanceMethod) { 4156 if (Diagnose) { 4157 std::string ExpressionString; 4158 SourceLocation SrcExprEndLoc = 4159 getLocForEndOfToken(SrcExpr->getEndLoc()); 4160 if (InstanceMethod->isPropertyAccessor()) 4161 if (const ObjCPropertyDecl *PDecl = 4162 InstanceMethod->findPropertyDecl()) { 4163 // fixit: ObjectExpr.propertyname when it is aproperty accessor. 4164 ExpressionString = "."; 4165 ExpressionString += PDecl->getNameAsString(); 4166 Diag(Loc, diag::err_objc_bridged_related_known_method) 4167 << SrcType << DestType << InstanceMethod->getSelector() << true 4168 << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString); 4169 } 4170 if (ExpressionString.empty()) { 4171 // Provide a fixit: [ObjectExpr InstanceMethod] 4172 ExpressionString = " "; 4173 ExpressionString += InstanceMethod->getSelector().getAsString(); 4174 ExpressionString += "]"; 4175 4176 Diag(Loc, diag::err_objc_bridged_related_known_method) 4177 << SrcType << DestType << InstanceMethod->getSelector() << true 4178 << FixItHint::CreateInsertion(SrcExpr->getBeginLoc(), "[") 4179 << FixItHint::CreateInsertion(SrcExprEndLoc, ExpressionString); 4180 } 4181 Diag(RelatedClass->getBeginLoc(), diag::note_declared_at); 4182 Diag(TDNDecl->getBeginLoc(), diag::note_declared_at); 4183 4184 ExprResult msg = 4185 BuildInstanceMessageImplicit(SrcExpr, SrcType, 4186 InstanceMethod->getLocation(), 4187 InstanceMethod->getSelector(), 4188 InstanceMethod, None); 4189 SrcExpr = msg.get(); 4190 } 4191 return true; 4192 } 4193 } 4194 return false; 4195 } 4196 4197 Sema::ARCConversionResult 4198 Sema::CheckObjCConversion(SourceRange castRange, QualType castType, 4199 Expr *&castExpr, CheckedConversionKind CCK, 4200 bool Diagnose, bool DiagnoseCFAudited, 4201 BinaryOperatorKind Opc) { 4202 QualType castExprType = castExpr->getType(); 4203 4204 // For the purposes of the classification, we assume reference types 4205 // will bind to temporaries. 4206 QualType effCastType = castType; 4207 if (const ReferenceType *ref = castType->getAs<ReferenceType>()) 4208 effCastType = ref->getPointeeType(); 4209 4210 ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExprType); 4211 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(effCastType); 4212 if (exprACTC == castACTC) { 4213 // Check for viability and report error if casting an rvalue to a 4214 // life-time qualifier. 4215 if (castACTC == ACTC_retainable && 4216 (CCK == CCK_CStyleCast || CCK == CCK_OtherCast) && 4217 castType != castExprType) { 4218 const Type *DT = castType.getTypePtr(); 4219 QualType QDT = castType; 4220 // We desugar some types but not others. We ignore those 4221 // that cannot happen in a cast; i.e. auto, and those which 4222 // should not be de-sugared; i.e typedef. 4223 if (const ParenType *PT = dyn_cast<ParenType>(DT)) 4224 QDT = PT->desugar(); 4225 else if (const TypeOfType *TP = dyn_cast<TypeOfType>(DT)) 4226 QDT = TP->desugar(); 4227 else if (const AttributedType *AT = dyn_cast<AttributedType>(DT)) 4228 QDT = AT->desugar(); 4229 if (QDT != castType && 4230 QDT.getObjCLifetime() != Qualifiers::OCL_None) { 4231 if (Diagnose) { 4232 SourceLocation loc = (castRange.isValid() ? castRange.getBegin() 4233 : castExpr->getExprLoc()); 4234 Diag(loc, diag::err_arc_nolifetime_behavior); 4235 } 4236 return ACR_error; 4237 } 4238 } 4239 return ACR_okay; 4240 } 4241 4242 // The life-time qualifier cast check above is all we need for ObjCWeak. 4243 // ObjCAutoRefCount has more restrictions on what is legal. 4244 if (!getLangOpts().ObjCAutoRefCount) 4245 return ACR_okay; 4246 4247 if (isAnyCLike(exprACTC) && isAnyCLike(castACTC)) return ACR_okay; 4248 4249 // Allow all of these types to be cast to integer types (but not 4250 // vice-versa). 4251 if (castACTC == ACTC_none && castType->isIntegralType(Context)) 4252 return ACR_okay; 4253 4254 // Allow casts between pointers to lifetime types (e.g., __strong id*) 4255 // and pointers to void (e.g., cv void *). Casting from void* to lifetime* 4256 // must be explicit. 4257 if (exprACTC == ACTC_indirectRetainable && castACTC == ACTC_voidPtr) 4258 return ACR_okay; 4259 if (castACTC == ACTC_indirectRetainable && exprACTC == ACTC_voidPtr && 4260 isCast(CCK)) 4261 return ACR_okay; 4262 4263 switch (ARCCastChecker(Context, exprACTC, castACTC, false).Visit(castExpr)) { 4264 // For invalid casts, fall through. 4265 case ACC_invalid: 4266 break; 4267 4268 // Do nothing for both bottom and +0. 4269 case ACC_bottom: 4270 case ACC_plusZero: 4271 return ACR_okay; 4272 4273 // If the result is +1, consume it here. 4274 case ACC_plusOne: 4275 castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(), 4276 CK_ARCConsumeObject, castExpr, 4277 nullptr, VK_RValue); 4278 Cleanup.setExprNeedsCleanups(true); 4279 return ACR_okay; 4280 } 4281 4282 // If this is a non-implicit cast from id or block type to a 4283 // CoreFoundation type, delay complaining in case the cast is used 4284 // in an acceptable context. 4285 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC) && isCast(CCK)) 4286 return ACR_unbridged; 4287 4288 // Issue a diagnostic about a missing @-sign when implicit casting a cstring 4289 // to 'NSString *', instead of falling through to report a "bridge cast" 4290 // diagnostic. 4291 if (castACTC == ACTC_retainable && exprACTC == ACTC_none && 4292 ConversionToObjCStringLiteralCheck(castType, castExpr, Diagnose)) 4293 return ACR_error; 4294 4295 // Do not issue "bridge cast" diagnostic when implicit casting 4296 // a retainable object to a CF type parameter belonging to an audited 4297 // CF API function. Let caller issue a normal type mismatched diagnostic 4298 // instead. 4299 if ((!DiagnoseCFAudited || exprACTC != ACTC_retainable || 4300 castACTC != ACTC_coreFoundation) && 4301 !(exprACTC == ACTC_voidPtr && castACTC == ACTC_retainable && 4302 (Opc == BO_NE || Opc == BO_EQ))) { 4303 if (Diagnose) 4304 diagnoseObjCARCConversion(*this, castRange, castType, castACTC, castExpr, 4305 castExpr, exprACTC, CCK); 4306 return ACR_error; 4307 } 4308 return ACR_okay; 4309 } 4310 4311 /// Given that we saw an expression with the ARCUnbridgedCastTy 4312 /// placeholder type, complain bitterly. 4313 void Sema::diagnoseARCUnbridgedCast(Expr *e) { 4314 // We expect the spurious ImplicitCastExpr to already have been stripped. 4315 assert(!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)); 4316 CastExpr *realCast = cast<CastExpr>(e->IgnoreParens()); 4317 4318 SourceRange castRange; 4319 QualType castType; 4320 CheckedConversionKind CCK; 4321 4322 if (CStyleCastExpr *cast = dyn_cast<CStyleCastExpr>(realCast)) { 4323 castRange = SourceRange(cast->getLParenLoc(), cast->getRParenLoc()); 4324 castType = cast->getTypeAsWritten(); 4325 CCK = CCK_CStyleCast; 4326 } else if (ExplicitCastExpr *cast = dyn_cast<ExplicitCastExpr>(realCast)) { 4327 castRange = cast->getTypeInfoAsWritten()->getTypeLoc().getSourceRange(); 4328 castType = cast->getTypeAsWritten(); 4329 CCK = CCK_OtherCast; 4330 } else { 4331 llvm_unreachable("Unexpected ImplicitCastExpr"); 4332 } 4333 4334 ARCConversionTypeClass castACTC = 4335 classifyTypeForARCConversion(castType.getNonReferenceType()); 4336 4337 Expr *castExpr = realCast->getSubExpr(); 4338 assert(classifyTypeForARCConversion(castExpr->getType()) == ACTC_retainable); 4339 4340 diagnoseObjCARCConversion(*this, castRange, castType, castACTC, 4341 castExpr, realCast, ACTC_retainable, CCK); 4342 } 4343 4344 /// stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast 4345 /// type, remove the placeholder cast. 4346 Expr *Sema::stripARCUnbridgedCast(Expr *e) { 4347 assert(e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)); 4348 4349 if (ParenExpr *pe = dyn_cast<ParenExpr>(e)) { 4350 Expr *sub = stripARCUnbridgedCast(pe->getSubExpr()); 4351 return new (Context) ParenExpr(pe->getLParen(), pe->getRParen(), sub); 4352 } else if (UnaryOperator *uo = dyn_cast<UnaryOperator>(e)) { 4353 assert(uo->getOpcode() == UO_Extension); 4354 Expr *sub = stripARCUnbridgedCast(uo->getSubExpr()); 4355 return new (Context) 4356 UnaryOperator(sub, UO_Extension, sub->getType(), sub->getValueKind(), 4357 sub->getObjectKind(), uo->getOperatorLoc(), false); 4358 } else if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) { 4359 assert(!gse->isResultDependent()); 4360 4361 unsigned n = gse->getNumAssocs(); 4362 SmallVector<Expr *, 4> subExprs; 4363 SmallVector<TypeSourceInfo *, 4> subTypes; 4364 subExprs.reserve(n); 4365 subTypes.reserve(n); 4366 for (const GenericSelectionExpr::Association &assoc : gse->associations()) { 4367 subTypes.push_back(assoc.getTypeSourceInfo()); 4368 Expr *sub = assoc.getAssociationExpr(); 4369 if (assoc.isSelected()) 4370 sub = stripARCUnbridgedCast(sub); 4371 subExprs.push_back(sub); 4372 } 4373 4374 return GenericSelectionExpr::Create( 4375 Context, gse->getGenericLoc(), gse->getControllingExpr(), subTypes, 4376 subExprs, gse->getDefaultLoc(), gse->getRParenLoc(), 4377 gse->containsUnexpandedParameterPack(), gse->getResultIndex()); 4378 } else { 4379 assert(isa<ImplicitCastExpr>(e) && "bad form of unbridged cast!"); 4380 return cast<ImplicitCastExpr>(e)->getSubExpr(); 4381 } 4382 } 4383 4384 bool Sema::CheckObjCARCUnavailableWeakConversion(QualType castType, 4385 QualType exprType) { 4386 QualType canCastType = 4387 Context.getCanonicalType(castType).getUnqualifiedType(); 4388 QualType canExprType = 4389 Context.getCanonicalType(exprType).getUnqualifiedType(); 4390 if (isa<ObjCObjectPointerType>(canCastType) && 4391 castType.getObjCLifetime() == Qualifiers::OCL_Weak && 4392 canExprType->isObjCObjectPointerType()) { 4393 if (const ObjCObjectPointerType *ObjT = 4394 canExprType->getAs<ObjCObjectPointerType>()) 4395 if (const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl()) 4396 return !ObjI->isArcWeakrefUnavailable(); 4397 } 4398 return true; 4399 } 4400 4401 /// Look for an ObjCReclaimReturnedObject cast and destroy it. 4402 static Expr *maybeUndoReclaimObject(Expr *e) { 4403 Expr *curExpr = e, *prevExpr = nullptr; 4404 4405 // Walk down the expression until we hit an implicit cast of kind 4406 // ARCReclaimReturnedObject or an Expr that is neither a Paren nor a Cast. 4407 while (true) { 4408 if (auto *pe = dyn_cast<ParenExpr>(curExpr)) { 4409 prevExpr = curExpr; 4410 curExpr = pe->getSubExpr(); 4411 continue; 4412 } 4413 4414 if (auto *ce = dyn_cast<CastExpr>(curExpr)) { 4415 if (auto *ice = dyn_cast<ImplicitCastExpr>(ce)) 4416 if (ice->getCastKind() == CK_ARCReclaimReturnedObject) { 4417 if (!prevExpr) 4418 return ice->getSubExpr(); 4419 if (auto *pe = dyn_cast<ParenExpr>(prevExpr)) 4420 pe->setSubExpr(ice->getSubExpr()); 4421 else 4422 cast<CastExpr>(prevExpr)->setSubExpr(ice->getSubExpr()); 4423 return e; 4424 } 4425 4426 prevExpr = curExpr; 4427 curExpr = ce->getSubExpr(); 4428 continue; 4429 } 4430 4431 // Break out of the loop if curExpr is neither a Paren nor a Cast. 4432 break; 4433 } 4434 4435 return e; 4436 } 4437 4438 ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, 4439 ObjCBridgeCastKind Kind, 4440 SourceLocation BridgeKeywordLoc, 4441 TypeSourceInfo *TSInfo, 4442 Expr *SubExpr) { 4443 ExprResult SubResult = UsualUnaryConversions(SubExpr); 4444 if (SubResult.isInvalid()) return ExprError(); 4445 SubExpr = SubResult.get(); 4446 4447 QualType T = TSInfo->getType(); 4448 QualType FromType = SubExpr->getType(); 4449 4450 CastKind CK; 4451 4452 bool MustConsume = false; 4453 if (T->isDependentType() || SubExpr->isTypeDependent()) { 4454 // Okay: we'll build a dependent expression type. 4455 CK = CK_Dependent; 4456 } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) { 4457 // Casting CF -> id 4458 CK = (T->isBlockPointerType() ? CK_AnyPointerToBlockPointerCast 4459 : CK_CPointerToObjCPointerCast); 4460 switch (Kind) { 4461 case OBC_Bridge: 4462 break; 4463 4464 case OBC_BridgeRetained: { 4465 bool br = isKnownName("CFBridgingRelease"); 4466 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind) 4467 << 2 4468 << FromType 4469 << (T->isBlockPointerType()? 1 : 0) 4470 << T 4471 << SubExpr->getSourceRange() 4472 << Kind; 4473 Diag(BridgeKeywordLoc, diag::note_arc_bridge) 4474 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge"); 4475 Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer) 4476 << FromType << br 4477 << FixItHint::CreateReplacement(BridgeKeywordLoc, 4478 br ? "CFBridgingRelease " 4479 : "__bridge_transfer "); 4480 4481 Kind = OBC_Bridge; 4482 break; 4483 } 4484 4485 case OBC_BridgeTransfer: 4486 // We must consume the Objective-C object produced by the cast. 4487 MustConsume = true; 4488 break; 4489 } 4490 } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) { 4491 // Okay: id -> CF 4492 CK = CK_BitCast; 4493 switch (Kind) { 4494 case OBC_Bridge: 4495 // Reclaiming a value that's going to be __bridge-casted to CF 4496 // is very dangerous, so we don't do it. 4497 SubExpr = maybeUndoReclaimObject(SubExpr); 4498 break; 4499 4500 case OBC_BridgeRetained: 4501 // Produce the object before casting it. 4502 SubExpr = ImplicitCastExpr::Create(Context, FromType, 4503 CK_ARCProduceObject, 4504 SubExpr, nullptr, VK_RValue); 4505 break; 4506 4507 case OBC_BridgeTransfer: { 4508 bool br = isKnownName("CFBridgingRetain"); 4509 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind) 4510 << (FromType->isBlockPointerType()? 1 : 0) 4511 << FromType 4512 << 2 4513 << T 4514 << SubExpr->getSourceRange() 4515 << Kind; 4516 4517 Diag(BridgeKeywordLoc, diag::note_arc_bridge) 4518 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge "); 4519 Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained) 4520 << T << br 4521 << FixItHint::CreateReplacement(BridgeKeywordLoc, 4522 br ? "CFBridgingRetain " : "__bridge_retained"); 4523 4524 Kind = OBC_Bridge; 4525 break; 4526 } 4527 } 4528 } else { 4529 Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible) 4530 << FromType << T << Kind 4531 << SubExpr->getSourceRange() 4532 << TSInfo->getTypeLoc().getSourceRange(); 4533 return ExprError(); 4534 } 4535 4536 Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK, 4537 BridgeKeywordLoc, 4538 TSInfo, SubExpr); 4539 4540 if (MustConsume) { 4541 Cleanup.setExprNeedsCleanups(true); 4542 Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result, 4543 nullptr, VK_RValue); 4544 } 4545 4546 return Result; 4547 } 4548 4549 ExprResult Sema::ActOnObjCBridgedCast(Scope *S, 4550 SourceLocation LParenLoc, 4551 ObjCBridgeCastKind Kind, 4552 SourceLocation BridgeKeywordLoc, 4553 ParsedType Type, 4554 SourceLocation RParenLoc, 4555 Expr *SubExpr) { 4556 TypeSourceInfo *TSInfo = nullptr; 4557 QualType T = GetTypeFromParser(Type, &TSInfo); 4558 if (Kind == OBC_Bridge) 4559 CheckTollFreeBridgeCast(T, SubExpr); 4560 if (!TSInfo) 4561 TSInfo = Context.getTrivialTypeSourceInfo(T, LParenLoc); 4562 return BuildObjCBridgedCast(LParenLoc, Kind, BridgeKeywordLoc, TSInfo, 4563 SubExpr); 4564 } 4565