1 //===--- SemaExprObjC.cpp - Semantic Analysis for ObjC Expressions --------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements semantic analysis for Objective-C expressions. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Sema/SemaInternal.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/DeclObjC.h" 17 #include "clang/AST/ExprObjC.h" 18 #include "clang/AST/StmtVisitor.h" 19 #include "clang/AST/TypeLoc.h" 20 #include "clang/Analysis/DomainSpecific/CocoaConventions.h" 21 #include "clang/Edit/Commit.h" 22 #include "clang/Edit/Rewriters.h" 23 #include "clang/Lex/Preprocessor.h" 24 #include "clang/Sema/Initialization.h" 25 #include "clang/Sema/Lookup.h" 26 #include "clang/Sema/Scope.h" 27 #include "clang/Sema/ScopeInfo.h" 28 #include "llvm/ADT/SmallString.h" 29 30 using namespace clang; 31 using namespace sema; 32 using llvm::makeArrayRef; 33 34 ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs, 35 Expr **strings, 36 unsigned NumStrings) { 37 StringLiteral **Strings = reinterpret_cast<StringLiteral**>(strings); 38 39 // Most ObjC strings are formed out of a single piece. However, we *can* 40 // have strings formed out of multiple @ strings with multiple pptokens in 41 // each one, e.g. @"foo" "bar" @"baz" "qux" which need to be turned into one 42 // StringLiteral for ObjCStringLiteral to hold onto. 43 StringLiteral *S = Strings[0]; 44 45 // If we have a multi-part string, merge it all together. 46 if (NumStrings != 1) { 47 // Concatenate objc strings. 48 SmallString<128> StrBuf; 49 SmallVector<SourceLocation, 8> StrLocs; 50 51 for (unsigned i = 0; i != NumStrings; ++i) { 52 S = Strings[i]; 53 54 // ObjC strings can't be wide or UTF. 55 if (!S->isAscii()) { 56 Diag(S->getLocStart(), diag::err_cfstring_literal_not_string_constant) 57 << S->getSourceRange(); 58 return true; 59 } 60 61 // Append the string. 62 StrBuf += S->getString(); 63 64 // Get the locations of the string tokens. 65 StrLocs.append(S->tokloc_begin(), S->tokloc_end()); 66 } 67 68 // Create the aggregate string with the appropriate content and location 69 // information. 70 S = StringLiteral::Create(Context, StrBuf, 71 StringLiteral::Ascii, /*Pascal=*/false, 72 Context.getPointerType(Context.CharTy), 73 &StrLocs[0], StrLocs.size()); 74 } 75 76 return BuildObjCStringLiteral(AtLocs[0], S); 77 } 78 79 ExprResult Sema::BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S){ 80 // Verify that this composite string is acceptable for ObjC strings. 81 if (CheckObjCString(S)) 82 return true; 83 84 // Initialize the constant string interface lazily. This assumes 85 // the NSString interface is seen in this translation unit. Note: We 86 // don't use NSConstantString, since the runtime team considers this 87 // interface private (even though it appears in the header files). 88 QualType Ty = Context.getObjCConstantStringInterface(); 89 if (!Ty.isNull()) { 90 Ty = Context.getObjCObjectPointerType(Ty); 91 } else if (getLangOpts().NoConstantCFStrings) { 92 IdentifierInfo *NSIdent=0; 93 std::string StringClass(getLangOpts().ObjCConstantStringClass); 94 95 if (StringClass.empty()) 96 NSIdent = &Context.Idents.get("NSConstantString"); 97 else 98 NSIdent = &Context.Idents.get(StringClass); 99 100 NamedDecl *IF = LookupSingleName(TUScope, NSIdent, AtLoc, 101 LookupOrdinaryName); 102 if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) { 103 Context.setObjCConstantStringInterface(StrIF); 104 Ty = Context.getObjCConstantStringInterface(); 105 Ty = Context.getObjCObjectPointerType(Ty); 106 } else { 107 // If there is no NSConstantString interface defined then treat this 108 // as error and recover from it. 109 Diag(S->getLocStart(), diag::err_no_nsconstant_string_class) << NSIdent 110 << S->getSourceRange(); 111 Ty = Context.getObjCIdType(); 112 } 113 } else { 114 IdentifierInfo *NSIdent = NSAPIObj->getNSClassId(NSAPI::ClassId_NSString); 115 NamedDecl *IF = LookupSingleName(TUScope, NSIdent, AtLoc, 116 LookupOrdinaryName); 117 if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) { 118 Context.setObjCConstantStringInterface(StrIF); 119 Ty = Context.getObjCConstantStringInterface(); 120 Ty = Context.getObjCObjectPointerType(Ty); 121 } else { 122 // If there is no NSString interface defined, implicitly declare 123 // a @class NSString; and use that instead. This is to make sure 124 // type of an NSString literal is represented correctly, instead of 125 // being an 'id' type. 126 Ty = Context.getObjCNSStringType(); 127 if (Ty.isNull()) { 128 ObjCInterfaceDecl *NSStringIDecl = 129 ObjCInterfaceDecl::Create (Context, 130 Context.getTranslationUnitDecl(), 131 SourceLocation(), NSIdent, 132 0, SourceLocation()); 133 Ty = Context.getObjCInterfaceType(NSStringIDecl); 134 Context.setObjCNSStringType(Ty); 135 } 136 Ty = Context.getObjCObjectPointerType(Ty); 137 } 138 } 139 140 return new (Context) ObjCStringLiteral(S, Ty, AtLoc); 141 } 142 143 /// \brief Emits an error if the given method does not exist, or if the return 144 /// type is not an Objective-C object. 145 static bool validateBoxingMethod(Sema &S, SourceLocation Loc, 146 const ObjCInterfaceDecl *Class, 147 Selector Sel, const ObjCMethodDecl *Method) { 148 if (!Method) { 149 // FIXME: Is there a better way to avoid quotes than using getName()? 150 S.Diag(Loc, diag::err_undeclared_boxing_method) << Sel << Class->getName(); 151 return false; 152 } 153 154 // Make sure the return type is reasonable. 155 QualType ReturnType = Method->getResultType(); 156 if (!ReturnType->isObjCObjectPointerType()) { 157 S.Diag(Loc, diag::err_objc_literal_method_sig) 158 << Sel; 159 S.Diag(Method->getLocation(), diag::note_objc_literal_method_return) 160 << ReturnType; 161 return false; 162 } 163 164 return true; 165 } 166 167 /// \brief Retrieve the NSNumber factory method that should be used to create 168 /// an Objective-C literal for the given type. 169 static ObjCMethodDecl *getNSNumberFactoryMethod(Sema &S, SourceLocation Loc, 170 QualType NumberType, 171 bool isLiteral = false, 172 SourceRange R = SourceRange()) { 173 Optional<NSAPI::NSNumberLiteralMethodKind> Kind = 174 S.NSAPIObj->getNSNumberFactoryMethodKind(NumberType); 175 176 if (!Kind) { 177 if (isLiteral) { 178 S.Diag(Loc, diag::err_invalid_nsnumber_type) 179 << NumberType << R; 180 } 181 return 0; 182 } 183 184 // If we already looked up this method, we're done. 185 if (S.NSNumberLiteralMethods[*Kind]) 186 return S.NSNumberLiteralMethods[*Kind]; 187 188 Selector Sel = S.NSAPIObj->getNSNumberLiteralSelector(*Kind, 189 /*Instance=*/false); 190 191 ASTContext &CX = S.Context; 192 193 // Look up the NSNumber class, if we haven't done so already. It's cached 194 // in the Sema instance. 195 if (!S.NSNumberDecl) { 196 IdentifierInfo *NSNumberId = 197 S.NSAPIObj->getNSClassId(NSAPI::ClassId_NSNumber); 198 NamedDecl *IF = S.LookupSingleName(S.TUScope, NSNumberId, 199 Loc, Sema::LookupOrdinaryName); 200 S.NSNumberDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF); 201 if (!S.NSNumberDecl) { 202 if (S.getLangOpts().DebuggerObjCLiteral) { 203 // Create a stub definition of NSNumber. 204 S.NSNumberDecl = ObjCInterfaceDecl::Create(CX, 205 CX.getTranslationUnitDecl(), 206 SourceLocation(), NSNumberId, 207 0, SourceLocation()); 208 } else { 209 // Otherwise, require a declaration of NSNumber. 210 S.Diag(Loc, diag::err_undeclared_nsnumber); 211 return 0; 212 } 213 } else if (!S.NSNumberDecl->hasDefinition()) { 214 S.Diag(Loc, diag::err_undeclared_nsnumber); 215 return 0; 216 } 217 218 // generate the pointer to NSNumber type. 219 QualType NSNumberObject = CX.getObjCInterfaceType(S.NSNumberDecl); 220 S.NSNumberPointer = CX.getObjCObjectPointerType(NSNumberObject); 221 } 222 223 // Look for the appropriate method within NSNumber. 224 ObjCMethodDecl *Method = S.NSNumberDecl->lookupClassMethod(Sel); 225 if (!Method && S.getLangOpts().DebuggerObjCLiteral) { 226 // create a stub definition this NSNumber factory method. 227 TypeSourceInfo *ResultTInfo = 0; 228 Method = ObjCMethodDecl::Create(CX, SourceLocation(), SourceLocation(), Sel, 229 S.NSNumberPointer, ResultTInfo, 230 S.NSNumberDecl, 231 /*isInstance=*/false, /*isVariadic=*/false, 232 /*isPropertyAccessor=*/false, 233 /*isImplicitlyDeclared=*/true, 234 /*isDefined=*/false, 235 ObjCMethodDecl::Required, 236 /*HasRelatedResultType=*/false); 237 ParmVarDecl *value = ParmVarDecl::Create(S.Context, Method, 238 SourceLocation(), SourceLocation(), 239 &CX.Idents.get("value"), 240 NumberType, /*TInfo=*/0, SC_None, 241 0); 242 Method->setMethodParams(S.Context, value, None); 243 } 244 245 if (!validateBoxingMethod(S, Loc, S.NSNumberDecl, Sel, Method)) 246 return 0; 247 248 // Note: if the parameter type is out-of-line, we'll catch it later in the 249 // implicit conversion. 250 251 S.NSNumberLiteralMethods[*Kind] = Method; 252 return Method; 253 } 254 255 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the 256 /// numeric literal expression. Type of the expression will be "NSNumber *". 257 ExprResult Sema::BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number) { 258 // Determine the type of the literal. 259 QualType NumberType = Number->getType(); 260 if (CharacterLiteral *Char = dyn_cast<CharacterLiteral>(Number)) { 261 // In C, character literals have type 'int'. That's not the type we want 262 // to use to determine the Objective-c literal kind. 263 switch (Char->getKind()) { 264 case CharacterLiteral::Ascii: 265 NumberType = Context.CharTy; 266 break; 267 268 case CharacterLiteral::Wide: 269 NumberType = Context.getWideCharType(); 270 break; 271 272 case CharacterLiteral::UTF16: 273 NumberType = Context.Char16Ty; 274 break; 275 276 case CharacterLiteral::UTF32: 277 NumberType = Context.Char32Ty; 278 break; 279 } 280 } 281 282 // Look for the appropriate method within NSNumber. 283 // Construct the literal. 284 SourceRange NR(Number->getSourceRange()); 285 ObjCMethodDecl *Method = getNSNumberFactoryMethod(*this, AtLoc, NumberType, 286 true, NR); 287 if (!Method) 288 return ExprError(); 289 290 // Convert the number to the type that the parameter expects. 291 ParmVarDecl *ParamDecl = Method->param_begin()[0]; 292 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context, 293 ParamDecl); 294 ExprResult ConvertedNumber = PerformCopyInitialization(Entity, 295 SourceLocation(), 296 Owned(Number)); 297 if (ConvertedNumber.isInvalid()) 298 return ExprError(); 299 Number = ConvertedNumber.get(); 300 301 // Use the effective source range of the literal, including the leading '@'. 302 return MaybeBindToTemporary( 303 new (Context) ObjCBoxedExpr(Number, NSNumberPointer, Method, 304 SourceRange(AtLoc, NR.getEnd()))); 305 } 306 307 ExprResult Sema::ActOnObjCBoolLiteral(SourceLocation AtLoc, 308 SourceLocation ValueLoc, 309 bool Value) { 310 ExprResult Inner; 311 if (getLangOpts().CPlusPlus) { 312 Inner = ActOnCXXBoolLiteral(ValueLoc, Value? tok::kw_true : tok::kw_false); 313 } else { 314 // C doesn't actually have a way to represent literal values of type 315 // _Bool. So, we'll use 0/1 and implicit cast to _Bool. 316 Inner = ActOnIntegerConstant(ValueLoc, Value? 1 : 0); 317 Inner = ImpCastExprToType(Inner.get(), Context.BoolTy, 318 CK_IntegralToBoolean); 319 } 320 321 return BuildObjCNumericLiteral(AtLoc, Inner.get()); 322 } 323 324 /// \brief Check that the given expression is a valid element of an Objective-C 325 /// collection literal. 326 static ExprResult CheckObjCCollectionLiteralElement(Sema &S, Expr *Element, 327 QualType T) { 328 // If the expression is type-dependent, there's nothing for us to do. 329 if (Element->isTypeDependent()) 330 return Element; 331 332 ExprResult Result = S.CheckPlaceholderExpr(Element); 333 if (Result.isInvalid()) 334 return ExprError(); 335 Element = Result.get(); 336 337 // In C++, check for an implicit conversion to an Objective-C object pointer 338 // type. 339 if (S.getLangOpts().CPlusPlus && Element->getType()->isRecordType()) { 340 InitializedEntity Entity 341 = InitializedEntity::InitializeParameter(S.Context, T, 342 /*Consumed=*/false); 343 InitializationKind Kind 344 = InitializationKind::CreateCopy(Element->getLocStart(), 345 SourceLocation()); 346 InitializationSequence Seq(S, Entity, Kind, Element); 347 if (!Seq.Failed()) 348 return Seq.Perform(S, Entity, Kind, Element); 349 } 350 351 Expr *OrigElement = Element; 352 353 // Perform lvalue-to-rvalue conversion. 354 Result = S.DefaultLvalueConversion(Element); 355 if (Result.isInvalid()) 356 return ExprError(); 357 Element = Result.get(); 358 359 // Make sure that we have an Objective-C pointer type or block. 360 if (!Element->getType()->isObjCObjectPointerType() && 361 !Element->getType()->isBlockPointerType()) { 362 bool Recovered = false; 363 364 // If this is potentially an Objective-C numeric literal, add the '@'. 365 if (isa<IntegerLiteral>(OrigElement) || 366 isa<CharacterLiteral>(OrigElement) || 367 isa<FloatingLiteral>(OrigElement) || 368 isa<ObjCBoolLiteralExpr>(OrigElement) || 369 isa<CXXBoolLiteralExpr>(OrigElement)) { 370 if (S.NSAPIObj->getNSNumberFactoryMethodKind(OrigElement->getType())) { 371 int Which = isa<CharacterLiteral>(OrigElement) ? 1 372 : (isa<CXXBoolLiteralExpr>(OrigElement) || 373 isa<ObjCBoolLiteralExpr>(OrigElement)) ? 2 374 : 3; 375 376 S.Diag(OrigElement->getLocStart(), diag::err_box_literal_collection) 377 << Which << OrigElement->getSourceRange() 378 << FixItHint::CreateInsertion(OrigElement->getLocStart(), "@"); 379 380 Result = S.BuildObjCNumericLiteral(OrigElement->getLocStart(), 381 OrigElement); 382 if (Result.isInvalid()) 383 return ExprError(); 384 385 Element = Result.get(); 386 Recovered = true; 387 } 388 } 389 // If this is potentially an Objective-C string literal, add the '@'. 390 else if (StringLiteral *String = dyn_cast<StringLiteral>(OrigElement)) { 391 if (String->isAscii()) { 392 S.Diag(OrigElement->getLocStart(), diag::err_box_literal_collection) 393 << 0 << OrigElement->getSourceRange() 394 << FixItHint::CreateInsertion(OrigElement->getLocStart(), "@"); 395 396 Result = S.BuildObjCStringLiteral(OrigElement->getLocStart(), String); 397 if (Result.isInvalid()) 398 return ExprError(); 399 400 Element = Result.get(); 401 Recovered = true; 402 } 403 } 404 405 if (!Recovered) { 406 S.Diag(Element->getLocStart(), diag::err_invalid_collection_element) 407 << Element->getType(); 408 return ExprError(); 409 } 410 } 411 412 // Make sure that the element has the type that the container factory 413 // function expects. 414 return S.PerformCopyInitialization( 415 InitializedEntity::InitializeParameter(S.Context, T, 416 /*Consumed=*/false), 417 Element->getLocStart(), Element); 418 } 419 420 ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) { 421 if (ValueExpr->isTypeDependent()) { 422 ObjCBoxedExpr *BoxedExpr = 423 new (Context) ObjCBoxedExpr(ValueExpr, Context.DependentTy, NULL, SR); 424 return Owned(BoxedExpr); 425 } 426 ObjCMethodDecl *BoxingMethod = NULL; 427 QualType BoxedType; 428 // Convert the expression to an RValue, so we can check for pointer types... 429 ExprResult RValue = DefaultFunctionArrayLvalueConversion(ValueExpr); 430 if (RValue.isInvalid()) { 431 return ExprError(); 432 } 433 ValueExpr = RValue.get(); 434 QualType ValueType(ValueExpr->getType()); 435 if (const PointerType *PT = ValueType->getAs<PointerType>()) { 436 QualType PointeeType = PT->getPointeeType(); 437 if (Context.hasSameUnqualifiedType(PointeeType, Context.CharTy)) { 438 439 if (!NSStringDecl) { 440 IdentifierInfo *NSStringId = 441 NSAPIObj->getNSClassId(NSAPI::ClassId_NSString); 442 NamedDecl *Decl = LookupSingleName(TUScope, NSStringId, 443 SR.getBegin(), LookupOrdinaryName); 444 NSStringDecl = dyn_cast_or_null<ObjCInterfaceDecl>(Decl); 445 if (!NSStringDecl) { 446 if (getLangOpts().DebuggerObjCLiteral) { 447 // Support boxed expressions in the debugger w/o NSString declaration. 448 DeclContext *TU = Context.getTranslationUnitDecl(); 449 NSStringDecl = ObjCInterfaceDecl::Create(Context, TU, 450 SourceLocation(), 451 NSStringId, 452 0, SourceLocation()); 453 } else { 454 Diag(SR.getBegin(), diag::err_undeclared_nsstring); 455 return ExprError(); 456 } 457 } else if (!NSStringDecl->hasDefinition()) { 458 Diag(SR.getBegin(), diag::err_undeclared_nsstring); 459 return ExprError(); 460 } 461 assert(NSStringDecl && "NSStringDecl should not be NULL"); 462 QualType NSStringObject = Context.getObjCInterfaceType(NSStringDecl); 463 NSStringPointer = Context.getObjCObjectPointerType(NSStringObject); 464 } 465 466 if (!StringWithUTF8StringMethod) { 467 IdentifierInfo *II = &Context.Idents.get("stringWithUTF8String"); 468 Selector stringWithUTF8String = Context.Selectors.getUnarySelector(II); 469 470 // Look for the appropriate method within NSString. 471 BoxingMethod = NSStringDecl->lookupClassMethod(stringWithUTF8String); 472 if (!BoxingMethod && getLangOpts().DebuggerObjCLiteral) { 473 // Debugger needs to work even if NSString hasn't been defined. 474 TypeSourceInfo *ResultTInfo = 0; 475 ObjCMethodDecl *M = 476 ObjCMethodDecl::Create(Context, SourceLocation(), SourceLocation(), 477 stringWithUTF8String, NSStringPointer, 478 ResultTInfo, NSStringDecl, 479 /*isInstance=*/false, /*isVariadic=*/false, 480 /*isPropertyAccessor=*/false, 481 /*isImplicitlyDeclared=*/true, 482 /*isDefined=*/false, 483 ObjCMethodDecl::Required, 484 /*HasRelatedResultType=*/false); 485 QualType ConstCharType = Context.CharTy.withConst(); 486 ParmVarDecl *value = 487 ParmVarDecl::Create(Context, M, 488 SourceLocation(), SourceLocation(), 489 &Context.Idents.get("value"), 490 Context.getPointerType(ConstCharType), 491 /*TInfo=*/0, 492 SC_None, 0); 493 M->setMethodParams(Context, value, None); 494 BoxingMethod = M; 495 } 496 497 if (!validateBoxingMethod(*this, SR.getBegin(), NSStringDecl, 498 stringWithUTF8String, BoxingMethod)) 499 return ExprError(); 500 501 StringWithUTF8StringMethod = BoxingMethod; 502 } 503 504 BoxingMethod = StringWithUTF8StringMethod; 505 BoxedType = NSStringPointer; 506 } 507 } else if (ValueType->isBuiltinType()) { 508 // The other types we support are numeric, char and BOOL/bool. We could also 509 // provide limited support for structure types, such as NSRange, NSRect, and 510 // NSSize. See NSValue (NSValueGeometryExtensions) in <Foundation/NSGeometry.h> 511 // for more details. 512 513 // Check for a top-level character literal. 514 if (const CharacterLiteral *Char = 515 dyn_cast<CharacterLiteral>(ValueExpr->IgnoreParens())) { 516 // In C, character literals have type 'int'. That's not the type we want 517 // to use to determine the Objective-c literal kind. 518 switch (Char->getKind()) { 519 case CharacterLiteral::Ascii: 520 ValueType = Context.CharTy; 521 break; 522 523 case CharacterLiteral::Wide: 524 ValueType = Context.getWideCharType(); 525 break; 526 527 case CharacterLiteral::UTF16: 528 ValueType = Context.Char16Ty; 529 break; 530 531 case CharacterLiteral::UTF32: 532 ValueType = Context.Char32Ty; 533 break; 534 } 535 } 536 537 // FIXME: Do I need to do anything special with BoolTy expressions? 538 539 // Look for the appropriate method within NSNumber. 540 BoxingMethod = getNSNumberFactoryMethod(*this, SR.getBegin(), ValueType); 541 BoxedType = NSNumberPointer; 542 543 } else if (const EnumType *ET = ValueType->getAs<EnumType>()) { 544 if (!ET->getDecl()->isComplete()) { 545 Diag(SR.getBegin(), diag::err_objc_incomplete_boxed_expression_type) 546 << ValueType << ValueExpr->getSourceRange(); 547 return ExprError(); 548 } 549 550 BoxingMethod = getNSNumberFactoryMethod(*this, SR.getBegin(), 551 ET->getDecl()->getIntegerType()); 552 BoxedType = NSNumberPointer; 553 } 554 555 if (!BoxingMethod) { 556 Diag(SR.getBegin(), diag::err_objc_illegal_boxed_expression_type) 557 << ValueType << ValueExpr->getSourceRange(); 558 return ExprError(); 559 } 560 561 // Convert the expression to the type that the parameter requires. 562 ParmVarDecl *ParamDecl = BoxingMethod->param_begin()[0]; 563 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context, 564 ParamDecl); 565 ExprResult ConvertedValueExpr = PerformCopyInitialization(Entity, 566 SourceLocation(), 567 Owned(ValueExpr)); 568 if (ConvertedValueExpr.isInvalid()) 569 return ExprError(); 570 ValueExpr = ConvertedValueExpr.get(); 571 572 ObjCBoxedExpr *BoxedExpr = 573 new (Context) ObjCBoxedExpr(ValueExpr, BoxedType, 574 BoxingMethod, SR); 575 return MaybeBindToTemporary(BoxedExpr); 576 } 577 578 /// Build an ObjC subscript pseudo-object expression, given that 579 /// that's supported by the runtime. 580 ExprResult Sema::BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr, 581 Expr *IndexExpr, 582 ObjCMethodDecl *getterMethod, 583 ObjCMethodDecl *setterMethod) { 584 assert(!LangOpts.ObjCRuntime.isSubscriptPointerArithmetic()); 585 586 // We can't get dependent types here; our callers should have 587 // filtered them out. 588 assert((!BaseExpr->isTypeDependent() && !IndexExpr->isTypeDependent()) && 589 "base or index cannot have dependent type here"); 590 591 // Filter out placeholders in the index. In theory, overloads could 592 // be preserved here, although that might not actually work correctly. 593 ExprResult Result = CheckPlaceholderExpr(IndexExpr); 594 if (Result.isInvalid()) 595 return ExprError(); 596 IndexExpr = Result.get(); 597 598 // Perform lvalue-to-rvalue conversion on the base. 599 Result = DefaultLvalueConversion(BaseExpr); 600 if (Result.isInvalid()) 601 return ExprError(); 602 BaseExpr = Result.get(); 603 604 // Build the pseudo-object expression. 605 return Owned(ObjCSubscriptRefExpr::Create(Context, 606 BaseExpr, 607 IndexExpr, 608 Context.PseudoObjectTy, 609 getterMethod, 610 setterMethod, RB)); 611 612 } 613 614 ExprResult Sema::BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements) { 615 // Look up the NSArray class, if we haven't done so already. 616 if (!NSArrayDecl) { 617 NamedDecl *IF = LookupSingleName(TUScope, 618 NSAPIObj->getNSClassId(NSAPI::ClassId_NSArray), 619 SR.getBegin(), 620 LookupOrdinaryName); 621 NSArrayDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF); 622 if (!NSArrayDecl && getLangOpts().DebuggerObjCLiteral) 623 NSArrayDecl = ObjCInterfaceDecl::Create (Context, 624 Context.getTranslationUnitDecl(), 625 SourceLocation(), 626 NSAPIObj->getNSClassId(NSAPI::ClassId_NSArray), 627 0, SourceLocation()); 628 629 if (!NSArrayDecl) { 630 Diag(SR.getBegin(), diag::err_undeclared_nsarray); 631 return ExprError(); 632 } 633 } 634 635 // Find the arrayWithObjects:count: method, if we haven't done so already. 636 QualType IdT = Context.getObjCIdType(); 637 if (!ArrayWithObjectsMethod) { 638 Selector 639 Sel = NSAPIObj->getNSArraySelector(NSAPI::NSArr_arrayWithObjectsCount); 640 ObjCMethodDecl *Method = NSArrayDecl->lookupClassMethod(Sel); 641 if (!Method && getLangOpts().DebuggerObjCLiteral) { 642 TypeSourceInfo *ResultTInfo = 0; 643 Method = ObjCMethodDecl::Create(Context, 644 SourceLocation(), SourceLocation(), Sel, 645 IdT, 646 ResultTInfo, 647 Context.getTranslationUnitDecl(), 648 false /*Instance*/, false/*isVariadic*/, 649 /*isPropertyAccessor=*/false, 650 /*isImplicitlyDeclared=*/true, /*isDefined=*/false, 651 ObjCMethodDecl::Required, 652 false); 653 SmallVector<ParmVarDecl *, 2> Params; 654 ParmVarDecl *objects = ParmVarDecl::Create(Context, Method, 655 SourceLocation(), 656 SourceLocation(), 657 &Context.Idents.get("objects"), 658 Context.getPointerType(IdT), 659 /*TInfo=*/0, SC_None, 0); 660 Params.push_back(objects); 661 ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method, 662 SourceLocation(), 663 SourceLocation(), 664 &Context.Idents.get("cnt"), 665 Context.UnsignedLongTy, 666 /*TInfo=*/0, SC_None, 0); 667 Params.push_back(cnt); 668 Method->setMethodParams(Context, Params, None); 669 } 670 671 if (!validateBoxingMethod(*this, SR.getBegin(), NSArrayDecl, Sel, Method)) 672 return ExprError(); 673 674 // Dig out the type that all elements should be converted to. 675 QualType T = Method->param_begin()[0]->getType(); 676 const PointerType *PtrT = T->getAs<PointerType>(); 677 if (!PtrT || 678 !Context.hasSameUnqualifiedType(PtrT->getPointeeType(), IdT)) { 679 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 680 << Sel; 681 Diag(Method->param_begin()[0]->getLocation(), 682 diag::note_objc_literal_method_param) 683 << 0 << T 684 << Context.getPointerType(IdT.withConst()); 685 return ExprError(); 686 } 687 688 // Check that the 'count' parameter is integral. 689 if (!Method->param_begin()[1]->getType()->isIntegerType()) { 690 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 691 << Sel; 692 Diag(Method->param_begin()[1]->getLocation(), 693 diag::note_objc_literal_method_param) 694 << 1 695 << Method->param_begin()[1]->getType() 696 << "integral"; 697 return ExprError(); 698 } 699 700 // We've found a good +arrayWithObjects:count: method. Save it! 701 ArrayWithObjectsMethod = Method; 702 } 703 704 QualType ObjectsType = ArrayWithObjectsMethod->param_begin()[0]->getType(); 705 QualType RequiredType = ObjectsType->castAs<PointerType>()->getPointeeType(); 706 707 // Check that each of the elements provided is valid in a collection literal, 708 // performing conversions as necessary. 709 Expr **ElementsBuffer = Elements.data(); 710 for (unsigned I = 0, N = Elements.size(); I != N; ++I) { 711 ExprResult Converted = CheckObjCCollectionLiteralElement(*this, 712 ElementsBuffer[I], 713 RequiredType); 714 if (Converted.isInvalid()) 715 return ExprError(); 716 717 ElementsBuffer[I] = Converted.get(); 718 } 719 720 QualType Ty 721 = Context.getObjCObjectPointerType( 722 Context.getObjCInterfaceType(NSArrayDecl)); 723 724 return MaybeBindToTemporary( 725 ObjCArrayLiteral::Create(Context, Elements, Ty, 726 ArrayWithObjectsMethod, SR)); 727 } 728 729 ExprResult Sema::BuildObjCDictionaryLiteral(SourceRange SR, 730 ObjCDictionaryElement *Elements, 731 unsigned NumElements) { 732 // Look up the NSDictionary class, if we haven't done so already. 733 if (!NSDictionaryDecl) { 734 NamedDecl *IF = LookupSingleName(TUScope, 735 NSAPIObj->getNSClassId(NSAPI::ClassId_NSDictionary), 736 SR.getBegin(), LookupOrdinaryName); 737 NSDictionaryDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF); 738 if (!NSDictionaryDecl && getLangOpts().DebuggerObjCLiteral) 739 NSDictionaryDecl = ObjCInterfaceDecl::Create (Context, 740 Context.getTranslationUnitDecl(), 741 SourceLocation(), 742 NSAPIObj->getNSClassId(NSAPI::ClassId_NSDictionary), 743 0, SourceLocation()); 744 745 if (!NSDictionaryDecl) { 746 Diag(SR.getBegin(), diag::err_undeclared_nsdictionary); 747 return ExprError(); 748 } 749 } 750 751 // Find the dictionaryWithObjects:forKeys:count: method, if we haven't done 752 // so already. 753 QualType IdT = Context.getObjCIdType(); 754 if (!DictionaryWithObjectsMethod) { 755 Selector Sel = NSAPIObj->getNSDictionarySelector( 756 NSAPI::NSDict_dictionaryWithObjectsForKeysCount); 757 ObjCMethodDecl *Method = NSDictionaryDecl->lookupClassMethod(Sel); 758 if (!Method && getLangOpts().DebuggerObjCLiteral) { 759 Method = ObjCMethodDecl::Create(Context, 760 SourceLocation(), SourceLocation(), Sel, 761 IdT, 762 0 /*TypeSourceInfo */, 763 Context.getTranslationUnitDecl(), 764 false /*Instance*/, false/*isVariadic*/, 765 /*isPropertyAccessor=*/false, 766 /*isImplicitlyDeclared=*/true, /*isDefined=*/false, 767 ObjCMethodDecl::Required, 768 false); 769 SmallVector<ParmVarDecl *, 3> Params; 770 ParmVarDecl *objects = ParmVarDecl::Create(Context, Method, 771 SourceLocation(), 772 SourceLocation(), 773 &Context.Idents.get("objects"), 774 Context.getPointerType(IdT), 775 /*TInfo=*/0, SC_None, 0); 776 Params.push_back(objects); 777 ParmVarDecl *keys = ParmVarDecl::Create(Context, Method, 778 SourceLocation(), 779 SourceLocation(), 780 &Context.Idents.get("keys"), 781 Context.getPointerType(IdT), 782 /*TInfo=*/0, SC_None, 0); 783 Params.push_back(keys); 784 ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method, 785 SourceLocation(), 786 SourceLocation(), 787 &Context.Idents.get("cnt"), 788 Context.UnsignedLongTy, 789 /*TInfo=*/0, SC_None, 0); 790 Params.push_back(cnt); 791 Method->setMethodParams(Context, Params, None); 792 } 793 794 if (!validateBoxingMethod(*this, SR.getBegin(), NSDictionaryDecl, Sel, 795 Method)) 796 return ExprError(); 797 798 // Dig out the type that all values should be converted to. 799 QualType ValueT = Method->param_begin()[0]->getType(); 800 const PointerType *PtrValue = ValueT->getAs<PointerType>(); 801 if (!PtrValue || 802 !Context.hasSameUnqualifiedType(PtrValue->getPointeeType(), IdT)) { 803 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 804 << Sel; 805 Diag(Method->param_begin()[0]->getLocation(), 806 diag::note_objc_literal_method_param) 807 << 0 << ValueT 808 << Context.getPointerType(IdT.withConst()); 809 return ExprError(); 810 } 811 812 // Dig out the type that all keys should be converted to. 813 QualType KeyT = Method->param_begin()[1]->getType(); 814 const PointerType *PtrKey = KeyT->getAs<PointerType>(); 815 if (!PtrKey || 816 !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(), 817 IdT)) { 818 bool err = true; 819 if (PtrKey) { 820 if (QIDNSCopying.isNull()) { 821 // key argument of selector is id<NSCopying>? 822 if (ObjCProtocolDecl *NSCopyingPDecl = 823 LookupProtocol(&Context.Idents.get("NSCopying"), SR.getBegin())) { 824 ObjCProtocolDecl *PQ[] = {NSCopyingPDecl}; 825 QIDNSCopying = 826 Context.getObjCObjectType(Context.ObjCBuiltinIdTy, 827 (ObjCProtocolDecl**) PQ,1); 828 QIDNSCopying = Context.getObjCObjectPointerType(QIDNSCopying); 829 } 830 } 831 if (!QIDNSCopying.isNull()) 832 err = !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(), 833 QIDNSCopying); 834 } 835 836 if (err) { 837 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 838 << Sel; 839 Diag(Method->param_begin()[1]->getLocation(), 840 diag::note_objc_literal_method_param) 841 << 1 << KeyT 842 << Context.getPointerType(IdT.withConst()); 843 return ExprError(); 844 } 845 } 846 847 // Check that the 'count' parameter is integral. 848 QualType CountType = Method->param_begin()[2]->getType(); 849 if (!CountType->isIntegerType()) { 850 Diag(SR.getBegin(), diag::err_objc_literal_method_sig) 851 << Sel; 852 Diag(Method->param_begin()[2]->getLocation(), 853 diag::note_objc_literal_method_param) 854 << 2 << CountType 855 << "integral"; 856 return ExprError(); 857 } 858 859 // We've found a good +dictionaryWithObjects:keys:count: method; save it! 860 DictionaryWithObjectsMethod = Method; 861 } 862 863 QualType ValuesT = DictionaryWithObjectsMethod->param_begin()[0]->getType(); 864 QualType ValueT = ValuesT->castAs<PointerType>()->getPointeeType(); 865 QualType KeysT = DictionaryWithObjectsMethod->param_begin()[1]->getType(); 866 QualType KeyT = KeysT->castAs<PointerType>()->getPointeeType(); 867 868 // Check that each of the keys and values provided is valid in a collection 869 // literal, performing conversions as necessary. 870 bool HasPackExpansions = false; 871 for (unsigned I = 0, N = NumElements; I != N; ++I) { 872 // Check the key. 873 ExprResult Key = CheckObjCCollectionLiteralElement(*this, Elements[I].Key, 874 KeyT); 875 if (Key.isInvalid()) 876 return ExprError(); 877 878 // Check the value. 879 ExprResult Value 880 = CheckObjCCollectionLiteralElement(*this, Elements[I].Value, ValueT); 881 if (Value.isInvalid()) 882 return ExprError(); 883 884 Elements[I].Key = Key.get(); 885 Elements[I].Value = Value.get(); 886 887 if (Elements[I].EllipsisLoc.isInvalid()) 888 continue; 889 890 if (!Elements[I].Key->containsUnexpandedParameterPack() && 891 !Elements[I].Value->containsUnexpandedParameterPack()) { 892 Diag(Elements[I].EllipsisLoc, 893 diag::err_pack_expansion_without_parameter_packs) 894 << SourceRange(Elements[I].Key->getLocStart(), 895 Elements[I].Value->getLocEnd()); 896 return ExprError(); 897 } 898 899 HasPackExpansions = true; 900 } 901 902 903 QualType Ty 904 = Context.getObjCObjectPointerType( 905 Context.getObjCInterfaceType(NSDictionaryDecl)); 906 return MaybeBindToTemporary( 907 ObjCDictionaryLiteral::Create(Context, 908 llvm::makeArrayRef(Elements, 909 NumElements), 910 HasPackExpansions, 911 Ty, 912 DictionaryWithObjectsMethod, SR)); 913 } 914 915 ExprResult Sema::BuildObjCEncodeExpression(SourceLocation AtLoc, 916 TypeSourceInfo *EncodedTypeInfo, 917 SourceLocation RParenLoc) { 918 QualType EncodedType = EncodedTypeInfo->getType(); 919 QualType StrTy; 920 if (EncodedType->isDependentType()) 921 StrTy = Context.DependentTy; 922 else { 923 if (!EncodedType->getAsArrayTypeUnsafe() && //// Incomplete array is handled. 924 !EncodedType->isVoidType()) // void is handled too. 925 if (RequireCompleteType(AtLoc, EncodedType, 926 diag::err_incomplete_type_objc_at_encode, 927 EncodedTypeInfo->getTypeLoc())) 928 return ExprError(); 929 930 std::string Str; 931 Context.getObjCEncodingForType(EncodedType, Str); 932 933 // The type of @encode is the same as the type of the corresponding string, 934 // which is an array type. 935 StrTy = Context.CharTy; 936 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 937 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings) 938 StrTy.addConst(); 939 StrTy = Context.getConstantArrayType(StrTy, llvm::APInt(32, Str.size()+1), 940 ArrayType::Normal, 0); 941 } 942 943 return new (Context) ObjCEncodeExpr(StrTy, EncodedTypeInfo, AtLoc, RParenLoc); 944 } 945 946 ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc, 947 SourceLocation EncodeLoc, 948 SourceLocation LParenLoc, 949 ParsedType ty, 950 SourceLocation RParenLoc) { 951 // FIXME: Preserve type source info ? 952 TypeSourceInfo *TInfo; 953 QualType EncodedType = GetTypeFromParser(ty, &TInfo); 954 if (!TInfo) 955 TInfo = Context.getTrivialTypeSourceInfo(EncodedType, 956 PP.getLocForEndOfToken(LParenLoc)); 957 958 return BuildObjCEncodeExpression(AtLoc, TInfo, RParenLoc); 959 } 960 961 ExprResult Sema::ParseObjCSelectorExpression(Selector Sel, 962 SourceLocation AtLoc, 963 SourceLocation SelLoc, 964 SourceLocation LParenLoc, 965 SourceLocation RParenLoc) { 966 ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(Sel, 967 SourceRange(LParenLoc, RParenLoc), false, false); 968 if (!Method) 969 Method = LookupFactoryMethodInGlobalPool(Sel, 970 SourceRange(LParenLoc, RParenLoc)); 971 if (!Method) { 972 if (const ObjCMethodDecl *OM = SelectorsForTypoCorrection(Sel)) { 973 Selector MatchedSel = OM->getSelector(); 974 SourceRange SelectorRange(LParenLoc.getLocWithOffset(1), 975 RParenLoc.getLocWithOffset(-1)); 976 Diag(SelLoc, diag::warn_undeclared_selector_with_typo) 977 << Sel << MatchedSel 978 << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString()); 979 980 } else 981 Diag(SelLoc, diag::warn_undeclared_selector) << Sel; 982 } 983 984 if (!Method || 985 Method->getImplementationControl() != ObjCMethodDecl::Optional) { 986 llvm::DenseMap<Selector, SourceLocation>::iterator Pos 987 = ReferencedSelectors.find(Sel); 988 if (Pos == ReferencedSelectors.end()) 989 ReferencedSelectors.insert(std::make_pair(Sel, AtLoc)); 990 } 991 992 // In ARC, forbid the user from using @selector for 993 // retain/release/autorelease/dealloc/retainCount. 994 if (getLangOpts().ObjCAutoRefCount) { 995 switch (Sel.getMethodFamily()) { 996 case OMF_retain: 997 case OMF_release: 998 case OMF_autorelease: 999 case OMF_retainCount: 1000 case OMF_dealloc: 1001 Diag(AtLoc, diag::err_arc_illegal_selector) << 1002 Sel << SourceRange(LParenLoc, RParenLoc); 1003 break; 1004 1005 case OMF_None: 1006 case OMF_alloc: 1007 case OMF_copy: 1008 case OMF_finalize: 1009 case OMF_init: 1010 case OMF_mutableCopy: 1011 case OMF_new: 1012 case OMF_self: 1013 case OMF_performSelector: 1014 break; 1015 } 1016 } 1017 QualType Ty = Context.getObjCSelType(); 1018 return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc); 1019 } 1020 1021 ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId, 1022 SourceLocation AtLoc, 1023 SourceLocation ProtoLoc, 1024 SourceLocation LParenLoc, 1025 SourceLocation ProtoIdLoc, 1026 SourceLocation RParenLoc) { 1027 ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId, ProtoIdLoc); 1028 if (!PDecl) { 1029 Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId; 1030 return true; 1031 } 1032 1033 QualType Ty = Context.getObjCProtoType(); 1034 if (Ty.isNull()) 1035 return true; 1036 Ty = Context.getObjCObjectPointerType(Ty); 1037 return new (Context) ObjCProtocolExpr(Ty, PDecl, AtLoc, ProtoIdLoc, RParenLoc); 1038 } 1039 1040 /// Try to capture an implicit reference to 'self'. 1041 ObjCMethodDecl *Sema::tryCaptureObjCSelf(SourceLocation Loc) { 1042 DeclContext *DC = getFunctionLevelDeclContext(); 1043 1044 // If we're not in an ObjC method, error out. Note that, unlike the 1045 // C++ case, we don't require an instance method --- class methods 1046 // still have a 'self', and we really do still need to capture it! 1047 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(DC); 1048 if (!method) 1049 return 0; 1050 1051 tryCaptureVariable(method->getSelfDecl(), Loc); 1052 1053 return method; 1054 } 1055 1056 static QualType stripObjCInstanceType(ASTContext &Context, QualType T) { 1057 if (T == Context.getObjCInstanceType()) 1058 return Context.getObjCIdType(); 1059 1060 return T; 1061 } 1062 1063 QualType Sema::getMessageSendResultType(QualType ReceiverType, 1064 ObjCMethodDecl *Method, 1065 bool isClassMessage, bool isSuperMessage) { 1066 assert(Method && "Must have a method"); 1067 if (!Method->hasRelatedResultType()) 1068 return Method->getSendResultType(); 1069 1070 // If a method has a related return type: 1071 // - if the method found is an instance method, but the message send 1072 // was a class message send, T is the declared return type of the method 1073 // found 1074 if (Method->isInstanceMethod() && isClassMessage) 1075 return stripObjCInstanceType(Context, Method->getSendResultType()); 1076 1077 // - if the receiver is super, T is a pointer to the class of the 1078 // enclosing method definition 1079 if (isSuperMessage) { 1080 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) 1081 if (ObjCInterfaceDecl *Class = CurMethod->getClassInterface()) 1082 return Context.getObjCObjectPointerType( 1083 Context.getObjCInterfaceType(Class)); 1084 } 1085 1086 // - if the receiver is the name of a class U, T is a pointer to U 1087 if (ReceiverType->getAs<ObjCInterfaceType>() || 1088 ReceiverType->isObjCQualifiedInterfaceType()) 1089 return Context.getObjCObjectPointerType(ReceiverType); 1090 // - if the receiver is of type Class or qualified Class type, 1091 // T is the declared return type of the method. 1092 if (ReceiverType->isObjCClassType() || 1093 ReceiverType->isObjCQualifiedClassType()) 1094 return stripObjCInstanceType(Context, Method->getSendResultType()); 1095 1096 // - if the receiver is id, qualified id, Class, or qualified Class, T 1097 // is the receiver type, otherwise 1098 // - T is the type of the receiver expression. 1099 return ReceiverType; 1100 } 1101 1102 /// Look for an ObjC method whose result type exactly matches the given type. 1103 static const ObjCMethodDecl * 1104 findExplicitInstancetypeDeclarer(const ObjCMethodDecl *MD, 1105 QualType instancetype) { 1106 if (MD->getResultType() == instancetype) return MD; 1107 1108 // For these purposes, a method in an @implementation overrides a 1109 // declaration in the @interface. 1110 if (const ObjCImplDecl *impl = 1111 dyn_cast<ObjCImplDecl>(MD->getDeclContext())) { 1112 const ObjCContainerDecl *iface; 1113 if (const ObjCCategoryImplDecl *catImpl = 1114 dyn_cast<ObjCCategoryImplDecl>(impl)) { 1115 iface = catImpl->getCategoryDecl(); 1116 } else { 1117 iface = impl->getClassInterface(); 1118 } 1119 1120 const ObjCMethodDecl *ifaceMD = 1121 iface->getMethod(MD->getSelector(), MD->isInstanceMethod()); 1122 if (ifaceMD) return findExplicitInstancetypeDeclarer(ifaceMD, instancetype); 1123 } 1124 1125 SmallVector<const ObjCMethodDecl *, 4> overrides; 1126 MD->getOverriddenMethods(overrides); 1127 for (unsigned i = 0, e = overrides.size(); i != e; ++i) { 1128 if (const ObjCMethodDecl *result = 1129 findExplicitInstancetypeDeclarer(overrides[i], instancetype)) 1130 return result; 1131 } 1132 1133 return 0; 1134 } 1135 1136 void Sema::EmitRelatedResultTypeNoteForReturn(QualType destType) { 1137 // Only complain if we're in an ObjC method and the required return 1138 // type doesn't match the method's declared return type. 1139 ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurContext); 1140 if (!MD || !MD->hasRelatedResultType() || 1141 Context.hasSameUnqualifiedType(destType, MD->getResultType())) 1142 return; 1143 1144 // Look for a method overridden by this method which explicitly uses 1145 // 'instancetype'. 1146 if (const ObjCMethodDecl *overridden = 1147 findExplicitInstancetypeDeclarer(MD, Context.getObjCInstanceType())) { 1148 SourceLocation loc; 1149 SourceRange range; 1150 if (TypeSourceInfo *TSI = overridden->getResultTypeSourceInfo()) { 1151 range = TSI->getTypeLoc().getSourceRange(); 1152 loc = range.getBegin(); 1153 } 1154 if (loc.isInvalid()) 1155 loc = overridden->getLocation(); 1156 Diag(loc, diag::note_related_result_type_explicit) 1157 << /*current method*/ 1 << range; 1158 return; 1159 } 1160 1161 // Otherwise, if we have an interesting method family, note that. 1162 // This should always trigger if the above didn't. 1163 if (ObjCMethodFamily family = MD->getMethodFamily()) 1164 Diag(MD->getLocation(), diag::note_related_result_type_family) 1165 << /*current method*/ 1 1166 << family; 1167 } 1168 1169 void Sema::EmitRelatedResultTypeNote(const Expr *E) { 1170 E = E->IgnoreParenImpCasts(); 1171 const ObjCMessageExpr *MsgSend = dyn_cast<ObjCMessageExpr>(E); 1172 if (!MsgSend) 1173 return; 1174 1175 const ObjCMethodDecl *Method = MsgSend->getMethodDecl(); 1176 if (!Method) 1177 return; 1178 1179 if (!Method->hasRelatedResultType()) 1180 return; 1181 1182 if (Context.hasSameUnqualifiedType(Method->getResultType() 1183 .getNonReferenceType(), 1184 MsgSend->getType())) 1185 return; 1186 1187 if (!Context.hasSameUnqualifiedType(Method->getResultType(), 1188 Context.getObjCInstanceType())) 1189 return; 1190 1191 Diag(Method->getLocation(), diag::note_related_result_type_inferred) 1192 << Method->isInstanceMethod() << Method->getSelector() 1193 << MsgSend->getType(); 1194 } 1195 1196 bool Sema::CheckMessageArgumentTypes(QualType ReceiverType, 1197 MultiExprArg Args, 1198 Selector Sel, 1199 ArrayRef<SourceLocation> SelectorLocs, 1200 ObjCMethodDecl *Method, 1201 bool isClassMessage, bool isSuperMessage, 1202 SourceLocation lbrac, SourceLocation rbrac, 1203 QualType &ReturnType, ExprValueKind &VK) { 1204 SourceLocation SelLoc; 1205 if (!SelectorLocs.empty() && SelectorLocs.front().isValid()) 1206 SelLoc = SelectorLocs.front(); 1207 else 1208 SelLoc = lbrac; 1209 1210 if (!Method) { 1211 // Apply default argument promotion as for (C99 6.5.2.2p6). 1212 for (unsigned i = 0, e = Args.size(); i != e; i++) { 1213 if (Args[i]->isTypeDependent()) 1214 continue; 1215 1216 ExprResult result; 1217 if (getLangOpts().DebuggerSupport) { 1218 QualType paramTy; // ignored 1219 result = checkUnknownAnyArg(SelLoc, Args[i], paramTy); 1220 } else { 1221 result = DefaultArgumentPromotion(Args[i]); 1222 } 1223 if (result.isInvalid()) 1224 return true; 1225 Args[i] = result.take(); 1226 } 1227 1228 unsigned DiagID; 1229 if (getLangOpts().ObjCAutoRefCount) 1230 DiagID = diag::err_arc_method_not_found; 1231 else 1232 DiagID = isClassMessage ? diag::warn_class_method_not_found 1233 : diag::warn_inst_method_not_found; 1234 if (!getLangOpts().DebuggerSupport) { 1235 const ObjCMethodDecl *OMD = SelectorsForTypoCorrection(Sel, ReceiverType); 1236 if (OMD && !OMD->isInvalidDecl()) { 1237 if (getLangOpts().ObjCAutoRefCount) 1238 DiagID = diag::error_method_not_found_with_typo; 1239 else 1240 DiagID = isClassMessage ? diag::warn_class_method_not_found_with_typo 1241 : diag::warn_instance_method_not_found_with_typo; 1242 Selector MatchedSel = OMD->getSelector(); 1243 SourceRange SelectorRange(SelectorLocs.front(), SelectorLocs.back()); 1244 Diag(SelLoc, DiagID) 1245 << Sel<< isClassMessage << MatchedSel 1246 << FixItHint::CreateReplacement(SelectorRange, MatchedSel.getAsString()); 1247 } 1248 else 1249 Diag(SelLoc, DiagID) 1250 << Sel << isClassMessage << SourceRange(SelectorLocs.front(), 1251 SelectorLocs.back()); 1252 // Find the class to which we are sending this message. 1253 if (ReceiverType->isObjCObjectPointerType()) { 1254 if (ObjCInterfaceDecl *Class = 1255 ReceiverType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()) 1256 Diag(Class->getLocation(), diag::note_receiver_class_declared); 1257 } 1258 } 1259 1260 // In debuggers, we want to use __unknown_anytype for these 1261 // results so that clients can cast them. 1262 if (getLangOpts().DebuggerSupport) { 1263 ReturnType = Context.UnknownAnyTy; 1264 } else { 1265 ReturnType = Context.getObjCIdType(); 1266 } 1267 VK = VK_RValue; 1268 return false; 1269 } 1270 1271 ReturnType = getMessageSendResultType(ReceiverType, Method, isClassMessage, 1272 isSuperMessage); 1273 VK = Expr::getValueKindForType(Method->getResultType()); 1274 1275 unsigned NumNamedArgs = Sel.getNumArgs(); 1276 // Method might have more arguments than selector indicates. This is due 1277 // to addition of c-style arguments in method. 1278 if (Method->param_size() > Sel.getNumArgs()) 1279 NumNamedArgs = Method->param_size(); 1280 // FIXME. This need be cleaned up. 1281 if (Args.size() < NumNamedArgs) { 1282 Diag(SelLoc, diag::err_typecheck_call_too_few_args) 1283 << 2 << NumNamedArgs << static_cast<unsigned>(Args.size()); 1284 return false; 1285 } 1286 1287 bool IsError = false; 1288 for (unsigned i = 0; i < NumNamedArgs; i++) { 1289 // We can't do any type-checking on a type-dependent argument. 1290 if (Args[i]->isTypeDependent()) 1291 continue; 1292 1293 Expr *argExpr = Args[i]; 1294 1295 ParmVarDecl *param = Method->param_begin()[i]; 1296 assert(argExpr && "CheckMessageArgumentTypes(): missing expression"); 1297 1298 // Strip the unbridged-cast placeholder expression off unless it's 1299 // a consumed argument. 1300 if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) && 1301 !param->hasAttr<CFConsumedAttr>()) 1302 argExpr = stripARCUnbridgedCast(argExpr); 1303 1304 // If the parameter is __unknown_anytype, infer its type 1305 // from the argument. 1306 if (param->getType() == Context.UnknownAnyTy) { 1307 QualType paramType; 1308 ExprResult argE = checkUnknownAnyArg(SelLoc, argExpr, paramType); 1309 if (argE.isInvalid()) { 1310 IsError = true; 1311 } else { 1312 Args[i] = argE.take(); 1313 1314 // Update the parameter type in-place. 1315 param->setType(paramType); 1316 } 1317 continue; 1318 } 1319 1320 if (RequireCompleteType(argExpr->getSourceRange().getBegin(), 1321 param->getType(), 1322 diag::err_call_incomplete_argument, argExpr)) 1323 return true; 1324 1325 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context, 1326 param); 1327 ExprResult ArgE = PerformCopyInitialization(Entity, SelLoc, Owned(argExpr)); 1328 if (ArgE.isInvalid()) 1329 IsError = true; 1330 else 1331 Args[i] = ArgE.takeAs<Expr>(); 1332 } 1333 1334 // Promote additional arguments to variadic methods. 1335 if (Method->isVariadic()) { 1336 for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) { 1337 if (Args[i]->isTypeDependent()) 1338 continue; 1339 1340 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod, 1341 0); 1342 IsError |= Arg.isInvalid(); 1343 Args[i] = Arg.take(); 1344 } 1345 } else { 1346 // Check for extra arguments to non-variadic methods. 1347 if (Args.size() != NumNamedArgs) { 1348 Diag(Args[NumNamedArgs]->getLocStart(), 1349 diag::err_typecheck_call_too_many_args) 1350 << 2 /*method*/ << NumNamedArgs << static_cast<unsigned>(Args.size()) 1351 << Method->getSourceRange() 1352 << SourceRange(Args[NumNamedArgs]->getLocStart(), 1353 Args.back()->getLocEnd()); 1354 } 1355 } 1356 1357 DiagnoseSentinelCalls(Method, SelLoc, Args); 1358 1359 // Do additional checkings on method. 1360 IsError |= CheckObjCMethodCall( 1361 Method, SelLoc, 1362 llvm::makeArrayRef<const Expr *>(Args.data(), Args.size())); 1363 1364 return IsError; 1365 } 1366 1367 bool Sema::isSelfExpr(Expr *receiver) { 1368 // 'self' is objc 'self' in an objc method only. 1369 ObjCMethodDecl *method = 1370 dyn_cast_or_null<ObjCMethodDecl>(CurContext->getNonClosureAncestor()); 1371 if (!method) return false; 1372 1373 receiver = receiver->IgnoreParenLValueCasts(); 1374 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(receiver)) 1375 if (DRE->getDecl() == method->getSelfDecl()) 1376 return true; 1377 return false; 1378 } 1379 1380 /// LookupMethodInType - Look up a method in an ObjCObjectType. 1381 ObjCMethodDecl *Sema::LookupMethodInObjectType(Selector sel, QualType type, 1382 bool isInstance) { 1383 const ObjCObjectType *objType = type->castAs<ObjCObjectType>(); 1384 if (ObjCInterfaceDecl *iface = objType->getInterface()) { 1385 // Look it up in the main interface (and categories, etc.) 1386 if (ObjCMethodDecl *method = iface->lookupMethod(sel, isInstance)) 1387 return method; 1388 1389 // Okay, look for "private" methods declared in any 1390 // @implementations we've seen. 1391 if (ObjCMethodDecl *method = iface->lookupPrivateMethod(sel, isInstance)) 1392 return method; 1393 } 1394 1395 // Check qualifiers. 1396 for (ObjCObjectType::qual_iterator 1397 i = objType->qual_begin(), e = objType->qual_end(); i != e; ++i) 1398 if (ObjCMethodDecl *method = (*i)->lookupMethod(sel, isInstance)) 1399 return method; 1400 1401 return 0; 1402 } 1403 1404 /// LookupMethodInQualifiedType - Lookups up a method in protocol qualifier 1405 /// list of a qualified objective pointer type. 1406 ObjCMethodDecl *Sema::LookupMethodInQualifiedType(Selector Sel, 1407 const ObjCObjectPointerType *OPT, 1408 bool Instance) 1409 { 1410 ObjCMethodDecl *MD = 0; 1411 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 1412 E = OPT->qual_end(); I != E; ++I) { 1413 ObjCProtocolDecl *PROTO = (*I); 1414 if ((MD = PROTO->lookupMethod(Sel, Instance))) { 1415 return MD; 1416 } 1417 } 1418 return 0; 1419 } 1420 1421 static void DiagnoseARCUseOfWeakReceiver(Sema &S, Expr *Receiver) { 1422 if (!Receiver) 1423 return; 1424 1425 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Receiver)) 1426 Receiver = OVE->getSourceExpr(); 1427 1428 Expr *RExpr = Receiver->IgnoreParenImpCasts(); 1429 SourceLocation Loc = RExpr->getLocStart(); 1430 QualType T = RExpr->getType(); 1431 const ObjCPropertyDecl *PDecl = 0; 1432 const ObjCMethodDecl *GDecl = 0; 1433 if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(RExpr)) { 1434 RExpr = POE->getSyntacticForm(); 1435 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(RExpr)) { 1436 if (PRE->isImplicitProperty()) { 1437 GDecl = PRE->getImplicitPropertyGetter(); 1438 if (GDecl) { 1439 T = GDecl->getResultType(); 1440 } 1441 } 1442 else { 1443 PDecl = PRE->getExplicitProperty(); 1444 if (PDecl) { 1445 T = PDecl->getType(); 1446 } 1447 } 1448 } 1449 } 1450 else if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(RExpr)) { 1451 // See if receiver is a method which envokes a synthesized getter 1452 // backing a 'weak' property. 1453 ObjCMethodDecl *Method = ME->getMethodDecl(); 1454 if (Method && Method->getSelector().getNumArgs() == 0) { 1455 PDecl = Method->findPropertyDecl(); 1456 if (PDecl) 1457 T = PDecl->getType(); 1458 } 1459 } 1460 1461 if (T.getObjCLifetime() != Qualifiers::OCL_Weak) { 1462 if (!PDecl) 1463 return; 1464 if (!(PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak)) 1465 return; 1466 } 1467 1468 S.Diag(Loc, diag::warn_receiver_is_weak) 1469 << ((!PDecl && !GDecl) ? 0 : (PDecl ? 1 : 2)); 1470 1471 if (PDecl) 1472 S.Diag(PDecl->getLocation(), diag::note_property_declare); 1473 else if (GDecl) 1474 S.Diag(GDecl->getLocation(), diag::note_method_declared_at) << GDecl; 1475 1476 S.Diag(Loc, diag::note_arc_assign_to_strong); 1477 } 1478 1479 /// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an 1480 /// objective C interface. This is a property reference expression. 1481 ExprResult Sema:: 1482 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, 1483 Expr *BaseExpr, SourceLocation OpLoc, 1484 DeclarationName MemberName, 1485 SourceLocation MemberLoc, 1486 SourceLocation SuperLoc, QualType SuperType, 1487 bool Super) { 1488 const ObjCInterfaceType *IFaceT = OPT->getInterfaceType(); 1489 ObjCInterfaceDecl *IFace = IFaceT->getDecl(); 1490 1491 if (!MemberName.isIdentifier()) { 1492 Diag(MemberLoc, diag::err_invalid_property_name) 1493 << MemberName << QualType(OPT, 0); 1494 return ExprError(); 1495 } 1496 1497 IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); 1498 1499 SourceRange BaseRange = Super? SourceRange(SuperLoc) 1500 : BaseExpr->getSourceRange(); 1501 if (RequireCompleteType(MemberLoc, OPT->getPointeeType(), 1502 diag::err_property_not_found_forward_class, 1503 MemberName, BaseRange)) 1504 return ExprError(); 1505 1506 // Search for a declared property first. 1507 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(Member)) { 1508 // Check whether we can reference this property. 1509 if (DiagnoseUseOfDecl(PD, MemberLoc)) 1510 return ExprError(); 1511 if (Super) 1512 return Owned(new (Context) ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, 1513 VK_LValue, OK_ObjCProperty, 1514 MemberLoc, 1515 SuperLoc, SuperType)); 1516 else 1517 return Owned(new (Context) ObjCPropertyRefExpr(PD, Context.PseudoObjectTy, 1518 VK_LValue, OK_ObjCProperty, 1519 MemberLoc, BaseExpr)); 1520 } 1521 // Check protocols on qualified interfaces. 1522 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 1523 E = OPT->qual_end(); I != E; ++I) 1524 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Member)) { 1525 // Check whether we can reference this property. 1526 if (DiagnoseUseOfDecl(PD, MemberLoc)) 1527 return ExprError(); 1528 1529 if (Super) 1530 return Owned(new (Context) ObjCPropertyRefExpr(PD, 1531 Context.PseudoObjectTy, 1532 VK_LValue, 1533 OK_ObjCProperty, 1534 MemberLoc, 1535 SuperLoc, SuperType)); 1536 else 1537 return Owned(new (Context) ObjCPropertyRefExpr(PD, 1538 Context.PseudoObjectTy, 1539 VK_LValue, 1540 OK_ObjCProperty, 1541 MemberLoc, 1542 BaseExpr)); 1543 } 1544 // If that failed, look for an "implicit" property by seeing if the nullary 1545 // selector is implemented. 1546 1547 // FIXME: The logic for looking up nullary and unary selectors should be 1548 // shared with the code in ActOnInstanceMessage. 1549 1550 Selector Sel = PP.getSelectorTable().getNullarySelector(Member); 1551 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel); 1552 1553 // May be founf in property's qualified list. 1554 if (!Getter) 1555 Getter = LookupMethodInQualifiedType(Sel, OPT, true); 1556 1557 // If this reference is in an @implementation, check for 'private' methods. 1558 if (!Getter) 1559 Getter = IFace->lookupPrivateMethod(Sel); 1560 1561 if (Getter) { 1562 // Check if we can reference this property. 1563 if (DiagnoseUseOfDecl(Getter, MemberLoc)) 1564 return ExprError(); 1565 } 1566 // If we found a getter then this may be a valid dot-reference, we 1567 // will look for the matching setter, in case it is needed. 1568 Selector SetterSel = 1569 SelectorTable::constructSetterSelector(PP.getIdentifierTable(), 1570 PP.getSelectorTable(), Member); 1571 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel); 1572 1573 // May be founf in property's qualified list. 1574 if (!Setter) 1575 Setter = LookupMethodInQualifiedType(SetterSel, OPT, true); 1576 1577 if (!Setter) { 1578 // If this reference is in an @implementation, also check for 'private' 1579 // methods. 1580 Setter = IFace->lookupPrivateMethod(SetterSel); 1581 } 1582 1583 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc)) 1584 return ExprError(); 1585 1586 if (Getter || Setter) { 1587 if (Super) 1588 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter, 1589 Context.PseudoObjectTy, 1590 VK_LValue, OK_ObjCProperty, 1591 MemberLoc, 1592 SuperLoc, SuperType)); 1593 else 1594 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter, 1595 Context.PseudoObjectTy, 1596 VK_LValue, OK_ObjCProperty, 1597 MemberLoc, BaseExpr)); 1598 1599 } 1600 1601 // Attempt to correct for typos in property names. 1602 DeclFilterCCC<ObjCPropertyDecl> Validator; 1603 if (TypoCorrection Corrected = CorrectTypo( 1604 DeclarationNameInfo(MemberName, MemberLoc), LookupOrdinaryName, NULL, 1605 NULL, Validator, IFace, false, OPT)) { 1606 ObjCPropertyDecl *Property = 1607 Corrected.getCorrectionDeclAs<ObjCPropertyDecl>(); 1608 DeclarationName TypoResult = Corrected.getCorrection(); 1609 Diag(MemberLoc, diag::err_property_not_found_suggest) 1610 << MemberName << QualType(OPT, 0) << TypoResult 1611 << FixItHint::CreateReplacement(MemberLoc, TypoResult.getAsString()); 1612 Diag(Property->getLocation(), diag::note_previous_decl) 1613 << Property->getDeclName(); 1614 return HandleExprPropertyRefExpr(OPT, BaseExpr, OpLoc, 1615 TypoResult, MemberLoc, 1616 SuperLoc, SuperType, Super); 1617 } 1618 ObjCInterfaceDecl *ClassDeclared; 1619 if (ObjCIvarDecl *Ivar = 1620 IFace->lookupInstanceVariable(Member, ClassDeclared)) { 1621 QualType T = Ivar->getType(); 1622 if (const ObjCObjectPointerType * OBJPT = 1623 T->getAsObjCInterfacePointerType()) { 1624 if (RequireCompleteType(MemberLoc, OBJPT->getPointeeType(), 1625 diag::err_property_not_as_forward_class, 1626 MemberName, BaseExpr)) 1627 return ExprError(); 1628 } 1629 Diag(MemberLoc, 1630 diag::err_ivar_access_using_property_syntax_suggest) 1631 << MemberName << QualType(OPT, 0) << Ivar->getDeclName() 1632 << FixItHint::CreateReplacement(OpLoc, "->"); 1633 return ExprError(); 1634 } 1635 1636 Diag(MemberLoc, diag::err_property_not_found) 1637 << MemberName << QualType(OPT, 0); 1638 if (Setter) 1639 Diag(Setter->getLocation(), diag::note_getter_unavailable) 1640 << MemberName << BaseExpr->getSourceRange(); 1641 return ExprError(); 1642 } 1643 1644 1645 1646 ExprResult Sema:: 1647 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName, 1648 IdentifierInfo &propertyName, 1649 SourceLocation receiverNameLoc, 1650 SourceLocation propertyNameLoc) { 1651 1652 IdentifierInfo *receiverNamePtr = &receiverName; 1653 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(receiverNamePtr, 1654 receiverNameLoc); 1655 1656 bool IsSuper = false; 1657 if (IFace == 0) { 1658 // If the "receiver" is 'super' in a method, handle it as an expression-like 1659 // property reference. 1660 if (receiverNamePtr->isStr("super")) { 1661 IsSuper = true; 1662 1663 if (ObjCMethodDecl *CurMethod = tryCaptureObjCSelf(receiverNameLoc)) { 1664 if (CurMethod->isInstanceMethod()) { 1665 ObjCInterfaceDecl *Super = 1666 CurMethod->getClassInterface()->getSuperClass(); 1667 if (!Super) { 1668 // The current class does not have a superclass. 1669 Diag(receiverNameLoc, diag::error_root_class_cannot_use_super) 1670 << CurMethod->getClassInterface()->getIdentifier(); 1671 return ExprError(); 1672 } 1673 QualType T = Context.getObjCInterfaceType(Super); 1674 T = Context.getObjCObjectPointerType(T); 1675 1676 return HandleExprPropertyRefExpr(T->getAsObjCInterfacePointerType(), 1677 /*BaseExpr*/0, 1678 SourceLocation()/*OpLoc*/, 1679 &propertyName, 1680 propertyNameLoc, 1681 receiverNameLoc, T, true); 1682 } 1683 1684 // Otherwise, if this is a class method, try dispatching to our 1685 // superclass. 1686 IFace = CurMethod->getClassInterface()->getSuperClass(); 1687 } 1688 } 1689 1690 if (IFace == 0) { 1691 Diag(receiverNameLoc, diag::err_expected_ident_or_lparen); 1692 return ExprError(); 1693 } 1694 } 1695 1696 // Search for a declared property first. 1697 Selector Sel = PP.getSelectorTable().getNullarySelector(&propertyName); 1698 ObjCMethodDecl *Getter = IFace->lookupClassMethod(Sel); 1699 1700 // If this reference is in an @implementation, check for 'private' methods. 1701 if (!Getter) 1702 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) 1703 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) 1704 if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation()) 1705 Getter = ImpDecl->getClassMethod(Sel); 1706 1707 if (Getter) { 1708 // FIXME: refactor/share with ActOnMemberReference(). 1709 // Check if we can reference this property. 1710 if (DiagnoseUseOfDecl(Getter, propertyNameLoc)) 1711 return ExprError(); 1712 } 1713 1714 // Look for the matching setter, in case it is needed. 1715 Selector SetterSel = 1716 SelectorTable::constructSetterSelector(PP.getIdentifierTable(), 1717 PP.getSelectorTable(), 1718 &propertyName); 1719 1720 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel); 1721 if (!Setter) { 1722 // If this reference is in an @implementation, also check for 'private' 1723 // methods. 1724 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) 1725 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) 1726 if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation()) 1727 Setter = ImpDecl->getClassMethod(SetterSel); 1728 } 1729 // Look through local category implementations associated with the class. 1730 if (!Setter) 1731 Setter = IFace->getCategoryClassMethod(SetterSel); 1732 1733 if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc)) 1734 return ExprError(); 1735 1736 if (Getter || Setter) { 1737 if (IsSuper) 1738 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter, 1739 Context.PseudoObjectTy, 1740 VK_LValue, OK_ObjCProperty, 1741 propertyNameLoc, 1742 receiverNameLoc, 1743 Context.getObjCInterfaceType(IFace))); 1744 1745 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter, 1746 Context.PseudoObjectTy, 1747 VK_LValue, OK_ObjCProperty, 1748 propertyNameLoc, 1749 receiverNameLoc, IFace)); 1750 } 1751 return ExprError(Diag(propertyNameLoc, diag::err_property_not_found) 1752 << &propertyName << Context.getObjCInterfaceType(IFace)); 1753 } 1754 1755 namespace { 1756 1757 class ObjCInterfaceOrSuperCCC : public CorrectionCandidateCallback { 1758 public: 1759 ObjCInterfaceOrSuperCCC(ObjCMethodDecl *Method) { 1760 // Determine whether "super" is acceptable in the current context. 1761 if (Method && Method->getClassInterface()) 1762 WantObjCSuper = Method->getClassInterface()->getSuperClass(); 1763 } 1764 1765 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 1766 return candidate.getCorrectionDeclAs<ObjCInterfaceDecl>() || 1767 candidate.isKeyword("super"); 1768 } 1769 }; 1770 1771 } 1772 1773 Sema::ObjCMessageKind Sema::getObjCMessageKind(Scope *S, 1774 IdentifierInfo *Name, 1775 SourceLocation NameLoc, 1776 bool IsSuper, 1777 bool HasTrailingDot, 1778 ParsedType &ReceiverType) { 1779 ReceiverType = ParsedType(); 1780 1781 // If the identifier is "super" and there is no trailing dot, we're 1782 // messaging super. If the identifier is "super" and there is a 1783 // trailing dot, it's an instance message. 1784 if (IsSuper && S->isInObjcMethodScope()) 1785 return HasTrailingDot? ObjCInstanceMessage : ObjCSuperMessage; 1786 1787 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName); 1788 LookupName(Result, S); 1789 1790 switch (Result.getResultKind()) { 1791 case LookupResult::NotFound: 1792 // Normal name lookup didn't find anything. If we're in an 1793 // Objective-C method, look for ivars. If we find one, we're done! 1794 // FIXME: This is a hack. Ivar lookup should be part of normal 1795 // lookup. 1796 if (ObjCMethodDecl *Method = getCurMethodDecl()) { 1797 if (!Method->getClassInterface()) { 1798 // Fall back: let the parser try to parse it as an instance message. 1799 return ObjCInstanceMessage; 1800 } 1801 1802 ObjCInterfaceDecl *ClassDeclared; 1803 if (Method->getClassInterface()->lookupInstanceVariable(Name, 1804 ClassDeclared)) 1805 return ObjCInstanceMessage; 1806 } 1807 1808 // Break out; we'll perform typo correction below. 1809 break; 1810 1811 case LookupResult::NotFoundInCurrentInstantiation: 1812 case LookupResult::FoundOverloaded: 1813 case LookupResult::FoundUnresolvedValue: 1814 case LookupResult::Ambiguous: 1815 Result.suppressDiagnostics(); 1816 return ObjCInstanceMessage; 1817 1818 case LookupResult::Found: { 1819 // If the identifier is a class or not, and there is a trailing dot, 1820 // it's an instance message. 1821 if (HasTrailingDot) 1822 return ObjCInstanceMessage; 1823 // We found something. If it's a type, then we have a class 1824 // message. Otherwise, it's an instance message. 1825 NamedDecl *ND = Result.getFoundDecl(); 1826 QualType T; 1827 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(ND)) 1828 T = Context.getObjCInterfaceType(Class); 1829 else if (TypeDecl *Type = dyn_cast<TypeDecl>(ND)) { 1830 T = Context.getTypeDeclType(Type); 1831 DiagnoseUseOfDecl(Type, NameLoc); 1832 } 1833 else 1834 return ObjCInstanceMessage; 1835 1836 // We have a class message, and T is the type we're 1837 // messaging. Build source-location information for it. 1838 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc); 1839 ReceiverType = CreateParsedType(T, TSInfo); 1840 return ObjCClassMessage; 1841 } 1842 } 1843 1844 ObjCInterfaceOrSuperCCC Validator(getCurMethodDecl()); 1845 if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), 1846 Result.getLookupKind(), S, NULL, 1847 Validator)) { 1848 if (Corrected.isKeyword()) { 1849 // If we've found the keyword "super" (the only keyword that would be 1850 // returned by CorrectTypo), this is a send to super. 1851 Diag(NameLoc, diag::err_unknown_receiver_suggest) 1852 << Name << Corrected.getCorrection() 1853 << FixItHint::CreateReplacement(SourceRange(NameLoc), "super"); 1854 return ObjCSuperMessage; 1855 } else if (ObjCInterfaceDecl *Class = 1856 Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) { 1857 // If we found a declaration, correct when it refers to an Objective-C 1858 // class. 1859 Diag(NameLoc, diag::err_unknown_receiver_suggest) 1860 << Name << Corrected.getCorrection() 1861 << FixItHint::CreateReplacement(SourceRange(NameLoc), 1862 Class->getNameAsString()); 1863 Diag(Class->getLocation(), diag::note_previous_decl) 1864 << Corrected.getCorrection(); 1865 1866 QualType T = Context.getObjCInterfaceType(Class); 1867 TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc); 1868 ReceiverType = CreateParsedType(T, TSInfo); 1869 return ObjCClassMessage; 1870 } 1871 } 1872 1873 // Fall back: let the parser try to parse it as an instance message. 1874 return ObjCInstanceMessage; 1875 } 1876 1877 ExprResult Sema::ActOnSuperMessage(Scope *S, 1878 SourceLocation SuperLoc, 1879 Selector Sel, 1880 SourceLocation LBracLoc, 1881 ArrayRef<SourceLocation> SelectorLocs, 1882 SourceLocation RBracLoc, 1883 MultiExprArg Args) { 1884 // Determine whether we are inside a method or not. 1885 ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc); 1886 if (!Method) { 1887 Diag(SuperLoc, diag::err_invalid_receiver_to_message_super); 1888 return ExprError(); 1889 } 1890 1891 ObjCInterfaceDecl *Class = Method->getClassInterface(); 1892 if (!Class) { 1893 Diag(SuperLoc, diag::error_no_super_class_message) 1894 << Method->getDeclName(); 1895 return ExprError(); 1896 } 1897 1898 ObjCInterfaceDecl *Super = Class->getSuperClass(); 1899 if (!Super) { 1900 // The current class does not have a superclass. 1901 Diag(SuperLoc, diag::error_root_class_cannot_use_super) 1902 << Class->getIdentifier(); 1903 return ExprError(); 1904 } 1905 1906 // We are in a method whose class has a superclass, so 'super' 1907 // is acting as a keyword. 1908 if (Method->getSelector() == Sel) 1909 getCurFunction()->ObjCShouldCallSuper = false; 1910 1911 if (Method->isInstanceMethod()) { 1912 // Since we are in an instance method, this is an instance 1913 // message to the superclass instance. 1914 QualType SuperTy = Context.getObjCInterfaceType(Super); 1915 SuperTy = Context.getObjCObjectPointerType(SuperTy); 1916 return BuildInstanceMessage(0, SuperTy, SuperLoc, 1917 Sel, /*Method=*/0, 1918 LBracLoc, SelectorLocs, RBracLoc, Args); 1919 } 1920 1921 // Since we are in a class method, this is a class message to 1922 // the superclass. 1923 return BuildClassMessage(/*ReceiverTypeInfo=*/0, 1924 Context.getObjCInterfaceType(Super), 1925 SuperLoc, Sel, /*Method=*/0, 1926 LBracLoc, SelectorLocs, RBracLoc, Args); 1927 } 1928 1929 1930 ExprResult Sema::BuildClassMessageImplicit(QualType ReceiverType, 1931 bool isSuperReceiver, 1932 SourceLocation Loc, 1933 Selector Sel, 1934 ObjCMethodDecl *Method, 1935 MultiExprArg Args) { 1936 TypeSourceInfo *receiverTypeInfo = 0; 1937 if (!ReceiverType.isNull()) 1938 receiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType); 1939 1940 return BuildClassMessage(receiverTypeInfo, ReceiverType, 1941 /*SuperLoc=*/isSuperReceiver ? Loc : SourceLocation(), 1942 Sel, Method, Loc, Loc, Loc, Args, 1943 /*isImplicit=*/true); 1944 1945 } 1946 1947 static void applyCocoaAPICheck(Sema &S, const ObjCMessageExpr *Msg, 1948 unsigned DiagID, 1949 bool (*refactor)(const ObjCMessageExpr *, 1950 const NSAPI &, edit::Commit &)) { 1951 SourceLocation MsgLoc = Msg->getExprLoc(); 1952 if (S.Diags.getDiagnosticLevel(DiagID, MsgLoc) == DiagnosticsEngine::Ignored) 1953 return; 1954 1955 SourceManager &SM = S.SourceMgr; 1956 edit::Commit ECommit(SM, S.LangOpts); 1957 if (refactor(Msg,*S.NSAPIObj, ECommit)) { 1958 DiagnosticBuilder Builder = S.Diag(MsgLoc, DiagID) 1959 << Msg->getSelector() << Msg->getSourceRange(); 1960 // FIXME: Don't emit diagnostic at all if fixits are non-commitable. 1961 if (!ECommit.isCommitable()) 1962 return; 1963 for (edit::Commit::edit_iterator 1964 I = ECommit.edit_begin(), E = ECommit.edit_end(); I != E; ++I) { 1965 const edit::Commit::Edit &Edit = *I; 1966 switch (Edit.Kind) { 1967 case edit::Commit::Act_Insert: 1968 Builder.AddFixItHint(FixItHint::CreateInsertion(Edit.OrigLoc, 1969 Edit.Text, 1970 Edit.BeforePrev)); 1971 break; 1972 case edit::Commit::Act_InsertFromRange: 1973 Builder.AddFixItHint( 1974 FixItHint::CreateInsertionFromRange(Edit.OrigLoc, 1975 Edit.getInsertFromRange(SM), 1976 Edit.BeforePrev)); 1977 break; 1978 case edit::Commit::Act_Remove: 1979 Builder.AddFixItHint(FixItHint::CreateRemoval(Edit.getFileRange(SM))); 1980 break; 1981 } 1982 } 1983 } 1984 } 1985 1986 static void checkCocoaAPI(Sema &S, const ObjCMessageExpr *Msg) { 1987 applyCocoaAPICheck(S, Msg, diag::warn_objc_redundant_literal_use, 1988 edit::rewriteObjCRedundantCallWithLiteral); 1989 } 1990 1991 /// \brief Build an Objective-C class message expression. 1992 /// 1993 /// This routine takes care of both normal class messages and 1994 /// class messages to the superclass. 1995 /// 1996 /// \param ReceiverTypeInfo Type source information that describes the 1997 /// receiver of this message. This may be NULL, in which case we are 1998 /// sending to the superclass and \p SuperLoc must be a valid source 1999 /// location. 2000 2001 /// \param ReceiverType The type of the object receiving the 2002 /// message. When \p ReceiverTypeInfo is non-NULL, this is the same 2003 /// type as that refers to. For a superclass send, this is the type of 2004 /// the superclass. 2005 /// 2006 /// \param SuperLoc The location of the "super" keyword in a 2007 /// superclass message. 2008 /// 2009 /// \param Sel The selector to which the message is being sent. 2010 /// 2011 /// \param Method The method that this class message is invoking, if 2012 /// already known. 2013 /// 2014 /// \param LBracLoc The location of the opening square bracket ']'. 2015 /// 2016 /// \param RBracLoc The location of the closing square bracket ']'. 2017 /// 2018 /// \param ArgsIn The message arguments. 2019 ExprResult Sema::BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo, 2020 QualType ReceiverType, 2021 SourceLocation SuperLoc, 2022 Selector Sel, 2023 ObjCMethodDecl *Method, 2024 SourceLocation LBracLoc, 2025 ArrayRef<SourceLocation> SelectorLocs, 2026 SourceLocation RBracLoc, 2027 MultiExprArg ArgsIn, 2028 bool isImplicit) { 2029 SourceLocation Loc = SuperLoc.isValid()? SuperLoc 2030 : ReceiverTypeInfo->getTypeLoc().getSourceRange().getBegin(); 2031 if (LBracLoc.isInvalid()) { 2032 Diag(Loc, diag::err_missing_open_square_message_send) 2033 << FixItHint::CreateInsertion(Loc, "["); 2034 LBracLoc = Loc; 2035 } 2036 SourceLocation SelLoc; 2037 if (!SelectorLocs.empty() && SelectorLocs.front().isValid()) 2038 SelLoc = SelectorLocs.front(); 2039 else 2040 SelLoc = Loc; 2041 2042 if (ReceiverType->isDependentType()) { 2043 // If the receiver type is dependent, we can't type-check anything 2044 // at this point. Build a dependent expression. 2045 unsigned NumArgs = ArgsIn.size(); 2046 Expr **Args = ArgsIn.data(); 2047 assert(SuperLoc.isInvalid() && "Message to super with dependent type"); 2048 return Owned(ObjCMessageExpr::Create(Context, ReceiverType, 2049 VK_RValue, LBracLoc, ReceiverTypeInfo, 2050 Sel, SelectorLocs, /*Method=*/0, 2051 makeArrayRef(Args, NumArgs),RBracLoc, 2052 isImplicit)); 2053 } 2054 2055 // Find the class to which we are sending this message. 2056 ObjCInterfaceDecl *Class = 0; 2057 const ObjCObjectType *ClassType = ReceiverType->getAs<ObjCObjectType>(); 2058 if (!ClassType || !(Class = ClassType->getInterface())) { 2059 Diag(Loc, diag::err_invalid_receiver_class_message) 2060 << ReceiverType; 2061 return ExprError(); 2062 } 2063 assert(Class && "We don't know which class we're messaging?"); 2064 // objc++ diagnoses during typename annotation. 2065 if (!getLangOpts().CPlusPlus) 2066 (void)DiagnoseUseOfDecl(Class, SelLoc); 2067 // Find the method we are messaging. 2068 if (!Method) { 2069 SourceRange TypeRange 2070 = SuperLoc.isValid()? SourceRange(SuperLoc) 2071 : ReceiverTypeInfo->getTypeLoc().getSourceRange(); 2072 if (RequireCompleteType(Loc, Context.getObjCInterfaceType(Class), 2073 (getLangOpts().ObjCAutoRefCount 2074 ? diag::err_arc_receiver_forward_class 2075 : diag::warn_receiver_forward_class), 2076 TypeRange)) { 2077 // A forward class used in messaging is treated as a 'Class' 2078 Method = LookupFactoryMethodInGlobalPool(Sel, 2079 SourceRange(LBracLoc, RBracLoc)); 2080 if (Method && !getLangOpts().ObjCAutoRefCount) 2081 Diag(Method->getLocation(), diag::note_method_sent_forward_class) 2082 << Method->getDeclName(); 2083 } 2084 if (!Method) 2085 Method = Class->lookupClassMethod(Sel); 2086 2087 // If we have an implementation in scope, check "private" methods. 2088 if (!Method) 2089 Method = Class->lookupPrivateClassMethod(Sel); 2090 2091 if (Method && DiagnoseUseOfDecl(Method, SelLoc)) 2092 return ExprError(); 2093 } 2094 2095 // Check the argument types and determine the result type. 2096 QualType ReturnType; 2097 ExprValueKind VK = VK_RValue; 2098 2099 unsigned NumArgs = ArgsIn.size(); 2100 Expr **Args = ArgsIn.data(); 2101 if (CheckMessageArgumentTypes(ReceiverType, MultiExprArg(Args, NumArgs), 2102 Sel, SelectorLocs, 2103 Method, true, 2104 SuperLoc.isValid(), LBracLoc, RBracLoc, 2105 ReturnType, VK)) 2106 return ExprError(); 2107 2108 if (Method && !Method->getResultType()->isVoidType() && 2109 RequireCompleteType(LBracLoc, Method->getResultType(), 2110 diag::err_illegal_message_expr_incomplete_type)) 2111 return ExprError(); 2112 2113 // Construct the appropriate ObjCMessageExpr. 2114 ObjCMessageExpr *Result; 2115 if (SuperLoc.isValid()) 2116 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, 2117 SuperLoc, /*IsInstanceSuper=*/false, 2118 ReceiverType, Sel, SelectorLocs, 2119 Method, makeArrayRef(Args, NumArgs), 2120 RBracLoc, isImplicit); 2121 else { 2122 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, 2123 ReceiverTypeInfo, Sel, SelectorLocs, 2124 Method, makeArrayRef(Args, NumArgs), 2125 RBracLoc, isImplicit); 2126 if (!isImplicit) 2127 checkCocoaAPI(*this, Result); 2128 } 2129 return MaybeBindToTemporary(Result); 2130 } 2131 2132 // ActOnClassMessage - used for both unary and keyword messages. 2133 // ArgExprs is optional - if it is present, the number of expressions 2134 // is obtained from Sel.getNumArgs(). 2135 ExprResult Sema::ActOnClassMessage(Scope *S, 2136 ParsedType Receiver, 2137 Selector Sel, 2138 SourceLocation LBracLoc, 2139 ArrayRef<SourceLocation> SelectorLocs, 2140 SourceLocation RBracLoc, 2141 MultiExprArg Args) { 2142 TypeSourceInfo *ReceiverTypeInfo; 2143 QualType ReceiverType = GetTypeFromParser(Receiver, &ReceiverTypeInfo); 2144 if (ReceiverType.isNull()) 2145 return ExprError(); 2146 2147 2148 if (!ReceiverTypeInfo) 2149 ReceiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType, LBracLoc); 2150 2151 return BuildClassMessage(ReceiverTypeInfo, ReceiverType, 2152 /*SuperLoc=*/SourceLocation(), Sel, /*Method=*/0, 2153 LBracLoc, SelectorLocs, RBracLoc, Args); 2154 } 2155 2156 ExprResult Sema::BuildInstanceMessageImplicit(Expr *Receiver, 2157 QualType ReceiverType, 2158 SourceLocation Loc, 2159 Selector Sel, 2160 ObjCMethodDecl *Method, 2161 MultiExprArg Args) { 2162 return BuildInstanceMessage(Receiver, ReceiverType, 2163 /*SuperLoc=*/!Receiver ? Loc : SourceLocation(), 2164 Sel, Method, Loc, Loc, Loc, Args, 2165 /*isImplicit=*/true); 2166 } 2167 2168 /// \brief Build an Objective-C instance message expression. 2169 /// 2170 /// This routine takes care of both normal instance messages and 2171 /// instance messages to the superclass instance. 2172 /// 2173 /// \param Receiver The expression that computes the object that will 2174 /// receive this message. This may be empty, in which case we are 2175 /// sending to the superclass instance and \p SuperLoc must be a valid 2176 /// source location. 2177 /// 2178 /// \param ReceiverType The (static) type of the object receiving the 2179 /// message. When a \p Receiver expression is provided, this is the 2180 /// same type as that expression. For a superclass instance send, this 2181 /// is a pointer to the type of the superclass. 2182 /// 2183 /// \param SuperLoc The location of the "super" keyword in a 2184 /// superclass instance message. 2185 /// 2186 /// \param Sel The selector to which the message is being sent. 2187 /// 2188 /// \param Method The method that this instance message is invoking, if 2189 /// already known. 2190 /// 2191 /// \param LBracLoc The location of the opening square bracket ']'. 2192 /// 2193 /// \param RBracLoc The location of the closing square bracket ']'. 2194 /// 2195 /// \param ArgsIn The message arguments. 2196 ExprResult Sema::BuildInstanceMessage(Expr *Receiver, 2197 QualType ReceiverType, 2198 SourceLocation SuperLoc, 2199 Selector Sel, 2200 ObjCMethodDecl *Method, 2201 SourceLocation LBracLoc, 2202 ArrayRef<SourceLocation> SelectorLocs, 2203 SourceLocation RBracLoc, 2204 MultiExprArg ArgsIn, 2205 bool isImplicit) { 2206 // The location of the receiver. 2207 SourceLocation Loc = SuperLoc.isValid()? SuperLoc : Receiver->getLocStart(); 2208 SourceRange RecRange = 2209 SuperLoc.isValid()? SuperLoc : Receiver->getSourceRange(); 2210 SourceLocation SelLoc; 2211 if (!SelectorLocs.empty() && SelectorLocs.front().isValid()) 2212 SelLoc = SelectorLocs.front(); 2213 else 2214 SelLoc = Loc; 2215 2216 if (LBracLoc.isInvalid()) { 2217 Diag(Loc, diag::err_missing_open_square_message_send) 2218 << FixItHint::CreateInsertion(Loc, "["); 2219 LBracLoc = Loc; 2220 } 2221 2222 // If we have a receiver expression, perform appropriate promotions 2223 // and determine receiver type. 2224 if (Receiver) { 2225 if (Receiver->hasPlaceholderType()) { 2226 ExprResult Result; 2227 if (Receiver->getType() == Context.UnknownAnyTy) 2228 Result = forceUnknownAnyToType(Receiver, Context.getObjCIdType()); 2229 else 2230 Result = CheckPlaceholderExpr(Receiver); 2231 if (Result.isInvalid()) return ExprError(); 2232 Receiver = Result.take(); 2233 } 2234 2235 if (Receiver->isTypeDependent()) { 2236 // If the receiver is type-dependent, we can't type-check anything 2237 // at this point. Build a dependent expression. 2238 unsigned NumArgs = ArgsIn.size(); 2239 Expr **Args = ArgsIn.data(); 2240 assert(SuperLoc.isInvalid() && "Message to super with dependent type"); 2241 return Owned(ObjCMessageExpr::Create(Context, Context.DependentTy, 2242 VK_RValue, LBracLoc, Receiver, Sel, 2243 SelectorLocs, /*Method=*/0, 2244 makeArrayRef(Args, NumArgs), 2245 RBracLoc, isImplicit)); 2246 } 2247 2248 // If necessary, apply function/array conversion to the receiver. 2249 // C99 6.7.5.3p[7,8]. 2250 ExprResult Result = DefaultFunctionArrayLvalueConversion(Receiver); 2251 if (Result.isInvalid()) 2252 return ExprError(); 2253 Receiver = Result.take(); 2254 ReceiverType = Receiver->getType(); 2255 2256 // If the receiver is an ObjC pointer, a block pointer, or an 2257 // __attribute__((NSObject)) pointer, we don't need to do any 2258 // special conversion in order to look up a receiver. 2259 if (ReceiverType->isObjCRetainableType()) { 2260 // do nothing 2261 } else if (!getLangOpts().ObjCAutoRefCount && 2262 !Context.getObjCIdType().isNull() && 2263 (ReceiverType->isPointerType() || 2264 ReceiverType->isIntegerType())) { 2265 // Implicitly convert integers and pointers to 'id' but emit a warning. 2266 // But not in ARC. 2267 Diag(Loc, diag::warn_bad_receiver_type) 2268 << ReceiverType 2269 << Receiver->getSourceRange(); 2270 if (ReceiverType->isPointerType()) { 2271 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(), 2272 CK_CPointerToObjCPointerCast).take(); 2273 } else { 2274 // TODO: specialized warning on null receivers? 2275 bool IsNull = Receiver->isNullPointerConstant(Context, 2276 Expr::NPC_ValueDependentIsNull); 2277 CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer; 2278 Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(), 2279 Kind).take(); 2280 } 2281 ReceiverType = Receiver->getType(); 2282 } else if (getLangOpts().CPlusPlus) { 2283 ExprResult result = PerformContextuallyConvertToObjCPointer(Receiver); 2284 if (result.isUsable()) { 2285 Receiver = result.take(); 2286 ReceiverType = Receiver->getType(); 2287 } 2288 } 2289 } 2290 2291 // There's a somewhat weird interaction here where we assume that we 2292 // won't actually have a method unless we also don't need to do some 2293 // of the more detailed type-checking on the receiver. 2294 2295 if (!Method) { 2296 // Handle messages to id. 2297 bool receiverIsId = ReceiverType->isObjCIdType(); 2298 if (receiverIsId || ReceiverType->isBlockPointerType() || 2299 (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) { 2300 Method = LookupInstanceMethodInGlobalPool(Sel, 2301 SourceRange(LBracLoc, RBracLoc), 2302 receiverIsId); 2303 if (!Method) 2304 Method = LookupFactoryMethodInGlobalPool(Sel, 2305 SourceRange(LBracLoc,RBracLoc), 2306 receiverIsId); 2307 } else if (ReceiverType->isObjCClassType() || 2308 ReceiverType->isObjCQualifiedClassType()) { 2309 // Handle messages to Class. 2310 // We allow sending a message to a qualified Class ("Class<foo>"), which 2311 // is ok as long as one of the protocols implements the selector (if not, warn). 2312 if (const ObjCObjectPointerType *QClassTy 2313 = ReceiverType->getAsObjCQualifiedClassType()) { 2314 // Search protocols for class methods. 2315 Method = LookupMethodInQualifiedType(Sel, QClassTy, false); 2316 if (!Method) { 2317 Method = LookupMethodInQualifiedType(Sel, QClassTy, true); 2318 // warn if instance method found for a Class message. 2319 if (Method) { 2320 Diag(SelLoc, diag::warn_instance_method_on_class_found) 2321 << Method->getSelector() << Sel; 2322 Diag(Method->getLocation(), diag::note_method_declared_at) 2323 << Method->getDeclName(); 2324 } 2325 } 2326 } else { 2327 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) { 2328 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) { 2329 // First check the public methods in the class interface. 2330 Method = ClassDecl->lookupClassMethod(Sel); 2331 2332 if (!Method) 2333 Method = ClassDecl->lookupPrivateClassMethod(Sel); 2334 } 2335 if (Method && DiagnoseUseOfDecl(Method, SelLoc)) 2336 return ExprError(); 2337 } 2338 if (!Method) { 2339 // If not messaging 'self', look for any factory method named 'Sel'. 2340 if (!Receiver || !isSelfExpr(Receiver)) { 2341 Method = LookupFactoryMethodInGlobalPool(Sel, 2342 SourceRange(LBracLoc, RBracLoc), 2343 true); 2344 if (!Method) { 2345 // If no class (factory) method was found, check if an _instance_ 2346 // method of the same name exists in the root class only. 2347 Method = LookupInstanceMethodInGlobalPool(Sel, 2348 SourceRange(LBracLoc, RBracLoc), 2349 true); 2350 if (Method) 2351 if (const ObjCInterfaceDecl *ID = 2352 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) { 2353 if (ID->getSuperClass()) 2354 Diag(SelLoc, diag::warn_root_inst_method_not_found) 2355 << Sel << SourceRange(LBracLoc, RBracLoc); 2356 } 2357 } 2358 } 2359 } 2360 } 2361 } else { 2362 ObjCInterfaceDecl* ClassDecl = 0; 2363 2364 // We allow sending a message to a qualified ID ("id<foo>"), which is ok as 2365 // long as one of the protocols implements the selector (if not, warn). 2366 // And as long as message is not deprecated/unavailable (warn if it is). 2367 if (const ObjCObjectPointerType *QIdTy 2368 = ReceiverType->getAsObjCQualifiedIdType()) { 2369 // Search protocols for instance methods. 2370 Method = LookupMethodInQualifiedType(Sel, QIdTy, true); 2371 if (!Method) 2372 Method = LookupMethodInQualifiedType(Sel, QIdTy, false); 2373 if (Method && DiagnoseUseOfDecl(Method, SelLoc)) 2374 return ExprError(); 2375 } else if (const ObjCObjectPointerType *OCIType 2376 = ReceiverType->getAsObjCInterfacePointerType()) { 2377 // We allow sending a message to a pointer to an interface (an object). 2378 ClassDecl = OCIType->getInterfaceDecl(); 2379 2380 // Try to complete the type. Under ARC, this is a hard error from which 2381 // we don't try to recover. 2382 const ObjCInterfaceDecl *forwardClass = 0; 2383 if (RequireCompleteType(Loc, OCIType->getPointeeType(), 2384 getLangOpts().ObjCAutoRefCount 2385 ? diag::err_arc_receiver_forward_instance 2386 : diag::warn_receiver_forward_instance, 2387 Receiver? Receiver->getSourceRange() 2388 : SourceRange(SuperLoc))) { 2389 if (getLangOpts().ObjCAutoRefCount) 2390 return ExprError(); 2391 2392 forwardClass = OCIType->getInterfaceDecl(); 2393 Diag(Receiver ? Receiver->getLocStart() 2394 : SuperLoc, diag::note_receiver_is_id); 2395 Method = 0; 2396 } else { 2397 Method = ClassDecl->lookupInstanceMethod(Sel); 2398 } 2399 2400 if (!Method) 2401 // Search protocol qualifiers. 2402 Method = LookupMethodInQualifiedType(Sel, OCIType, true); 2403 2404 if (!Method) { 2405 // If we have implementations in scope, check "private" methods. 2406 Method = ClassDecl->lookupPrivateMethod(Sel); 2407 2408 if (!Method && getLangOpts().ObjCAutoRefCount) { 2409 Diag(SelLoc, diag::err_arc_may_not_respond) 2410 << OCIType->getPointeeType() << Sel << RecRange 2411 << SourceRange(SelectorLocs.front(), SelectorLocs.back()); 2412 return ExprError(); 2413 } 2414 2415 if (!Method && (!Receiver || !isSelfExpr(Receiver))) { 2416 // If we still haven't found a method, look in the global pool. This 2417 // behavior isn't very desirable, however we need it for GCC 2418 // compatibility. FIXME: should we deviate?? 2419 if (OCIType->qual_empty()) { 2420 Method = LookupInstanceMethodInGlobalPool(Sel, 2421 SourceRange(LBracLoc, RBracLoc)); 2422 if (Method && !forwardClass) 2423 Diag(SelLoc, diag::warn_maynot_respond) 2424 << OCIType->getInterfaceDecl()->getIdentifier() 2425 << Sel << RecRange; 2426 } 2427 } 2428 } 2429 if (Method && DiagnoseUseOfDecl(Method, SelLoc, forwardClass)) 2430 return ExprError(); 2431 } else { 2432 // Reject other random receiver types (e.g. structs). 2433 Diag(Loc, diag::err_bad_receiver_type) 2434 << ReceiverType << Receiver->getSourceRange(); 2435 return ExprError(); 2436 } 2437 } 2438 } 2439 2440 // Check the message arguments. 2441 unsigned NumArgs = ArgsIn.size(); 2442 Expr **Args = ArgsIn.data(); 2443 QualType ReturnType; 2444 ExprValueKind VK = VK_RValue; 2445 bool ClassMessage = (ReceiverType->isObjCClassType() || 2446 ReceiverType->isObjCQualifiedClassType()); 2447 if (CheckMessageArgumentTypes(ReceiverType, MultiExprArg(Args, NumArgs), 2448 Sel, SelectorLocs, Method, 2449 ClassMessage, SuperLoc.isValid(), 2450 LBracLoc, RBracLoc, ReturnType, VK)) 2451 return ExprError(); 2452 2453 if (Method && !Method->getResultType()->isVoidType() && 2454 RequireCompleteType(LBracLoc, Method->getResultType(), 2455 diag::err_illegal_message_expr_incomplete_type)) 2456 return ExprError(); 2457 2458 // In ARC, forbid the user from sending messages to 2459 // retain/release/autorelease/dealloc/retainCount explicitly. 2460 if (getLangOpts().ObjCAutoRefCount) { 2461 ObjCMethodFamily family = 2462 (Method ? Method->getMethodFamily() : Sel.getMethodFamily()); 2463 switch (family) { 2464 case OMF_init: 2465 if (Method) 2466 checkInitMethod(Method, ReceiverType); 2467 2468 case OMF_None: 2469 case OMF_alloc: 2470 case OMF_copy: 2471 case OMF_finalize: 2472 case OMF_mutableCopy: 2473 case OMF_new: 2474 case OMF_self: 2475 break; 2476 2477 case OMF_dealloc: 2478 case OMF_retain: 2479 case OMF_release: 2480 case OMF_autorelease: 2481 case OMF_retainCount: 2482 Diag(SelLoc, diag::err_arc_illegal_explicit_message) 2483 << Sel << RecRange; 2484 break; 2485 2486 case OMF_performSelector: 2487 if (Method && NumArgs >= 1) { 2488 if (ObjCSelectorExpr *SelExp = dyn_cast<ObjCSelectorExpr>(Args[0])) { 2489 Selector ArgSel = SelExp->getSelector(); 2490 ObjCMethodDecl *SelMethod = 2491 LookupInstanceMethodInGlobalPool(ArgSel, 2492 SelExp->getSourceRange()); 2493 if (!SelMethod) 2494 SelMethod = 2495 LookupFactoryMethodInGlobalPool(ArgSel, 2496 SelExp->getSourceRange()); 2497 if (SelMethod) { 2498 ObjCMethodFamily SelFamily = SelMethod->getMethodFamily(); 2499 switch (SelFamily) { 2500 case OMF_alloc: 2501 case OMF_copy: 2502 case OMF_mutableCopy: 2503 case OMF_new: 2504 case OMF_self: 2505 case OMF_init: 2506 // Issue error, unless ns_returns_not_retained. 2507 if (!SelMethod->hasAttr<NSReturnsNotRetainedAttr>()) { 2508 // selector names a +1 method 2509 Diag(SelLoc, 2510 diag::err_arc_perform_selector_retains); 2511 Diag(SelMethod->getLocation(), diag::note_method_declared_at) 2512 << SelMethod->getDeclName(); 2513 } 2514 break; 2515 default: 2516 // +0 call. OK. unless ns_returns_retained. 2517 if (SelMethod->hasAttr<NSReturnsRetainedAttr>()) { 2518 // selector names a +1 method 2519 Diag(SelLoc, 2520 diag::err_arc_perform_selector_retains); 2521 Diag(SelMethod->getLocation(), diag::note_method_declared_at) 2522 << SelMethod->getDeclName(); 2523 } 2524 break; 2525 } 2526 } 2527 } else { 2528 // error (may leak). 2529 Diag(SelLoc, diag::warn_arc_perform_selector_leaks); 2530 Diag(Args[0]->getExprLoc(), diag::note_used_here); 2531 } 2532 } 2533 break; 2534 } 2535 } 2536 2537 // Construct the appropriate ObjCMessageExpr instance. 2538 ObjCMessageExpr *Result; 2539 if (SuperLoc.isValid()) 2540 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, 2541 SuperLoc, /*IsInstanceSuper=*/true, 2542 ReceiverType, Sel, SelectorLocs, Method, 2543 makeArrayRef(Args, NumArgs), RBracLoc, 2544 isImplicit); 2545 else { 2546 Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc, 2547 Receiver, Sel, SelectorLocs, Method, 2548 makeArrayRef(Args, NumArgs), RBracLoc, 2549 isImplicit); 2550 if (!isImplicit) 2551 checkCocoaAPI(*this, Result); 2552 } 2553 2554 if (getLangOpts().ObjCAutoRefCount) { 2555 DiagnoseARCUseOfWeakReceiver(*this, Receiver); 2556 2557 // In ARC, annotate delegate init calls. 2558 if (Result->getMethodFamily() == OMF_init && 2559 (SuperLoc.isValid() || isSelfExpr(Receiver))) { 2560 // Only consider init calls *directly* in init implementations, 2561 // not within blocks. 2562 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(CurContext); 2563 if (method && method->getMethodFamily() == OMF_init) { 2564 // The implicit assignment to self means we also don't want to 2565 // consume the result. 2566 Result->setDelegateInitCall(true); 2567 return Owned(Result); 2568 } 2569 } 2570 2571 // In ARC, check for message sends which are likely to introduce 2572 // retain cycles. 2573 checkRetainCycles(Result); 2574 2575 if (!isImplicit && Method) { 2576 if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) { 2577 bool IsWeak = 2578 Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak; 2579 if (!IsWeak && Sel.isUnarySelector()) 2580 IsWeak = ReturnType.getObjCLifetime() & Qualifiers::OCL_Weak; 2581 2582 if (IsWeak) { 2583 DiagnosticsEngine::Level Level = 2584 Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak, 2585 LBracLoc); 2586 if (Level != DiagnosticsEngine::Ignored) 2587 getCurFunction()->recordUseOfWeak(Result, Prop); 2588 2589 } 2590 } 2591 } 2592 } 2593 2594 return MaybeBindToTemporary(Result); 2595 } 2596 2597 static void RemoveSelectorFromWarningCache(Sema &S, Expr* Arg) { 2598 if (ObjCSelectorExpr *OSE = 2599 dyn_cast<ObjCSelectorExpr>(Arg->IgnoreParenCasts())) { 2600 Selector Sel = OSE->getSelector(); 2601 SourceLocation Loc = OSE->getAtLoc(); 2602 llvm::DenseMap<Selector, SourceLocation>::iterator Pos 2603 = S.ReferencedSelectors.find(Sel); 2604 if (Pos != S.ReferencedSelectors.end() && Pos->second == Loc) 2605 S.ReferencedSelectors.erase(Pos); 2606 } 2607 } 2608 2609 // ActOnInstanceMessage - used for both unary and keyword messages. 2610 // ArgExprs is optional - if it is present, the number of expressions 2611 // is obtained from Sel.getNumArgs(). 2612 ExprResult Sema::ActOnInstanceMessage(Scope *S, 2613 Expr *Receiver, 2614 Selector Sel, 2615 SourceLocation LBracLoc, 2616 ArrayRef<SourceLocation> SelectorLocs, 2617 SourceLocation RBracLoc, 2618 MultiExprArg Args) { 2619 if (!Receiver) 2620 return ExprError(); 2621 2622 // A ParenListExpr can show up while doing error recovery with invalid code. 2623 if (isa<ParenListExpr>(Receiver)) { 2624 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Receiver); 2625 if (Result.isInvalid()) return ExprError(); 2626 Receiver = Result.take(); 2627 } 2628 2629 if (RespondsToSelectorSel.isNull()) { 2630 IdentifierInfo *SelectorId = &Context.Idents.get("respondsToSelector"); 2631 RespondsToSelectorSel = Context.Selectors.getUnarySelector(SelectorId); 2632 } 2633 if (Sel == RespondsToSelectorSel) 2634 RemoveSelectorFromWarningCache(*this, Args[0]); 2635 2636 return BuildInstanceMessage(Receiver, Receiver->getType(), 2637 /*SuperLoc=*/SourceLocation(), Sel, /*Method=*/0, 2638 LBracLoc, SelectorLocs, RBracLoc, Args); 2639 } 2640 2641 enum ARCConversionTypeClass { 2642 /// int, void, struct A 2643 ACTC_none, 2644 2645 /// id, void (^)() 2646 ACTC_retainable, 2647 2648 /// id*, id***, void (^*)(), 2649 ACTC_indirectRetainable, 2650 2651 /// void* might be a normal C type, or it might a CF type. 2652 ACTC_voidPtr, 2653 2654 /// struct A* 2655 ACTC_coreFoundation 2656 }; 2657 static bool isAnyRetainable(ARCConversionTypeClass ACTC) { 2658 return (ACTC == ACTC_retainable || 2659 ACTC == ACTC_coreFoundation || 2660 ACTC == ACTC_voidPtr); 2661 } 2662 static bool isAnyCLike(ARCConversionTypeClass ACTC) { 2663 return ACTC == ACTC_none || 2664 ACTC == ACTC_voidPtr || 2665 ACTC == ACTC_coreFoundation; 2666 } 2667 2668 static ARCConversionTypeClass classifyTypeForARCConversion(QualType type) { 2669 bool isIndirect = false; 2670 2671 // Ignore an outermost reference type. 2672 if (const ReferenceType *ref = type->getAs<ReferenceType>()) { 2673 type = ref->getPointeeType(); 2674 isIndirect = true; 2675 } 2676 2677 // Drill through pointers and arrays recursively. 2678 while (true) { 2679 if (const PointerType *ptr = type->getAs<PointerType>()) { 2680 type = ptr->getPointeeType(); 2681 2682 // The first level of pointer may be the innermost pointer on a CF type. 2683 if (!isIndirect) { 2684 if (type->isVoidType()) return ACTC_voidPtr; 2685 if (type->isRecordType()) return ACTC_coreFoundation; 2686 } 2687 } else if (const ArrayType *array = type->getAsArrayTypeUnsafe()) { 2688 type = QualType(array->getElementType()->getBaseElementTypeUnsafe(), 0); 2689 } else { 2690 break; 2691 } 2692 isIndirect = true; 2693 } 2694 2695 if (isIndirect) { 2696 if (type->isObjCARCBridgableType()) 2697 return ACTC_indirectRetainable; 2698 return ACTC_none; 2699 } 2700 2701 if (type->isObjCARCBridgableType()) 2702 return ACTC_retainable; 2703 2704 return ACTC_none; 2705 } 2706 2707 namespace { 2708 /// A result from the cast checker. 2709 enum ACCResult { 2710 /// Cannot be casted. 2711 ACC_invalid, 2712 2713 /// Can be safely retained or not retained. 2714 ACC_bottom, 2715 2716 /// Can be casted at +0. 2717 ACC_plusZero, 2718 2719 /// Can be casted at +1. 2720 ACC_plusOne 2721 }; 2722 ACCResult merge(ACCResult left, ACCResult right) { 2723 if (left == right) return left; 2724 if (left == ACC_bottom) return right; 2725 if (right == ACC_bottom) return left; 2726 return ACC_invalid; 2727 } 2728 2729 /// A checker which white-lists certain expressions whose conversion 2730 /// to or from retainable type would otherwise be forbidden in ARC. 2731 class ARCCastChecker : public StmtVisitor<ARCCastChecker, ACCResult> { 2732 typedef StmtVisitor<ARCCastChecker, ACCResult> super; 2733 2734 ASTContext &Context; 2735 ARCConversionTypeClass SourceClass; 2736 ARCConversionTypeClass TargetClass; 2737 bool Diagnose; 2738 2739 static bool isCFType(QualType type) { 2740 // Someday this can use ns_bridged. For now, it has to do this. 2741 return type->isCARCBridgableType(); 2742 } 2743 2744 public: 2745 ARCCastChecker(ASTContext &Context, ARCConversionTypeClass source, 2746 ARCConversionTypeClass target, bool diagnose) 2747 : Context(Context), SourceClass(source), TargetClass(target), 2748 Diagnose(diagnose) {} 2749 2750 using super::Visit; 2751 ACCResult Visit(Expr *e) { 2752 return super::Visit(e->IgnoreParens()); 2753 } 2754 2755 ACCResult VisitStmt(Stmt *s) { 2756 return ACC_invalid; 2757 } 2758 2759 /// Null pointer constants can be casted however you please. 2760 ACCResult VisitExpr(Expr *e) { 2761 if (e->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull)) 2762 return ACC_bottom; 2763 return ACC_invalid; 2764 } 2765 2766 /// Objective-C string literals can be safely casted. 2767 ACCResult VisitObjCStringLiteral(ObjCStringLiteral *e) { 2768 // If we're casting to any retainable type, go ahead. Global 2769 // strings are immune to retains, so this is bottom. 2770 if (isAnyRetainable(TargetClass)) return ACC_bottom; 2771 2772 return ACC_invalid; 2773 } 2774 2775 /// Look through certain implicit and explicit casts. 2776 ACCResult VisitCastExpr(CastExpr *e) { 2777 switch (e->getCastKind()) { 2778 case CK_NullToPointer: 2779 return ACC_bottom; 2780 2781 case CK_NoOp: 2782 case CK_LValueToRValue: 2783 case CK_BitCast: 2784 case CK_CPointerToObjCPointerCast: 2785 case CK_BlockPointerToObjCPointerCast: 2786 case CK_AnyPointerToBlockPointerCast: 2787 return Visit(e->getSubExpr()); 2788 2789 default: 2790 return ACC_invalid; 2791 } 2792 } 2793 2794 /// Look through unary extension. 2795 ACCResult VisitUnaryExtension(UnaryOperator *e) { 2796 return Visit(e->getSubExpr()); 2797 } 2798 2799 /// Ignore the LHS of a comma operator. 2800 ACCResult VisitBinComma(BinaryOperator *e) { 2801 return Visit(e->getRHS()); 2802 } 2803 2804 /// Conditional operators are okay if both sides are okay. 2805 ACCResult VisitConditionalOperator(ConditionalOperator *e) { 2806 ACCResult left = Visit(e->getTrueExpr()); 2807 if (left == ACC_invalid) return ACC_invalid; 2808 return merge(left, Visit(e->getFalseExpr())); 2809 } 2810 2811 /// Look through pseudo-objects. 2812 ACCResult VisitPseudoObjectExpr(PseudoObjectExpr *e) { 2813 // If we're getting here, we should always have a result. 2814 return Visit(e->getResultExpr()); 2815 } 2816 2817 /// Statement expressions are okay if their result expression is okay. 2818 ACCResult VisitStmtExpr(StmtExpr *e) { 2819 return Visit(e->getSubStmt()->body_back()); 2820 } 2821 2822 /// Some declaration references are okay. 2823 ACCResult VisitDeclRefExpr(DeclRefExpr *e) { 2824 // References to global constants from system headers are okay. 2825 // These are things like 'kCFStringTransformToLatin'. They are 2826 // can also be assumed to be immune to retains. 2827 VarDecl *var = dyn_cast<VarDecl>(e->getDecl()); 2828 if (isAnyRetainable(TargetClass) && 2829 isAnyRetainable(SourceClass) && 2830 var && 2831 var->getStorageClass() == SC_Extern && 2832 var->getType().isConstQualified() && 2833 Context.getSourceManager().isInSystemHeader(var->getLocation())) { 2834 return ACC_bottom; 2835 } 2836 2837 // Nothing else. 2838 return ACC_invalid; 2839 } 2840 2841 /// Some calls are okay. 2842 ACCResult VisitCallExpr(CallExpr *e) { 2843 if (FunctionDecl *fn = e->getDirectCallee()) 2844 if (ACCResult result = checkCallToFunction(fn)) 2845 return result; 2846 2847 return super::VisitCallExpr(e); 2848 } 2849 2850 ACCResult checkCallToFunction(FunctionDecl *fn) { 2851 // Require a CF*Ref return type. 2852 if (!isCFType(fn->getResultType())) 2853 return ACC_invalid; 2854 2855 if (!isAnyRetainable(TargetClass)) 2856 return ACC_invalid; 2857 2858 // Honor an explicit 'not retained' attribute. 2859 if (fn->hasAttr<CFReturnsNotRetainedAttr>()) 2860 return ACC_plusZero; 2861 2862 // Honor an explicit 'retained' attribute, except that for 2863 // now we're not going to permit implicit handling of +1 results, 2864 // because it's a bit frightening. 2865 if (fn->hasAttr<CFReturnsRetainedAttr>()) 2866 return Diagnose ? ACC_plusOne 2867 : ACC_invalid; // ACC_plusOne if we start accepting this 2868 2869 // Recognize this specific builtin function, which is used by CFSTR. 2870 unsigned builtinID = fn->getBuiltinID(); 2871 if (builtinID == Builtin::BI__builtin___CFStringMakeConstantString) 2872 return ACC_bottom; 2873 2874 // Otherwise, don't do anything implicit with an unaudited function. 2875 if (!fn->hasAttr<CFAuditedTransferAttr>()) 2876 return ACC_invalid; 2877 2878 // Otherwise, it's +0 unless it follows the create convention. 2879 if (ento::coreFoundation::followsCreateRule(fn)) 2880 return Diagnose ? ACC_plusOne 2881 : ACC_invalid; // ACC_plusOne if we start accepting this 2882 2883 return ACC_plusZero; 2884 } 2885 2886 ACCResult VisitObjCMessageExpr(ObjCMessageExpr *e) { 2887 return checkCallToMethod(e->getMethodDecl()); 2888 } 2889 2890 ACCResult VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *e) { 2891 ObjCMethodDecl *method; 2892 if (e->isExplicitProperty()) 2893 method = e->getExplicitProperty()->getGetterMethodDecl(); 2894 else 2895 method = e->getImplicitPropertyGetter(); 2896 return checkCallToMethod(method); 2897 } 2898 2899 ACCResult checkCallToMethod(ObjCMethodDecl *method) { 2900 if (!method) return ACC_invalid; 2901 2902 // Check for message sends to functions returning CF types. We 2903 // just obey the Cocoa conventions with these, even though the 2904 // return type is CF. 2905 if (!isAnyRetainable(TargetClass) || !isCFType(method->getResultType())) 2906 return ACC_invalid; 2907 2908 // If the method is explicitly marked not-retained, it's +0. 2909 if (method->hasAttr<CFReturnsNotRetainedAttr>()) 2910 return ACC_plusZero; 2911 2912 // If the method is explicitly marked as returning retained, or its 2913 // selector follows a +1 Cocoa convention, treat it as +1. 2914 if (method->hasAttr<CFReturnsRetainedAttr>()) 2915 return ACC_plusOne; 2916 2917 switch (method->getSelector().getMethodFamily()) { 2918 case OMF_alloc: 2919 case OMF_copy: 2920 case OMF_mutableCopy: 2921 case OMF_new: 2922 return ACC_plusOne; 2923 2924 default: 2925 // Otherwise, treat it as +0. 2926 return ACC_plusZero; 2927 } 2928 } 2929 }; 2930 } 2931 2932 bool Sema::isKnownName(StringRef name) { 2933 if (name.empty()) 2934 return false; 2935 LookupResult R(*this, &Context.Idents.get(name), SourceLocation(), 2936 Sema::LookupOrdinaryName); 2937 return LookupName(R, TUScope, false); 2938 } 2939 2940 static void addFixitForObjCARCConversion(Sema &S, 2941 DiagnosticBuilder &DiagB, 2942 Sema::CheckedConversionKind CCK, 2943 SourceLocation afterLParen, 2944 QualType castType, 2945 Expr *castExpr, 2946 Expr *realCast, 2947 const char *bridgeKeyword, 2948 const char *CFBridgeName) { 2949 // We handle C-style and implicit casts here. 2950 switch (CCK) { 2951 case Sema::CCK_ImplicitConversion: 2952 case Sema::CCK_CStyleCast: 2953 case Sema::CCK_OtherCast: 2954 break; 2955 case Sema::CCK_FunctionalCast: 2956 return; 2957 } 2958 2959 if (CFBridgeName) { 2960 if (CCK == Sema::CCK_OtherCast) { 2961 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) { 2962 SourceRange range(NCE->getOperatorLoc(), 2963 NCE->getAngleBrackets().getEnd()); 2964 SmallString<32> BridgeCall; 2965 2966 SourceManager &SM = S.getSourceManager(); 2967 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1)); 2968 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts())) 2969 BridgeCall += ' '; 2970 2971 BridgeCall += CFBridgeName; 2972 DiagB.AddFixItHint(FixItHint::CreateReplacement(range, BridgeCall)); 2973 } 2974 return; 2975 } 2976 Expr *castedE = castExpr; 2977 if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(castedE)) 2978 castedE = CCE->getSubExpr(); 2979 castedE = castedE->IgnoreImpCasts(); 2980 SourceRange range = castedE->getSourceRange(); 2981 2982 SmallString<32> BridgeCall; 2983 2984 SourceManager &SM = S.getSourceManager(); 2985 char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1)); 2986 if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts())) 2987 BridgeCall += ' '; 2988 2989 BridgeCall += CFBridgeName; 2990 2991 if (isa<ParenExpr>(castedE)) { 2992 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(), 2993 BridgeCall)); 2994 } else { 2995 BridgeCall += '('; 2996 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(), 2997 BridgeCall)); 2998 DiagB.AddFixItHint(FixItHint::CreateInsertion( 2999 S.PP.getLocForEndOfToken(range.getEnd()), 3000 ")")); 3001 } 3002 return; 3003 } 3004 3005 if (CCK == Sema::CCK_CStyleCast) { 3006 DiagB.AddFixItHint(FixItHint::CreateInsertion(afterLParen, bridgeKeyword)); 3007 } else if (CCK == Sema::CCK_OtherCast) { 3008 if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) { 3009 std::string castCode = "("; 3010 castCode += bridgeKeyword; 3011 castCode += castType.getAsString(); 3012 castCode += ")"; 3013 SourceRange Range(NCE->getOperatorLoc(), 3014 NCE->getAngleBrackets().getEnd()); 3015 DiagB.AddFixItHint(FixItHint::CreateReplacement(Range, castCode)); 3016 } 3017 } else { 3018 std::string castCode = "("; 3019 castCode += bridgeKeyword; 3020 castCode += castType.getAsString(); 3021 castCode += ")"; 3022 Expr *castedE = castExpr->IgnoreImpCasts(); 3023 SourceRange range = castedE->getSourceRange(); 3024 if (isa<ParenExpr>(castedE)) { 3025 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(), 3026 castCode)); 3027 } else { 3028 castCode += "("; 3029 DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(), 3030 castCode)); 3031 DiagB.AddFixItHint(FixItHint::CreateInsertion( 3032 S.PP.getLocForEndOfToken(range.getEnd()), 3033 ")")); 3034 } 3035 } 3036 } 3037 3038 static void 3039 diagnoseObjCARCConversion(Sema &S, SourceRange castRange, 3040 QualType castType, ARCConversionTypeClass castACTC, 3041 Expr *castExpr, Expr *realCast, 3042 ARCConversionTypeClass exprACTC, 3043 Sema::CheckedConversionKind CCK) { 3044 SourceLocation loc = 3045 (castRange.isValid() ? castRange.getBegin() : castExpr->getExprLoc()); 3046 3047 if (S.makeUnavailableInSystemHeader(loc, 3048 "converts between Objective-C and C pointers in -fobjc-arc")) 3049 return; 3050 3051 QualType castExprType = castExpr->getType(); 3052 3053 unsigned srcKind = 0; 3054 switch (exprACTC) { 3055 case ACTC_none: 3056 case ACTC_coreFoundation: 3057 case ACTC_voidPtr: 3058 srcKind = (castExprType->isPointerType() ? 1 : 0); 3059 break; 3060 case ACTC_retainable: 3061 srcKind = (castExprType->isBlockPointerType() ? 2 : 3); 3062 break; 3063 case ACTC_indirectRetainable: 3064 srcKind = 4; 3065 break; 3066 } 3067 3068 // Check whether this could be fixed with a bridge cast. 3069 SourceLocation afterLParen = S.PP.getLocForEndOfToken(castRange.getBegin()); 3070 SourceLocation noteLoc = afterLParen.isValid() ? afterLParen : loc; 3071 3072 // Bridge from an ARC type to a CF type. 3073 if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) { 3074 3075 S.Diag(loc, diag::err_arc_cast_requires_bridge) 3076 << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit 3077 << 2 // of C pointer type 3078 << castExprType 3079 << unsigned(castType->isBlockPointerType()) // to ObjC|block type 3080 << castType 3081 << castRange 3082 << castExpr->getSourceRange(); 3083 bool br = S.isKnownName("CFBridgingRelease"); 3084 ACCResult CreateRule = 3085 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr); 3086 assert(CreateRule != ACC_bottom && "This cast should already be accepted."); 3087 if (CreateRule != ACC_plusOne) 3088 { 3089 DiagnosticBuilder DiagB = 3090 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge) 3091 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge); 3092 3093 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen, 3094 castType, castExpr, realCast, "__bridge ", 0); 3095 } 3096 if (CreateRule != ACC_plusZero) 3097 { 3098 DiagnosticBuilder DiagB = 3099 (CCK == Sema::CCK_OtherCast && !br) ? 3100 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_transfer) << castExprType : 3101 S.Diag(br ? castExpr->getExprLoc() : noteLoc, 3102 diag::note_arc_bridge_transfer) 3103 << castExprType << br; 3104 3105 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen, 3106 castType, castExpr, realCast, "__bridge_transfer ", 3107 br ? "CFBridgingRelease" : 0); 3108 } 3109 3110 return; 3111 } 3112 3113 // Bridge from a CF type to an ARC type. 3114 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) { 3115 bool br = S.isKnownName("CFBridgingRetain"); 3116 S.Diag(loc, diag::err_arc_cast_requires_bridge) 3117 << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit 3118 << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type 3119 << castExprType 3120 << 2 // to C pointer type 3121 << castType 3122 << castRange 3123 << castExpr->getSourceRange(); 3124 ACCResult CreateRule = 3125 ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr); 3126 assert(CreateRule != ACC_bottom && "This cast should already be accepted."); 3127 if (CreateRule != ACC_plusOne) 3128 { 3129 DiagnosticBuilder DiagB = 3130 (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge) 3131 : S.Diag(noteLoc, diag::note_arc_cstyle_bridge); 3132 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen, 3133 castType, castExpr, realCast, "__bridge ", 0); 3134 } 3135 if (CreateRule != ACC_plusZero) 3136 { 3137 DiagnosticBuilder DiagB = 3138 (CCK == Sema::CCK_OtherCast && !br) ? 3139 S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained) << castType : 3140 S.Diag(br ? castExpr->getExprLoc() : noteLoc, 3141 diag::note_arc_bridge_retained) 3142 << castType << br; 3143 3144 addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen, 3145 castType, castExpr, realCast, "__bridge_retained ", 3146 br ? "CFBridgingRetain" : 0); 3147 } 3148 3149 return; 3150 } 3151 3152 S.Diag(loc, diag::err_arc_mismatched_cast) 3153 << (CCK != Sema::CCK_ImplicitConversion) 3154 << srcKind << castExprType << castType 3155 << castRange << castExpr->getSourceRange(); 3156 } 3157 3158 Sema::ARCConversionResult 3159 Sema::CheckObjCARCConversion(SourceRange castRange, QualType castType, 3160 Expr *&castExpr, CheckedConversionKind CCK, 3161 bool DiagnoseCFAudited) { 3162 QualType castExprType = castExpr->getType(); 3163 3164 // For the purposes of the classification, we assume reference types 3165 // will bind to temporaries. 3166 QualType effCastType = castType; 3167 if (const ReferenceType *ref = castType->getAs<ReferenceType>()) 3168 effCastType = ref->getPointeeType(); 3169 3170 ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExprType); 3171 ARCConversionTypeClass castACTC = classifyTypeForARCConversion(effCastType); 3172 if (exprACTC == castACTC) { 3173 // check for viablity and report error if casting an rvalue to a 3174 // life-time qualifier. 3175 if ((castACTC == ACTC_retainable) && 3176 (CCK == CCK_CStyleCast || CCK == CCK_OtherCast) && 3177 (castType != castExprType)) { 3178 const Type *DT = castType.getTypePtr(); 3179 QualType QDT = castType; 3180 // We desugar some types but not others. We ignore those 3181 // that cannot happen in a cast; i.e. auto, and those which 3182 // should not be de-sugared; i.e typedef. 3183 if (const ParenType *PT = dyn_cast<ParenType>(DT)) 3184 QDT = PT->desugar(); 3185 else if (const TypeOfType *TP = dyn_cast<TypeOfType>(DT)) 3186 QDT = TP->desugar(); 3187 else if (const AttributedType *AT = dyn_cast<AttributedType>(DT)) 3188 QDT = AT->desugar(); 3189 if (QDT != castType && 3190 QDT.getObjCLifetime() != Qualifiers::OCL_None) { 3191 SourceLocation loc = 3192 (castRange.isValid() ? castRange.getBegin() 3193 : castExpr->getExprLoc()); 3194 Diag(loc, diag::err_arc_nolifetime_behavior); 3195 } 3196 } 3197 return ACR_okay; 3198 } 3199 3200 if (isAnyCLike(exprACTC) && isAnyCLike(castACTC)) return ACR_okay; 3201 3202 // Allow all of these types to be cast to integer types (but not 3203 // vice-versa). 3204 if (castACTC == ACTC_none && castType->isIntegralType(Context)) 3205 return ACR_okay; 3206 3207 // Allow casts between pointers to lifetime types (e.g., __strong id*) 3208 // and pointers to void (e.g., cv void *). Casting from void* to lifetime* 3209 // must be explicit. 3210 if (exprACTC == ACTC_indirectRetainable && castACTC == ACTC_voidPtr) 3211 return ACR_okay; 3212 if (castACTC == ACTC_indirectRetainable && exprACTC == ACTC_voidPtr && 3213 CCK != CCK_ImplicitConversion) 3214 return ACR_okay; 3215 3216 switch (ARCCastChecker(Context, exprACTC, castACTC, false).Visit(castExpr)) { 3217 // For invalid casts, fall through. 3218 case ACC_invalid: 3219 break; 3220 3221 // Do nothing for both bottom and +0. 3222 case ACC_bottom: 3223 case ACC_plusZero: 3224 return ACR_okay; 3225 3226 // If the result is +1, consume it here. 3227 case ACC_plusOne: 3228 castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(), 3229 CK_ARCConsumeObject, castExpr, 3230 0, VK_RValue); 3231 ExprNeedsCleanups = true; 3232 return ACR_okay; 3233 } 3234 3235 // If this is a non-implicit cast from id or block type to a 3236 // CoreFoundation type, delay complaining in case the cast is used 3237 // in an acceptable context. 3238 if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC) && 3239 CCK != CCK_ImplicitConversion) 3240 return ACR_unbridged; 3241 3242 // Do not issue "bridge cast" diagnostic when implicit casting 3243 // a retainable object to a CF type parameter belonging to an audited 3244 // CF API function. Let caller issue a normal type mismatched diagnostic 3245 // instead. 3246 if (!DiagnoseCFAudited || exprACTC != ACTC_retainable || 3247 castACTC != ACTC_coreFoundation) 3248 diagnoseObjCARCConversion(*this, castRange, castType, castACTC, 3249 castExpr, castExpr, exprACTC, CCK); 3250 return ACR_okay; 3251 } 3252 3253 /// Given that we saw an expression with the ARCUnbridgedCastTy 3254 /// placeholder type, complain bitterly. 3255 void Sema::diagnoseARCUnbridgedCast(Expr *e) { 3256 // We expect the spurious ImplicitCastExpr to already have been stripped. 3257 assert(!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)); 3258 CastExpr *realCast = cast<CastExpr>(e->IgnoreParens()); 3259 3260 SourceRange castRange; 3261 QualType castType; 3262 CheckedConversionKind CCK; 3263 3264 if (CStyleCastExpr *cast = dyn_cast<CStyleCastExpr>(realCast)) { 3265 castRange = SourceRange(cast->getLParenLoc(), cast->getRParenLoc()); 3266 castType = cast->getTypeAsWritten(); 3267 CCK = CCK_CStyleCast; 3268 } else if (ExplicitCastExpr *cast = dyn_cast<ExplicitCastExpr>(realCast)) { 3269 castRange = cast->getTypeInfoAsWritten()->getTypeLoc().getSourceRange(); 3270 castType = cast->getTypeAsWritten(); 3271 CCK = CCK_OtherCast; 3272 } else { 3273 castType = cast->getType(); 3274 CCK = CCK_ImplicitConversion; 3275 } 3276 3277 ARCConversionTypeClass castACTC = 3278 classifyTypeForARCConversion(castType.getNonReferenceType()); 3279 3280 Expr *castExpr = realCast->getSubExpr(); 3281 assert(classifyTypeForARCConversion(castExpr->getType()) == ACTC_retainable); 3282 3283 diagnoseObjCARCConversion(*this, castRange, castType, castACTC, 3284 castExpr, realCast, ACTC_retainable, CCK); 3285 } 3286 3287 /// stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast 3288 /// type, remove the placeholder cast. 3289 Expr *Sema::stripARCUnbridgedCast(Expr *e) { 3290 assert(e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)); 3291 3292 if (ParenExpr *pe = dyn_cast<ParenExpr>(e)) { 3293 Expr *sub = stripARCUnbridgedCast(pe->getSubExpr()); 3294 return new (Context) ParenExpr(pe->getLParen(), pe->getRParen(), sub); 3295 } else if (UnaryOperator *uo = dyn_cast<UnaryOperator>(e)) { 3296 assert(uo->getOpcode() == UO_Extension); 3297 Expr *sub = stripARCUnbridgedCast(uo->getSubExpr()); 3298 return new (Context) UnaryOperator(sub, UO_Extension, sub->getType(), 3299 sub->getValueKind(), sub->getObjectKind(), 3300 uo->getOperatorLoc()); 3301 } else if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) { 3302 assert(!gse->isResultDependent()); 3303 3304 unsigned n = gse->getNumAssocs(); 3305 SmallVector<Expr*, 4> subExprs(n); 3306 SmallVector<TypeSourceInfo*, 4> subTypes(n); 3307 for (unsigned i = 0; i != n; ++i) { 3308 subTypes[i] = gse->getAssocTypeSourceInfo(i); 3309 Expr *sub = gse->getAssocExpr(i); 3310 if (i == gse->getResultIndex()) 3311 sub = stripARCUnbridgedCast(sub); 3312 subExprs[i] = sub; 3313 } 3314 3315 return new (Context) GenericSelectionExpr(Context, gse->getGenericLoc(), 3316 gse->getControllingExpr(), 3317 subTypes, subExprs, 3318 gse->getDefaultLoc(), 3319 gse->getRParenLoc(), 3320 gse->containsUnexpandedParameterPack(), 3321 gse->getResultIndex()); 3322 } else { 3323 assert(isa<ImplicitCastExpr>(e) && "bad form of unbridged cast!"); 3324 return cast<ImplicitCastExpr>(e)->getSubExpr(); 3325 } 3326 } 3327 3328 bool Sema::CheckObjCARCUnavailableWeakConversion(QualType castType, 3329 QualType exprType) { 3330 QualType canCastType = 3331 Context.getCanonicalType(castType).getUnqualifiedType(); 3332 QualType canExprType = 3333 Context.getCanonicalType(exprType).getUnqualifiedType(); 3334 if (isa<ObjCObjectPointerType>(canCastType) && 3335 castType.getObjCLifetime() == Qualifiers::OCL_Weak && 3336 canExprType->isObjCObjectPointerType()) { 3337 if (const ObjCObjectPointerType *ObjT = 3338 canExprType->getAs<ObjCObjectPointerType>()) 3339 if (const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl()) 3340 return !ObjI->isArcWeakrefUnavailable(); 3341 } 3342 return true; 3343 } 3344 3345 /// Look for an ObjCReclaimReturnedObject cast and destroy it. 3346 static Expr *maybeUndoReclaimObject(Expr *e) { 3347 // For now, we just undo operands that are *immediately* reclaim 3348 // expressions, which prevents the vast majority of potential 3349 // problems here. To catch them all, we'd need to rebuild arbitrary 3350 // value-propagating subexpressions --- we can't reliably rebuild 3351 // in-place because of expression sharing. 3352 if (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e)) 3353 if (ice->getCastKind() == CK_ARCReclaimReturnedObject) 3354 return ice->getSubExpr(); 3355 3356 return e; 3357 } 3358 3359 ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, 3360 ObjCBridgeCastKind Kind, 3361 SourceLocation BridgeKeywordLoc, 3362 TypeSourceInfo *TSInfo, 3363 Expr *SubExpr) { 3364 ExprResult SubResult = UsualUnaryConversions(SubExpr); 3365 if (SubResult.isInvalid()) return ExprError(); 3366 SubExpr = SubResult.take(); 3367 3368 QualType T = TSInfo->getType(); 3369 QualType FromType = SubExpr->getType(); 3370 3371 CastKind CK; 3372 3373 bool MustConsume = false; 3374 if (T->isDependentType() || SubExpr->isTypeDependent()) { 3375 // Okay: we'll build a dependent expression type. 3376 CK = CK_Dependent; 3377 } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) { 3378 // Casting CF -> id 3379 CK = (T->isBlockPointerType() ? CK_AnyPointerToBlockPointerCast 3380 : CK_CPointerToObjCPointerCast); 3381 switch (Kind) { 3382 case OBC_Bridge: 3383 break; 3384 3385 case OBC_BridgeRetained: { 3386 bool br = isKnownName("CFBridgingRelease"); 3387 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind) 3388 << 2 3389 << FromType 3390 << (T->isBlockPointerType()? 1 : 0) 3391 << T 3392 << SubExpr->getSourceRange() 3393 << Kind; 3394 Diag(BridgeKeywordLoc, diag::note_arc_bridge) 3395 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge"); 3396 Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer) 3397 << FromType << br 3398 << FixItHint::CreateReplacement(BridgeKeywordLoc, 3399 br ? "CFBridgingRelease " 3400 : "__bridge_transfer "); 3401 3402 Kind = OBC_Bridge; 3403 break; 3404 } 3405 3406 case OBC_BridgeTransfer: 3407 // We must consume the Objective-C object produced by the cast. 3408 MustConsume = true; 3409 break; 3410 } 3411 } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) { 3412 // Okay: id -> CF 3413 CK = CK_BitCast; 3414 switch (Kind) { 3415 case OBC_Bridge: 3416 // Reclaiming a value that's going to be __bridge-casted to CF 3417 // is very dangerous, so we don't do it. 3418 SubExpr = maybeUndoReclaimObject(SubExpr); 3419 break; 3420 3421 case OBC_BridgeRetained: 3422 // Produce the object before casting it. 3423 SubExpr = ImplicitCastExpr::Create(Context, FromType, 3424 CK_ARCProduceObject, 3425 SubExpr, 0, VK_RValue); 3426 break; 3427 3428 case OBC_BridgeTransfer: { 3429 bool br = isKnownName("CFBridgingRetain"); 3430 Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind) 3431 << (FromType->isBlockPointerType()? 1 : 0) 3432 << FromType 3433 << 2 3434 << T 3435 << SubExpr->getSourceRange() 3436 << Kind; 3437 3438 Diag(BridgeKeywordLoc, diag::note_arc_bridge) 3439 << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge "); 3440 Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained) 3441 << T << br 3442 << FixItHint::CreateReplacement(BridgeKeywordLoc, 3443 br ? "CFBridgingRetain " : "__bridge_retained"); 3444 3445 Kind = OBC_Bridge; 3446 break; 3447 } 3448 } 3449 } else { 3450 Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible) 3451 << FromType << T << Kind 3452 << SubExpr->getSourceRange() 3453 << TSInfo->getTypeLoc().getSourceRange(); 3454 return ExprError(); 3455 } 3456 3457 Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK, 3458 BridgeKeywordLoc, 3459 TSInfo, SubExpr); 3460 3461 if (MustConsume) { 3462 ExprNeedsCleanups = true; 3463 Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result, 3464 0, VK_RValue); 3465 } 3466 3467 return Result; 3468 } 3469 3470 ExprResult Sema::ActOnObjCBridgedCast(Scope *S, 3471 SourceLocation LParenLoc, 3472 ObjCBridgeCastKind Kind, 3473 SourceLocation BridgeKeywordLoc, 3474 ParsedType Type, 3475 SourceLocation RParenLoc, 3476 Expr *SubExpr) { 3477 TypeSourceInfo *TSInfo = 0; 3478 QualType T = GetTypeFromParser(Type, &TSInfo); 3479 if (!TSInfo) 3480 TSInfo = Context.getTrivialTypeSourceInfo(T, LParenLoc); 3481 return BuildObjCBridgedCast(LParenLoc, Kind, BridgeKeywordLoc, TSInfo, 3482 SubExpr); 3483 } 3484