SemaExprObjC.cpp revision 83418529244038b34ae9990b4cf6ac0a92f8c741
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 "Sema.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/AST/ExprObjC.h" 18#include "llvm/ADT/SmallString.h" 19#include "clang/Lex/Preprocessor.h" 20 21using namespace clang; 22 23Sema::ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs, 24 ExprTy **strings, 25 unsigned NumStrings) { 26 StringLiteral **Strings = reinterpret_cast<StringLiteral**>(strings); 27 28 // Most ObjC strings are formed out of a single piece. However, we *can* 29 // have strings formed out of multiple @ strings with multiple pptokens in 30 // each one, e.g. @"foo" "bar" @"baz" "qux" which need to be turned into one 31 // StringLiteral for ObjCStringLiteral to hold onto. 32 StringLiteral *S = Strings[0]; 33 34 // If we have a multi-part string, merge it all together. 35 if (NumStrings != 1) { 36 // Concatenate objc strings. 37 llvm::SmallString<128> StrBuf; 38 llvm::SmallVector<SourceLocation, 8> StrLocs; 39 40 for (unsigned i = 0; i != NumStrings; ++i) { 41 S = Strings[i]; 42 43 // ObjC strings can't be wide. 44 if (S->isWide()) { 45 Diag(S->getLocStart(), diag::err_cfstring_literal_not_string_constant) 46 << S->getSourceRange(); 47 return true; 48 } 49 50 // Get the string data. 51 StrBuf.append(S->getStrData(), S->getStrData()+S->getByteLength()); 52 53 // Get the locations of the string tokens. 54 StrLocs.append(S->tokloc_begin(), S->tokloc_end()); 55 56 // Free the temporary string. 57 S->Destroy(Context); 58 } 59 60 // Create the aggregate string with the appropriate content and location 61 // information. 62 S = StringLiteral::Create(Context, &StrBuf[0], StrBuf.size(), false, 63 Context.getPointerType(Context.CharTy), 64 &StrLocs[0], StrLocs.size()); 65 } 66 67 // Verify that this composite string is acceptable for ObjC strings. 68 if (CheckObjCString(S)) 69 return true; 70 71 // Initialize the constant string interface lazily. This assumes 72 // the NSString interface is seen in this translation unit. Note: We 73 // don't use NSConstantString, since the runtime team considers this 74 // interface private (even though it appears in the header files). 75 QualType Ty = Context.getObjCConstantStringInterface(); 76 if (!Ty.isNull()) { 77 Ty = Context.getPointerType(Ty); 78 } else { 79 IdentifierInfo *NSIdent = &Context.Idents.get("NSString"); 80 NamedDecl *IF = LookupName(TUScope, NSIdent, LookupOrdinaryName); 81 if (ObjCInterfaceDecl *StrIF = dyn_cast_or_null<ObjCInterfaceDecl>(IF)) { 82 Context.setObjCConstantStringInterface(StrIF); 83 Ty = Context.getObjCConstantStringInterface(); 84 Ty = Context.getPointerType(Ty); 85 } else { 86 // If there is no NSString interface defined then treat constant 87 // strings as untyped objects and let the runtime figure it out later. 88 Ty = Context.getObjCIdType(); 89 } 90 } 91 92 return new (Context) ObjCStringLiteral(S, Ty, AtLocs[0]); 93} 94 95Sema::ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc, 96 SourceLocation EncodeLoc, 97 SourceLocation LParenLoc, 98 TypeTy *ty, 99 SourceLocation RParenLoc) { 100 QualType EncodedType = QualType::getFromOpaquePtr(ty); 101 102 std::string Str; 103 Context.getObjCEncodingForType(EncodedType, Str); 104 105 // The type of @encode is the same as the type of the corresponding string, 106 // which is an array type. 107 QualType StrTy = Context.CharTy; 108 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 109 if (getLangOptions().CPlusPlus) 110 StrTy.addConst(); 111 StrTy = Context.getConstantArrayType(StrTy, llvm::APInt(32, Str.size()+1), 112 ArrayType::Normal, 0); 113 114 return new (Context) ObjCEncodeExpr(StrTy, EncodedType, AtLoc, RParenLoc); 115} 116 117Sema::ExprResult Sema::ParseObjCSelectorExpression(Selector Sel, 118 SourceLocation AtLoc, 119 SourceLocation SelLoc, 120 SourceLocation LParenLoc, 121 SourceLocation RParenLoc) { 122 QualType Ty = Context.getObjCSelType(); 123 return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc); 124} 125 126Sema::ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId, 127 SourceLocation AtLoc, 128 SourceLocation ProtoLoc, 129 SourceLocation LParenLoc, 130 SourceLocation RParenLoc) { 131 ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId); 132 if (!PDecl) { 133 Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId; 134 return true; 135 } 136 137 QualType Ty = Context.getObjCProtoType(); 138 if (Ty.isNull()) 139 return true; 140 Ty = Context.getPointerType(Ty); 141 return new (Context) ObjCProtocolExpr(Ty, PDecl, AtLoc, RParenLoc); 142} 143 144bool Sema::CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs, 145 Selector Sel, ObjCMethodDecl *Method, 146 bool isClassMessage, 147 SourceLocation lbrac, SourceLocation rbrac, 148 QualType &ReturnType) { 149 if (!Method) { 150 // Apply default argument promotion as for (C99 6.5.2.2p6). 151 for (unsigned i = 0; i != NumArgs; i++) 152 DefaultArgumentPromotion(Args[i]); 153 154 unsigned DiagID = isClassMessage ? diag::warn_class_method_not_found : 155 diag::warn_inst_method_not_found; 156 Diag(lbrac, DiagID) 157 << Sel << isClassMessage << SourceRange(lbrac, rbrac); 158 ReturnType = Context.getObjCIdType(); 159 return false; 160 } 161 162 ReturnType = Method->getResultType(); 163 164 unsigned NumNamedArgs = Sel.getNumArgs(); 165 assert(NumArgs >= NumNamedArgs && "Too few arguments for selector!"); 166 167 bool IsError = false; 168 for (unsigned i = 0; i < NumNamedArgs; i++) { 169 Expr *argExpr = Args[i]; 170 assert(argExpr && "CheckMessageArgumentTypes(): missing expression"); 171 172 QualType lhsType = Method->param_begin()[i]->getType(); 173 QualType rhsType = argExpr->getType(); 174 175 // If necessary, apply function/array conversion. C99 6.7.5.3p[7,8]. 176 if (lhsType->isArrayType()) 177 lhsType = Context.getArrayDecayedType(lhsType); 178 else if (lhsType->isFunctionType()) 179 lhsType = Context.getPointerType(lhsType); 180 181 AssignConvertType Result = 182 CheckSingleAssignmentConstraints(lhsType, argExpr); 183 if (Args[i] != argExpr) // The expression was converted. 184 Args[i] = argExpr; // Make sure we store the converted expression. 185 186 IsError |= 187 DiagnoseAssignmentResult(Result, argExpr->getLocStart(), lhsType, rhsType, 188 argExpr, "sending"); 189 } 190 191 // Promote additional arguments to variadic methods. 192 if (Method->isVariadic()) { 193 for (unsigned i = NumNamedArgs; i < NumArgs; ++i) 194 IsError |= DefaultVariadicArgumentPromotion(Args[i], VariadicMethod); 195 } else { 196 // Check for extra arguments to non-variadic methods. 197 if (NumArgs != NumNamedArgs) { 198 Diag(Args[NumNamedArgs]->getLocStart(), 199 diag::err_typecheck_call_too_many_args) 200 << 2 /*method*/ << Method->getSourceRange() 201 << SourceRange(Args[NumNamedArgs]->getLocStart(), 202 Args[NumArgs-1]->getLocEnd()); 203 } 204 } 205 206 return IsError; 207} 208 209bool Sema::isSelfExpr(Expr *RExpr) { 210 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(RExpr)) 211 if (DRE->getDecl()->getIdentifier() == &Context.Idents.get("self")) 212 return true; 213 return false; 214} 215 216// Helper method for ActOnClassMethod/ActOnInstanceMethod. 217// Will search "local" class/category implementations for a method decl. 218// If failed, then we search in class's root for an instance method. 219// Returns 0 if no method is found. 220ObjCMethodDecl *Sema::LookupPrivateClassMethod(Selector Sel, 221 ObjCInterfaceDecl *ClassDecl) { 222 ObjCMethodDecl *Method = 0; 223 // lookup in class and all superclasses 224 while (ClassDecl && !Method) { 225 if (ObjCImplementationDecl *ImpDecl 226 = LookupObjCImplementation(ClassDecl->getIdentifier())) 227 Method = ImpDecl->getClassMethod(Context, Sel); 228 229 // Look through local category implementations associated with the class. 230 if (!Method) { 231 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Method; i++) { 232 if (ObjCCategoryImpls[i]->getClassInterface() == ClassDecl) 233 Method = ObjCCategoryImpls[i]->getClassMethod(Context, Sel); 234 } 235 } 236 237 // Before we give up, check if the selector is an instance method. 238 // But only in the root. This matches gcc's behaviour and what the 239 // runtime expects. 240 if (!Method && !ClassDecl->getSuperClass()) { 241 Method = ClassDecl->lookupInstanceMethod(Context, Sel); 242 // Look through local category implementations associated 243 // with the root class. 244 if (!Method) 245 Method = LookupPrivateInstanceMethod(Sel, ClassDecl); 246 } 247 248 ClassDecl = ClassDecl->getSuperClass(); 249 } 250 return Method; 251} 252 253ObjCMethodDecl *Sema::LookupPrivateInstanceMethod(Selector Sel, 254 ObjCInterfaceDecl *ClassDecl) { 255 ObjCMethodDecl *Method = 0; 256 while (ClassDecl && !Method) { 257 // If we have implementations in scope, check "private" methods. 258 if (ObjCImplementationDecl *ImpDecl 259 = LookupObjCImplementation(ClassDecl->getIdentifier())) 260 Method = ImpDecl->getInstanceMethod(Context, Sel); 261 262 // Look through local category implementations associated with the class. 263 if (!Method) { 264 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Method; i++) { 265 if (ObjCCategoryImpls[i]->getClassInterface() == ClassDecl) 266 Method = ObjCCategoryImpls[i]->getInstanceMethod(Context, Sel); 267 } 268 } 269 ClassDecl = ClassDecl->getSuperClass(); 270 } 271 return Method; 272} 273 274Action::OwningExprResult Sema::ActOnClassPropertyRefExpr( 275 IdentifierInfo &receiverName, 276 IdentifierInfo &propertyName, 277 SourceLocation &receiverNameLoc, 278 SourceLocation &propertyNameLoc) { 279 280 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(&receiverName); 281 282 // Search for a declared property first. 283 284 Selector Sel = PP.getSelectorTable().getNullarySelector(&propertyName); 285 ObjCMethodDecl *Getter = IFace->lookupClassMethod(Context, Sel); 286 287 // If this reference is in an @implementation, check for 'private' methods. 288 if (!Getter) 289 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) 290 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) 291 if (ObjCImplementationDecl *ImpDecl 292 = LookupObjCImplementation(ClassDecl->getIdentifier())) 293 Getter = ImpDecl->getClassMethod(Context, Sel); 294 295 if (Getter) { 296 // FIXME: refactor/share with ActOnMemberReference(). 297 // Check if we can reference this property. 298 if (DiagnoseUseOfDecl(Getter, propertyNameLoc)) 299 return ExprError(); 300 } 301 302 // Look for the matching setter, in case it is needed. 303 Selector SetterSel = 304 SelectorTable::constructSetterName(PP.getIdentifierTable(), 305 PP.getSelectorTable(), &propertyName); 306 307 ObjCMethodDecl *Setter = IFace->lookupClassMethod(Context, SetterSel); 308 if (!Setter) { 309 // If this reference is in an @implementation, also check for 'private' 310 // methods. 311 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) 312 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) 313 if (ObjCImplementationDecl *ImpDecl 314 = LookupObjCImplementation(ClassDecl->getIdentifier())) 315 Setter = ImpDecl->getClassMethod(Context, SetterSel); 316 } 317 // Look through local category implementations associated with the class. 318 if (!Setter) { 319 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Setter; i++) { 320 if (ObjCCategoryImpls[i]->getClassInterface() == IFace) 321 Setter = ObjCCategoryImpls[i]->getClassMethod(Context, SetterSel); 322 } 323 } 324 325 if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc)) 326 return ExprError(); 327 328 if (Getter || Setter) { 329 QualType PType; 330 331 if (Getter) 332 PType = Getter->getResultType(); 333 else { 334 for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(), 335 E = Setter->param_end(); PI != E; ++PI) 336 PType = (*PI)->getType(); 337 } 338 return Owned(new (Context) ObjCKVCRefExpr(Getter, PType, Setter, 339 propertyNameLoc, IFace, receiverNameLoc)); 340 } 341 return ExprError(Diag(propertyNameLoc, diag::err_property_not_found) 342 << &propertyName << Context.getObjCInterfaceType(IFace)); 343} 344 345 346// ActOnClassMessage - used for both unary and keyword messages. 347// ArgExprs is optional - if it is present, the number of expressions 348// is obtained from Sel.getNumArgs(). 349Sema::ExprResult Sema::ActOnClassMessage( 350 Scope *S, 351 IdentifierInfo *receiverName, Selector Sel, 352 SourceLocation lbrac, SourceLocation receiverLoc, 353 SourceLocation selectorLoc, SourceLocation rbrac, 354 ExprTy **Args, unsigned NumArgs) 355{ 356 assert(receiverName && "missing receiver class name"); 357 358 Expr **ArgExprs = reinterpret_cast<Expr **>(Args); 359 ObjCInterfaceDecl* ClassDecl = 0; 360 bool isSuper = false; 361 362 if (receiverName->isStr("super")) { 363 if (getCurMethodDecl()) { 364 isSuper = true; 365 ObjCInterfaceDecl *OID = getCurMethodDecl()->getClassInterface(); 366 if (!OID) 367 return Diag(lbrac, diag::error_no_super_class_message) 368 << getCurMethodDecl()->getDeclName(); 369 ClassDecl = OID->getSuperClass(); 370 if (!ClassDecl) 371 return Diag(lbrac, diag::error_no_super_class) << OID->getDeclName(); 372 if (getCurMethodDecl()->isInstanceMethod()) { 373 QualType superTy = Context.getObjCInterfaceType(ClassDecl); 374 superTy = Context.getPointerType(superTy); 375 ExprResult ReceiverExpr = new (Context) ObjCSuperExpr(SourceLocation(), 376 superTy); 377 // We are really in an instance method, redirect. 378 return ActOnInstanceMessage(ReceiverExpr.get(), Sel, lbrac, 379 selectorLoc, rbrac, Args, NumArgs); 380 } 381 // We are sending a message to 'super' within a class method. Do nothing, 382 // the receiver will pass through as 'super' (how convenient:-). 383 } else { 384 // 'super' has been used outside a method context. If a variable named 385 // 'super' has been declared, redirect. If not, produce a diagnostic. 386 NamedDecl *SuperDecl = LookupName(S, receiverName, LookupOrdinaryName); 387 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(SuperDecl); 388 if (VD) { 389 ExprResult ReceiverExpr = new (Context) DeclRefExpr(VD, VD->getType(), 390 receiverLoc); 391 // We are really in an instance method, redirect. 392 return ActOnInstanceMessage(ReceiverExpr.get(), Sel, lbrac, 393 selectorLoc, rbrac, Args, NumArgs); 394 } 395 return Diag(receiverLoc, diag::err_undeclared_var_use) << receiverName; 396 } 397 } else 398 ClassDecl = getObjCInterfaceDecl(receiverName); 399 400 // The following code allows for the following GCC-ism: 401 // 402 // typedef XCElementDisplayRect XCElementGraphicsRect; 403 // 404 // @implementation XCRASlice 405 // - whatever { // Note that XCElementGraphicsRect is a typedef name. 406 // _sGraphicsDelegate =[[XCElementGraphicsRect alloc] init]; 407 // } 408 // 409 // If necessary, the following lookup could move to getObjCInterfaceDecl(). 410 if (!ClassDecl) { 411 NamedDecl *IDecl = LookupName(TUScope, receiverName, LookupOrdinaryName); 412 if (TypedefDecl *OCTD = dyn_cast_or_null<TypedefDecl>(IDecl)) { 413 const ObjCInterfaceType *OCIT; 414 OCIT = OCTD->getUnderlyingType()->getAsObjCInterfaceType(); 415 if (!OCIT) { 416 Diag(receiverLoc, diag::err_invalid_receiver_to_message); 417 return true; 418 } 419 ClassDecl = OCIT->getDecl(); 420 } 421 } 422 assert(ClassDecl && "missing interface declaration"); 423 ObjCMethodDecl *Method = 0; 424 QualType returnType; 425 if (ClassDecl->isForwardDecl()) { 426 // A forward class used in messaging is tread as a 'Class' 427 Diag(lbrac, diag::warn_receiver_forward_class) << ClassDecl->getDeclName(); 428 Method = LookupFactoryMethodInGlobalPool(Sel, SourceRange(lbrac,rbrac)); 429 if (Method) 430 Diag(Method->getLocation(), diag::note_method_sent_forward_class) 431 << Method->getDeclName(); 432 } 433 if (!Method) 434 Method = ClassDecl->lookupClassMethod(Context, Sel); 435 436 // If we have an implementation in scope, check "private" methods. 437 if (!Method) 438 Method = LookupPrivateClassMethod(Sel, ClassDecl); 439 440 if (Method && DiagnoseUseOfDecl(Method, receiverLoc)) 441 return true; 442 443 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, true, 444 lbrac, rbrac, returnType)) 445 return true; 446 447 returnType = returnType.getNonReferenceType(); 448 449 // If we have the ObjCInterfaceDecl* for the class that is receiving the 450 // message, use that to construct the ObjCMessageExpr. Otherwise pass on the 451 // IdentifierInfo* for the class. 452 // FIXME: need to do a better job handling 'super' usage within a class. For 453 // now, we simply pass the "super" identifier through (which isn't consistent 454 // with instance methods. 455 if (isSuper) 456 return new (Context) ObjCMessageExpr(receiverName, Sel, returnType, Method, 457 lbrac, rbrac, ArgExprs, NumArgs); 458 else 459 return new (Context) ObjCMessageExpr(ClassDecl, Sel, returnType, Method, 460 lbrac, rbrac, ArgExprs, NumArgs); 461} 462 463// ActOnInstanceMessage - used for both unary and keyword messages. 464// ArgExprs is optional - if it is present, the number of expressions 465// is obtained from Sel.getNumArgs(). 466Sema::ExprResult Sema::ActOnInstanceMessage(ExprTy *receiver, Selector Sel, 467 SourceLocation lbrac, 468 SourceLocation receiverLoc, 469 SourceLocation rbrac, 470 ExprTy **Args, unsigned NumArgs) { 471 assert(receiver && "missing receiver expression"); 472 473 Expr **ArgExprs = reinterpret_cast<Expr **>(Args); 474 Expr *RExpr = static_cast<Expr *>(receiver); 475 476 // If necessary, apply function/array conversion to the receiver. 477 // C99 6.7.5.3p[7,8]. 478 DefaultFunctionArrayConversion(RExpr); 479 480 QualType returnType; 481 QualType ReceiverCType = 482 Context.getCanonicalType(RExpr->getType()).getUnqualifiedType(); 483 484 // Handle messages to 'super'. 485 if (isa<ObjCSuperExpr>(RExpr)) { 486 ObjCMethodDecl *Method = 0; 487 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) { 488 // If we have an interface in scope, check 'super' methods. 489 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) 490 if (ObjCInterfaceDecl *SuperDecl = ClassDecl->getSuperClass()) { 491 Method = SuperDecl->lookupInstanceMethod(Context, Sel); 492 493 if (!Method) 494 // If we have implementations in scope, check "private" methods. 495 Method = LookupPrivateInstanceMethod(Sel, SuperDecl); 496 } 497 } 498 499 if (Method && DiagnoseUseOfDecl(Method, receiverLoc)) 500 return true; 501 502 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, false, 503 lbrac, rbrac, returnType)) 504 return true; 505 506 returnType = returnType.getNonReferenceType(); 507 return new (Context) ObjCMessageExpr(RExpr, Sel, returnType, Method, lbrac, 508 rbrac, ArgExprs, NumArgs); 509 } 510 511 // Handle messages to id. 512 if (ReceiverCType == Context.getCanonicalType(Context.getObjCIdType()) || 513 ReceiverCType->isBlockPointerType() || 514 Context.isObjCNSObjectType(RExpr->getType())) { 515 ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool( 516 Sel, SourceRange(lbrac,rbrac)); 517 if (!Method) 518 Method = LookupFactoryMethodInGlobalPool(Sel, SourceRange(lbrac, rbrac)); 519 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, false, 520 lbrac, rbrac, returnType)) 521 return true; 522 returnType = returnType.getNonReferenceType(); 523 return new (Context) ObjCMessageExpr(RExpr, Sel, returnType, Method, lbrac, 524 rbrac, ArgExprs, NumArgs); 525 } 526 527 // Handle messages to Class. 528 if (ReceiverCType == Context.getCanonicalType(Context.getObjCClassType())) { 529 ObjCMethodDecl *Method = 0; 530 531 if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) { 532 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) { 533 // First check the public methods in the class interface. 534 Method = ClassDecl->lookupClassMethod(Context, Sel); 535 536 if (!Method) 537 Method = LookupPrivateClassMethod(Sel, ClassDecl); 538 } 539 if (Method && DiagnoseUseOfDecl(Method, receiverLoc)) 540 return true; 541 } 542 if (!Method) { 543 // If not messaging 'self', look for any factory method named 'Sel'. 544 if (!isSelfExpr(RExpr)) { 545 Method = LookupFactoryMethodInGlobalPool(Sel, SourceRange(lbrac,rbrac)); 546 if (!Method) { 547 // If no class (factory) method was found, check if an _instance_ 548 // method of the same name exists in the root class only. 549 Method = LookupInstanceMethodInGlobalPool( 550 Sel, SourceRange(lbrac,rbrac)); 551 if (Method) 552 if (const ObjCInterfaceDecl *ID = 553 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) { 554 if (ID->getSuperClass()) 555 Diag(lbrac, diag::warn_root_inst_method_not_found) 556 << Sel << SourceRange(lbrac, rbrac); 557 } 558 } 559 } 560 } 561 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, false, 562 lbrac, rbrac, returnType)) 563 return true; 564 returnType = returnType.getNonReferenceType(); 565 return new (Context) ObjCMessageExpr(RExpr, Sel, returnType, Method, lbrac, 566 rbrac, ArgExprs, NumArgs); 567 } 568 569 ObjCMethodDecl *Method = 0; 570 ObjCInterfaceDecl* ClassDecl = 0; 571 572 // We allow sending a message to a qualified ID ("id<foo>"), which is ok as 573 // long as one of the protocols implements the selector (if not, warn). 574 if (ObjCQualifiedIdType *QIdTy = dyn_cast<ObjCQualifiedIdType>(ReceiverCType)) { 575 // Search protocols for instance methods. 576 for (ObjCQualifiedIdType::qual_iterator I = QIdTy->qual_begin(), 577 E = QIdTy->qual_end(); I != E; ++I) { 578 ObjCProtocolDecl *PDecl = *I; 579 if (PDecl && (Method = PDecl->lookupInstanceMethod(Context, Sel))) 580 break; 581 // Since we aren't supporting "Class<foo>", look for a class method. 582 if (PDecl && (Method = PDecl->lookupClassMethod(Context, Sel))) 583 break; 584 } 585 } else if (const ObjCInterfaceType *OCIType = 586 ReceiverCType->getAsPointerToObjCInterfaceType()) { 587 // We allow sending a message to a pointer to an interface (an object). 588 589 ClassDecl = OCIType->getDecl(); 590 // FIXME: consider using LookupInstanceMethodInGlobalPool, since it will be 591 // faster than the following method (which can do *many* linear searches). 592 // The idea is to add class info to InstanceMethodPool. 593 Method = ClassDecl->lookupInstanceMethod(Context, Sel); 594 595 if (!Method) { 596 // Search protocol qualifiers. 597 for (ObjCQualifiedInterfaceType::qual_iterator QI = OCIType->qual_begin(), 598 E = OCIType->qual_end(); QI != E; ++QI) { 599 if ((Method = (*QI)->lookupInstanceMethod(Context, Sel))) 600 break; 601 } 602 } 603 if (!Method) { 604 // If we have implementations in scope, check "private" methods. 605 Method = LookupPrivateInstanceMethod(Sel, ClassDecl); 606 607 if (!Method && !isSelfExpr(RExpr)) { 608 // If we still haven't found a method, look in the global pool. This 609 // behavior isn't very desirable, however we need it for GCC 610 // compatibility. FIXME: should we deviate?? 611 if (OCIType->qual_empty()) { 612 Method = LookupInstanceMethodInGlobalPool( 613 Sel, SourceRange(lbrac,rbrac)); 614 if (Method && !OCIType->getDecl()->isForwardDecl()) 615 Diag(lbrac, diag::warn_maynot_respond) 616 << OCIType->getDecl()->getIdentifier()->getName() << Sel; 617 } 618 } 619 } 620 if (Method && DiagnoseUseOfDecl(Method, receiverLoc)) 621 return true; 622 } else if (!Context.getObjCIdType().isNull() && 623 (ReceiverCType->isPointerType() || 624 (ReceiverCType->isIntegerType() && 625 ReceiverCType->isScalarType()))) { 626 // Implicitly convert integers and pointers to 'id' but emit a warning. 627 Diag(lbrac, diag::warn_bad_receiver_type) 628 << RExpr->getType() << RExpr->getSourceRange(); 629 ImpCastExprToType(RExpr, Context.getObjCIdType()); 630 } else { 631 // Reject other random receiver types (e.g. structs). 632 Diag(lbrac, diag::err_bad_receiver_type) 633 << RExpr->getType() << RExpr->getSourceRange(); 634 return true; 635 } 636 637 if (Method) 638 DiagnoseSentinelCalls(Method, receiverLoc, ArgExprs, NumArgs); 639 if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, false, 640 lbrac, rbrac, returnType)) 641 return true; 642 returnType = returnType.getNonReferenceType(); 643 return new (Context) ObjCMessageExpr(RExpr, Sel, returnType, Method, lbrac, 644 rbrac, ArgExprs, NumArgs); 645} 646 647//===----------------------------------------------------------------------===// 648// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's. 649//===----------------------------------------------------------------------===// 650 651/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the 652/// inheritance hierarchy of 'rProto'. 653static bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, 654 ObjCProtocolDecl *rProto) { 655 if (lProto == rProto) 656 return true; 657 for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(), 658 E = rProto->protocol_end(); PI != E; ++PI) 659 if (ProtocolCompatibleWithProtocol(lProto, *PI)) 660 return true; 661 return false; 662} 663 664/// ClassImplementsProtocol - Checks that 'lProto' protocol 665/// has been implemented in IDecl class, its super class or categories (if 666/// lookupCategory is true). 667static bool ClassImplementsProtocol(ObjCProtocolDecl *lProto, 668 ObjCInterfaceDecl *IDecl, 669 bool lookupCategory, 670 bool RHSIsQualifiedID = false) { 671 672 // 1st, look up the class. 673 const ObjCList<ObjCProtocolDecl> &Protocols = 674 IDecl->getReferencedProtocols(); 675 676 for (ObjCList<ObjCProtocolDecl>::iterator PI = Protocols.begin(), 677 E = Protocols.end(); PI != E; ++PI) { 678 if (ProtocolCompatibleWithProtocol(lProto, *PI)) 679 return true; 680 // This is dubious and is added to be compatible with gcc. In gcc, it is 681 // also allowed assigning a protocol-qualified 'id' type to a LHS object 682 // when protocol in qualified LHS is in list of protocols in the rhs 'id' 683 // object. This IMO, should be a bug. 684 // FIXME: Treat this as an extension, and flag this as an error when GCC 685 // extensions are not enabled. 686 if (RHSIsQualifiedID && ProtocolCompatibleWithProtocol(*PI, lProto)) 687 return true; 688 } 689 690 // 2nd, look up the category. 691 if (lookupCategory) 692 for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl; 693 CDecl = CDecl->getNextClassCategory()) { 694 for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(), 695 E = CDecl->protocol_end(); PI != E; ++PI) 696 if (ProtocolCompatibleWithProtocol(lProto, *PI)) 697 return true; 698 } 699 700 // 3rd, look up the super class(s) 701 if (IDecl->getSuperClass()) 702 return 703 ClassImplementsProtocol(lProto, IDecl->getSuperClass(), lookupCategory, 704 RHSIsQualifiedID); 705 706 return false; 707} 708 709/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...> 710/// return true if lhs's protocols conform to rhs's protocol; false 711/// otherwise. 712bool Sema::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) { 713 if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType()) 714 return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false); 715 return false; 716} 717 718/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an 719/// ObjCQualifiedIDType. 720/// FIXME: Move to ASTContext::typesAreCompatible() and friends. 721bool Sema::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs, 722 bool compare) { 723 // Allow id<P..> and an 'id' or void* type in all cases. 724 if (const PointerType *PT = lhs->getAsPointerType()) { 725 QualType PointeeTy = PT->getPointeeType(); 726 if (PointeeTy->isVoidType() || 727 Context.isObjCIdStructType(PointeeTy) || 728 Context.isObjCClassStructType(PointeeTy)) 729 return true; 730 } else if (const PointerType *PT = rhs->getAsPointerType()) { 731 QualType PointeeTy = PT->getPointeeType(); 732 if (PointeeTy->isVoidType() || 733 Context.isObjCIdStructType(PointeeTy) || 734 Context.isObjCClassStructType(PointeeTy)) 735 return true; 736 } 737 738 if (const ObjCQualifiedIdType *lhsQID = lhs->getAsObjCQualifiedIdType()) { 739 const ObjCQualifiedIdType *rhsQID = rhs->getAsObjCQualifiedIdType(); 740 const ObjCQualifiedInterfaceType *rhsQI = 0; 741 QualType rtype; 742 743 if (!rhsQID) { 744 // Not comparing two ObjCQualifiedIdType's? 745 if (!rhs->isPointerType()) return false; 746 747 rtype = rhs->getAsPointerType()->getPointeeType(); 748 rhsQI = rtype->getAsObjCQualifiedInterfaceType(); 749 if (rhsQI == 0) { 750 // If the RHS is a unqualified interface pointer "NSString*", 751 // make sure we check the class hierarchy. 752 if (const ObjCInterfaceType *IT = rtype->getAsObjCInterfaceType()) { 753 ObjCInterfaceDecl *rhsID = IT->getDecl(); 754 for (ObjCQualifiedIdType::qual_iterator I = lhsQID->qual_begin(), 755 E = lhsQID->qual_end(); I != E; ++I) { 756 // when comparing an id<P> on lhs with a static type on rhs, 757 // see if static class implements all of id's protocols, directly or 758 // through its super class and categories. 759 if (!ClassImplementsProtocol(*I, rhsID, true)) 760 return false; 761 } 762 return true; 763 } 764 } 765 } 766 767 ObjCQualifiedIdType::qual_iterator RHSProtoI, RHSProtoE; 768 if (rhsQI) { // We have a qualified interface (e.g. "NSObject<Proto> *"). 769 RHSProtoI = rhsQI->qual_begin(); 770 RHSProtoE = rhsQI->qual_end(); 771 } else if (rhsQID) { // We have a qualified id (e.g. "id<Proto> *"). 772 RHSProtoI = rhsQID->qual_begin(); 773 RHSProtoE = rhsQID->qual_end(); 774 } else { 775 return false; 776 } 777 778 for (ObjCQualifiedIdType::qual_iterator I = lhsQID->qual_begin(), 779 E = lhsQID->qual_end(); I != E; ++I) { 780 ObjCProtocolDecl *lhsProto = *I; 781 bool match = false; 782 783 // when comparing an id<P> on lhs with a static type on rhs, 784 // see if static class implements all of id's protocols, directly or 785 // through its super class and categories. 786 for (; RHSProtoI != RHSProtoE; ++RHSProtoI) { 787 ObjCProtocolDecl *rhsProto = *RHSProtoI; 788 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 789 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 790 match = true; 791 break; 792 } 793 } 794 if (rhsQI) { 795 // If the RHS is a qualified interface pointer "NSString<P>*", 796 // make sure we check the class hierarchy. 797 if (const ObjCInterfaceType *IT = rtype->getAsObjCInterfaceType()) { 798 ObjCInterfaceDecl *rhsID = IT->getDecl(); 799 for (ObjCQualifiedIdType::qual_iterator I = lhsQID->qual_begin(), 800 E = lhsQID->qual_end(); I != E; ++I) { 801 // when comparing an id<P> on lhs with a static type on rhs, 802 // see if static class implements all of id's protocols, directly or 803 // through its super class and categories. 804 if (ClassImplementsProtocol(*I, rhsID, true)) { 805 match = true; 806 break; 807 } 808 } 809 } 810 } 811 if (!match) 812 return false; 813 } 814 815 return true; 816 } 817 818 const ObjCQualifiedIdType *rhsQID = rhs->getAsObjCQualifiedIdType(); 819 assert(rhsQID && "One of the LHS/RHS should be id<x>"); 820 821 if (!lhs->isPointerType()) 822 return false; 823 824 QualType ltype = lhs->getAsPointerType()->getPointeeType(); 825 if (const ObjCQualifiedInterfaceType *lhsQI = 826 ltype->getAsObjCQualifiedInterfaceType()) { 827 ObjCQualifiedIdType::qual_iterator LHSProtoI = lhsQI->qual_begin(); 828 ObjCQualifiedIdType::qual_iterator LHSProtoE = lhsQI->qual_end(); 829 for (; LHSProtoI != LHSProtoE; ++LHSProtoI) { 830 bool match = false; 831 ObjCProtocolDecl *lhsProto = *LHSProtoI; 832 for (ObjCQualifiedIdType::qual_iterator I = rhsQID->qual_begin(), 833 E = rhsQID->qual_end(); I != E; ++I) { 834 ObjCProtocolDecl *rhsProto = *I; 835 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 836 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 837 match = true; 838 break; 839 } 840 } 841 if (!match) 842 return false; 843 } 844 return true; 845 } 846 847 if (const ObjCInterfaceType *IT = ltype->getAsObjCInterfaceType()) { 848 // for static type vs. qualified 'id' type, check that class implements 849 // all of 'id's protocols. 850 ObjCInterfaceDecl *lhsID = IT->getDecl(); 851 for (ObjCQualifiedIdType::qual_iterator I = rhsQID->qual_begin(), 852 E = rhsQID->qual_end(); I != E; ++I) { 853 if (!ClassImplementsProtocol(*I, lhsID, compare, true)) 854 return false; 855 } 856 return true; 857 } 858 return false; 859} 860 861