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