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