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