lib/Sema/SemaExprObjC.cpp

   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 "clang/Basic/Diagnostic.h"
  19 using namespace clang;
  20
  21 Sema::ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs,
  22                                               ExprTy **Strings,
  23                                               unsigned NumStrings) {
  24   SourceLocation AtLoc = AtLocs[0];
  25   StringLiteral* S = static_cast<StringLiteral *>(Strings[0]);
  26   if (NumStrings > 1) {
  27     // Concatenate objc strings.
  28     StringLiteral* ES = static_cast<StringLiteral *>(Strings[NumStrings-1]);
  29     SourceLocation EndLoc = ES->getSourceRange().getEnd();
  30     unsigned Length = 0;
  31     for (unsigned i = 0; i < NumStrings; i++)
  32       Length += static_cast<StringLiteral *>(Strings[i])->getByteLength();
  33     char *strBuf = new char [Length];
  34     char *p = strBuf;
  35     bool isWide = false;
  36     for (unsigned i = 0; i < NumStrings; i++) {
  37       S = static_cast<StringLiteral *>(Strings[i]);
  38       if (S->isWide())
  39         isWide = true;
  40       memcpy(p, S->getStrData(), S->getByteLength());
  41       p += S->getByteLength();
  42       delete S;
  43     }
  44     S = new StringLiteral(strBuf, Length,
  45                           isWide, Context.getPointerType(Context.CharTy),
  46                           AtLoc, EndLoc);
  47   }
  48
  49   if (CheckBuiltinCFStringArgument(S))
  50     return true;
  51
  52   if (Context.getObjCConstantStringInterface().isNull()) {
  53     // Initialize the constant string interface lazily. This assumes
  54     // the NSConstantString interface is seen in this translation unit.
  55     IdentifierInfo *NSIdent = &Context.Idents.get("NSConstantString");
  56     Decl *IFace = LookupDecl(NSIdent, Decl::IDNS_Ordinary, TUScope);
  57     ObjCInterfaceDecl *strIFace = dyn_cast_or_null<ObjCInterfaceDecl>(IFace);
  58     if (strIFace)
  59       Context.setObjCConstantStringInterface(strIFace);
  60   }
  61   QualType t = Context.getObjCConstantStringInterface();
  62   // If there is no NSConstantString interface defined then treat constant
  63   // strings as untyped objects and let the runtime figure it out later.
  64   if (t == QualType()) {
  65     t = Context.getObjCIdType();
  66   } else {
  67     t = Context.getPointerType(t);
  68   }
  69   return new ObjCStringLiteral(S, t, AtLoc);
  70 }
  71
  72 Sema::ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc,
  73                                                  SourceLocation EncodeLoc,
  74                                                  SourceLocation LParenLoc,
  75                                                  TypeTy *Ty,
  76                                                  SourceLocation RParenLoc) {
  77   QualType EncodedType = QualType::getFromOpaquePtr(Ty);
  78
  79   QualType t = Context.getPointerType(Context.CharTy);
  80   return new ObjCEncodeExpr(t, EncodedType, AtLoc, RParenLoc);
  81 }
  82
  83 Sema::ExprResult Sema::ParseObjCSelectorExpression(Selector Sel,
  84                                                    SourceLocation AtLoc,
  85                                                    SourceLocation SelLoc,
  86                                                    SourceLocation LParenLoc,
  87                                                    SourceLocation RParenLoc) {
  88   QualType t = Context.getObjCSelType();
  89   return new ObjCSelectorExpr(t, Sel, AtLoc, RParenLoc);
  90 }
  91
  92 Sema::ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
  93                                                    SourceLocation AtLoc,
  94                                                    SourceLocation ProtoLoc,
  95                                                    SourceLocation LParenLoc,
  96                                                    SourceLocation RParenLoc) {
  97   ObjCProtocolDecl* PDecl = ObjCProtocols[ProtocolId];
  98   if (!PDecl) {
  99     Diag(ProtoLoc, diag::err_undeclared_protocol, ProtocolId->getName());
 100     return true;
 101   }
 102
 103   QualType t = Context.getObjCProtoType();
 104   if (t.isNull())
 105     return true;
 106   t = Context.getPointerType(t);
 107   return new ObjCProtocolExpr(t, PDecl, AtLoc, RParenLoc);
 108 }
 109
 110 bool Sema::CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs,
 111                                      Selector Sel, ObjCMethodDecl *Method,
 112                                      const char *PrefixStr,
 113                                      SourceLocation lbrac, SourceLocation rbrac,
 114                                      QualType &ReturnType) {
 115   if (!Method) {
 116     // Apply default argument promotion as for (C99 6.5.2.2p6).
 117     for (unsigned i = 0; i != NumArgs; i++)
 118       DefaultArgumentPromotion(Args[i]);
 119
 120     Diag(lbrac, diag::warn_method_not_found, std::string(PrefixStr),
 121          Sel.getName(), SourceRange(lbrac, rbrac));
 122     ReturnType = Context.getObjCIdType();
 123     return false;
 124   } else {
 125     ReturnType = Method->getResultType();
 126   }
 127
 128   unsigned NumNamedArgs = Sel.getNumArgs();
 129   assert(NumArgs >= NumNamedArgs && "Too few arguments for selector!");
 130
 131   bool anyIncompatibleArgs = false;
 132   for (unsigned i = 0; i < NumNamedArgs; i++) {
 133     Expr *argExpr = Args[i];
 134     assert(argExpr && "CheckMessageArgumentTypes(): missing expression");
 135
 136     QualType lhsType = Method->getParamDecl(i)->getType();
 137     QualType rhsType = argExpr->getType();
 138
 139     // If necessary, apply function/array conversion. C99 6.7.5.3p[7,8].
 140     if (lhsType->isArrayType())
 141       lhsType = Context.getArrayDecayedType(lhsType);
 142     else if (lhsType->isFunctionType())
 143       lhsType = Context.getPointerType(lhsType);
 144
 145     AssignConvertType Result =
 146       CheckSingleAssignmentConstraints(lhsType, argExpr);
 147     if (Args[i] != argExpr) // The expression was converted.
 148       Args[i] = argExpr; // Make sure we store the converted expression.
 149
 150     anyIncompatibleArgs |=
 151       DiagnoseAssignmentResult(Result, argExpr->getLocStart(), lhsType, rhsType,
 152                                argExpr, "sending");
 153   }
 154
 155   // Promote additional arguments to variadic methods.
 156   if (Method->isVariadic()) {
 157     for (unsigned i = NumNamedArgs; i < NumArgs; ++i)
 158       DefaultArgumentPromotion(Args[i]);
 159   } else {
 160     // Check for extra arguments to non-variadic methods.
 161     if (NumArgs != NumNamedArgs) {
 162       Diag(Args[NumNamedArgs]->getLocStart(),
 163            diag::err_typecheck_call_too_many_args,
 164            Method->getSourceRange(),
 165            SourceRange(Args[NumNamedArgs]->getLocStart(),
 166                        Args[NumArgs-1]->getLocEnd()));
 167     }
 168   }
 169
 170   return anyIncompatibleArgs;
 171 }
 172
 173 // ActOnClassMessage - used for both unary and keyword messages.
 174 // ArgExprs is optional - if it is present, the number of expressions
 175 // is obtained from Sel.getNumArgs().
 176 Sema::ExprResult Sema::ActOnClassMessage(
 177   Scope *S,
 178   IdentifierInfo *receiverName, Selector Sel,
 179   SourceLocation lbrac, SourceLocation rbrac, ExprTy **Args, unsigned NumArgs)
 180 {
 181   assert(receiverName && "missing receiver class name");
 182
 183   Expr **ArgExprs = reinterpret_cast<Expr **>(Args);
 184   ObjCInterfaceDecl* ClassDecl = 0;
 185   bool isSuper = false;
 186
 187   if (receiverName == SuperID && getCurMethodDecl()) {
 188     isSuper = true;
 189     ClassDecl = getCurMethodDecl()->getClassInterface()->getSuperClass();
 190     if (!ClassDecl)
 191       return Diag(lbrac, diag::error_no_super_class,
 192                   getCurMethodDecl()->getClassInterface()->getName());
 193     if (getCurMethodDecl()->isInstance()) {
 194       QualType superTy = Context.getObjCInterfaceType(ClassDecl);
 195       superTy = Context.getPointerType(superTy);
 196       ExprResult ReceiverExpr = new PredefinedExpr(SourceLocation(), superTy,
 197           PredefinedExpr::ObjCSuper);
 198       // We are really in an instance method, redirect.
 199       return ActOnInstanceMessage(ReceiverExpr.Val, Sel, lbrac, rbrac,
 200                                   Args, NumArgs);
 201     }
 202     // We are sending a message to 'super' within a class method. Do nothing,
 203     // the receiver will pass through as 'super' (how convenient:-).
 204   } else
 205     ClassDecl = getObjCInterfaceDecl(receiverName);
 206
 207   // The following code allows for the following GCC-ism:
 208   //
 209   //  typedef XCElementDisplayRect XCElementGraphicsRect;
 210   //
 211   //  @implementation XCRASlice
 212   //  - whatever { // Note that XCElementGraphicsRect is a typedef name.
 213   //    _sGraphicsDelegate =[[XCElementGraphicsRect alloc] init];
 214   //  }
 215   //
 216   // If necessary, the following lookup could move to getObjCInterfaceDecl().
 217   if (!ClassDecl) {
 218     Decl *IDecl = LookupDecl(receiverName, Decl::IDNS_Ordinary, 0, false);
 219     if (TypedefDecl *OCTD = dyn_cast_or_null<TypedefDecl>(IDecl)) {
 220       const ObjCInterfaceType *OCIT;
 221       OCIT = OCTD->getUnderlyingType()->getAsObjCInterfaceType();
 222       if (OCIT)
 223         ClassDecl = OCIT->getDecl();
 224     }
 225   }
 226   assert(ClassDecl && "missing interface declaration");
 227   ObjCMethodDecl *Method = 0;
 228   QualType returnType;
 229   Method = ClassDecl->lookupClassMethod(Sel);
 230
 231   // If we have an implementation in scope, check "private" methods.
 232   if (!Method) {
 233     if (ObjCImplementationDecl *ImpDecl =
 234         ObjCImplementations[ClassDecl->getIdentifier()])
 235       Method = ImpDecl->getClassMethod(Sel);
 236
 237     // Look through local category implementations associated with the class.
 238     if (!Method) {
 239       for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Method; i++) {
 240         if (ObjCCategoryImpls[i]->getClassInterface() == ClassDecl)
 241           Method = ObjCCategoryImpls[i]->getClassMethod(Sel);
 242       }
 243     }
 244   }
 245   // Before we give up, check if the selector is an instance method.
 246   if (!Method)
 247     Method = ClassDecl->lookupInstanceMethod(Sel);
 248
 249   if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, "+",
 250                                 lbrac, rbrac, returnType))
 251     return true;
 252
 253   // If we have the ObjCInterfaceDecl* for the class that is receiving
 254   // the message, use that to construct the ObjCMessageExpr.  Otherwise
 255   // pass on the IdentifierInfo* for the class.
 256   // FIXME: need to do a better job handling 'super' usage within a class
 257   // For now, we simply pass the "super" identifier through (which isn't
 258   // consistent with instance methods.
 259   if (isSuper)
 260     return new ObjCMessageExpr(receiverName, Sel, returnType, Method,
 261                                lbrac, rbrac, ArgExprs, NumArgs);
 262   else
 263     return new ObjCMessageExpr(ClassDecl, Sel, returnType, Method,
 264                                lbrac, rbrac, ArgExprs, NumArgs);
 265 }
 266
 267 // ActOnInstanceMessage - used for both unary and keyword messages.
 268 // ArgExprs is optional - if it is present, the number of expressions
 269 // is obtained from Sel.getNumArgs().
 270 Sema::ExprResult Sema::ActOnInstanceMessage(ExprTy *receiver, Selector Sel,
 271                                             SourceLocation lbrac,
 272                                             SourceLocation rbrac,
 273                                             ExprTy **Args, unsigned NumArgs) {
 274   assert(receiver && "missing receiver expression");
 275
 276   Expr **ArgExprs = reinterpret_cast<Expr **>(Args);
 277   Expr *RExpr = static_cast<Expr *>(receiver);
 278   QualType returnType;
 279
 280   QualType ReceiverCType =
 281     Context.getCanonicalType(RExpr->getType()).getUnqualifiedType();
 282
 283   // Handle messages to id.
 284   if (ReceiverCType == Context.getCanonicalType(Context.getObjCIdType()) ||
 285       ReceiverCType->getAsBlockPointerType()) {
 286     ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(
 287                                Sel, SourceRange(lbrac,rbrac));
 288     if (!Method)
 289       Method = FactoryMethodPool[Sel].Method;
 290     if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, "-",
 291                                   lbrac, rbrac, returnType))
 292       return true;
 293     return new ObjCMessageExpr(RExpr, Sel, returnType, Method, lbrac, rbrac,
 294                                ArgExprs, NumArgs);
 295   }
 296
 297   // Handle messages to Class.
 298   if (ReceiverCType == Context.getCanonicalType(Context.getObjCClassType())) {
 299     ObjCMethodDecl *Method = 0;
 300     if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
 301       // If we have an implementation in scope, check "private" methods.
 302       if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
 303         if (ObjCImplementationDecl *ImpDecl =
 304               ObjCImplementations[ClassDecl->getIdentifier()])
 305           Method = ImpDecl->getClassMethod(Sel);
 306     }
 307     if (!Method)
 308       Method = FactoryMethodPool[Sel].Method;
 309     if (!Method)
 310       Method = LookupInstanceMethodInGlobalPool(
 311                                Sel, SourceRange(lbrac,rbrac));
 312     if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, "-",
 313                                   lbrac, rbrac, returnType))
 314       return true;
 315     return new ObjCMessageExpr(RExpr, Sel, returnType, Method, lbrac, rbrac,
 316                                ArgExprs, NumArgs);
 317   }
 318
 319   ObjCMethodDecl *Method = 0;
 320   ObjCInterfaceDecl* ClassDecl = 0;
 321
 322   // We allow sending a message to a qualified ID ("id<foo>"), which is ok as
 323   // long as one of the protocols implements the selector (if not, warn).
 324   if (ObjCQualifiedIdType *QIT = dyn_cast<ObjCQualifiedIdType>(ReceiverCType)) {
 325     // Search protocols
 326     for (unsigned i = 0; i < QIT->getNumProtocols(); i++) {
 327       ObjCProtocolDecl *PDecl = QIT->getProtocols(i);
 328       if (PDecl && (Method = PDecl->lookupInstanceMethod(Sel)))
 329         break;
 330     }
 331     if (!Method)
 332       Diag(lbrac, diag::warn_method_not_found_in_protocol,
 333            std::string("-"), Sel.getName(),
 334            RExpr->getSourceRange());
 335   } else if (const ObjCInterfaceType *OCIReceiver =
 336                 ReceiverCType->getAsPointerToObjCInterfaceType()) {
 337     // We allow sending a message to a pointer to an interface (an object).
 338
 339     ClassDecl = OCIReceiver->getDecl();
 340     // FIXME: consider using LookupInstanceMethodInGlobalPool, since it will be
 341     // faster than the following method (which can do *many* linear searches).
 342     // The idea is to add class info to InstanceMethodPool.
 343     Method = ClassDecl->lookupInstanceMethod(Sel);
 344
 345     if (!Method) {
 346       // Search protocol qualifiers.
 347       for (ObjCQualifiedIdType::qual_iterator QI = OCIReceiver->qual_begin(),
 348            E = OCIReceiver->qual_end(); QI != E; ++QI) {
 349         if ((Method = (*QI)->lookupInstanceMethod(Sel)))
 350           break;
 351       }
 352     }
 353
 354     if (!Method && !OCIReceiver->qual_empty())
 355       Diag(lbrac, diag::warn_method_not_found_in_protocol,
 356            std::string("-"), Sel.getName(),
 357            SourceRange(lbrac, rbrac));
 358   } else {
 359     Diag(lbrac, diag::error_bad_receiver_type,
 360          RExpr->getType().getAsString(), RExpr->getSourceRange());
 361     return true;
 362   }
 363
 364   if (!Method) {
 365     // If we have an implementation in scope, check "private" methods.
 366     if (ClassDecl)
 367       if (ObjCImplementationDecl *ImpDecl =
 368             ObjCImplementations[ClassDecl->getIdentifier()])
 369         Method = ImpDecl->getInstanceMethod(Sel);
 370         // If we still haven't found a method, look in the global pool. This
 371         // behavior isn't very desirable, however we need it for GCC
 372         // compatibility.
 373         if (!Method)
 374           Method = LookupInstanceMethodInGlobalPool(
 375                                Sel, SourceRange(lbrac,rbrac));
 376   }
 377   if (CheckMessageArgumentTypes(ArgExprs, NumArgs, Sel, Method, "-",
 378                                 lbrac, rbrac, returnType))
 379     return true;
 380   return new ObjCMessageExpr(RExpr, Sel, returnType, Method, lbrac, rbrac,
 381                              ArgExprs, NumArgs);
 382 }
 383
 384 //===----------------------------------------------------------------------===//
 385 // ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
 386 //===----------------------------------------------------------------------===//
 387
 388 /// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
 389 /// inheritance hierarchy of 'rProto'.
 390 static bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
 391                                            ObjCProtocolDecl *rProto) {
 392   if (lProto == rProto)
 393     return true;
 394   for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(),
 395        E = rProto->protocol_end(); PI != E; ++PI)
 396     if (ProtocolCompatibleWithProtocol(lProto, *PI))
 397       return true;
 398   return false;
 399 }
 400
 401 /// ClassImplementsProtocol - Checks that 'lProto' protocol
 402 /// has been implemented in IDecl class, its super class or categories (if
 403 /// lookupCategory is true).
 404 static bool ClassImplementsProtocol(ObjCProtocolDecl *lProto,
 405                                     ObjCInterfaceDecl *IDecl,
 406                                     bool lookupCategory,
 407                                     bool RHSIsQualifiedID = false) {
 408
 409   // 1st, look up the class.
 410   const ObjCList<ObjCProtocolDecl> &Protocols =
 411     IDecl->getReferencedProtocols();
 412
 413   for (ObjCList<ObjCProtocolDecl>::iterator PI = Protocols.begin(),
 414        E = Protocols.end(); PI != E; ++PI) {
 415     if (ProtocolCompatibleWithProtocol(lProto, *PI))
 416       return true;
 417     // This is dubious and is added to be compatible with gcc.
 418     // In gcc, it is also allowed assigning a protocol-qualified 'id'
 419     // type to a LHS object when protocol in qualified LHS is in list
 420     // of protocols in the rhs 'id' object. This IMO, should be a bug.
 421     // FIXME: Treat this as an extension, and flag this as an error when
 422     //  GCC extensions are not enabled.
 423     if (RHSIsQualifiedID && ProtocolCompatibleWithProtocol(*PI, lProto))
 424       return true;
 425   }
 426
 427   // 2nd, look up the category.
 428   if (lookupCategory)
 429     for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl;
 430          CDecl = CDecl->getNextClassCategory()) {
 431       for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(),
 432            E = CDecl->protocol_end(); PI != E; ++PI)
 433         if (ProtocolCompatibleWithProtocol(lProto, *PI))
 434           return true;
 435     }
 436
 437   // 3rd, look up the super class(s)
 438   if (IDecl->getSuperClass())
 439     return
 440       ClassImplementsProtocol(lProto, IDecl->getSuperClass(), lookupCategory,
 441                               RHSIsQualifiedID);
 442
 443   return false;
 444 }
 445
 446 /// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
 447 /// ObjCQualifiedIDType.
 448 bool Sema::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs,
 449                                              bool compare) {
 450   // Allow id<P..> and an 'id' or void* type in all cases.
 451   if (const PointerType *PT = lhs->getAsPointerType()) {
 452     QualType PointeeTy = PT->getPointeeType();
 453     if (Context.isObjCIdType(PointeeTy) || PointeeTy->isVoidType())
 454       return true;
 455   } else if (const PointerType *PT = rhs->getAsPointerType()) {
 456     QualType PointeeTy = PT->getPointeeType();
 457     if (Context.isObjCIdType(PointeeTy) || PointeeTy->isVoidType())
 458       return true;
 459   }
 460
 461   if (const ObjCQualifiedIdType *lhsQID = lhs->getAsObjCQualifiedIdType()) {
 462     const ObjCQualifiedIdType *rhsQID = rhs->getAsObjCQualifiedIdType();
 463     const ObjCQualifiedInterfaceType *rhsQI = 0;
 464     QualType rtype;
 465
 466     if (!rhsQID) {
 467       // Not comparing two ObjCQualifiedIdType's?
 468       if (!rhs->isPointerType()) return false;
 469
 470       rtype = rhs->getAsPointerType()->getPointeeType();
 471       rhsQI = rtype->getAsObjCQualifiedInterfaceType();
 472       if (rhsQI == 0) {
 473         // If the RHS is a unqualified interface pointer "NSString*",
 474         // make sure we check the class hierarchy.
 475         if (const ObjCInterfaceType *IT = rtype->getAsObjCInterfaceType()) {
 476           ObjCInterfaceDecl *rhsID = IT->getDecl();
 477           for (unsigned i = 0; i != lhsQID->getNumProtocols(); ++i) {
 478             // when comparing an id<P> on lhs with a static type on rhs,
 479             // see if static class implements all of id's protocols, directly or
 480             // through its super class and categories.
 481             if (!ClassImplementsProtocol(lhsQID->getProtocols(i), rhsID, true))
 482               return false;
 483           }
 484           return true;
 485         }
 486       }
 487     }
 488
 489     ObjCQualifiedIdType::qual_iterator RHSProtoI, RHSProtoE;
 490     if (rhsQI) { // We have a qualified interface (e.g. "NSObject<Proto> *").
 491       RHSProtoI = rhsQI->qual_begin();
 492       RHSProtoE = rhsQI->qual_end();
 493     } else if (rhsQID) { // We have a qualified id (e.g. "id<Proto> *").
 494       RHSProtoI = rhsQID->qual_begin();
 495       RHSProtoE = rhsQID->qual_end();
 496     } else {
 497       return false;
 498     }
 499
 500     for (unsigned i =0; i < lhsQID->getNumProtocols(); i++) {
 501       ObjCProtocolDecl *lhsProto = lhsQID->getProtocols(i);
 502       bool match = false;
 503
 504       // when comparing an id<P> on lhs with a static type on rhs,
 505       // see if static class implements all of id's protocols, directly or
 506       // through its super class and categories.
 507       for (; RHSProtoI != RHSProtoE; ++RHSProtoI) {
 508         ObjCProtocolDecl *rhsProto = *RHSProtoI;
 509         if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
 510             compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto)) {
 511           match = true;
 512           break;
 513         }
 514       }
 515       if (rhsQI) {
 516         // If the RHS is a qualified interface pointer "NSString<P>*",
 517         // make sure we check the class hierarchy.
 518         if (const ObjCInterfaceType *IT = rtype->getAsObjCInterfaceType()) {
 519           ObjCInterfaceDecl *rhsID = IT->getDecl();
 520           for (unsigned i = 0; i != lhsQID->getNumProtocols(); ++i) {
 521             // when comparing an id<P> on lhs with a static type on rhs,
 522             // see if static class implements all of id's protocols, directly or
 523             // through its super class and categories.
 524             if (ClassImplementsProtocol(lhsQID->getProtocols(i), rhsID, true)) {
 525               match = true;
 526               break;
 527             }
 528           }
 529         }
 530       }
 531       if (!match)
 532         return false;
 533     }
 534
 535     return true;
 536   }
 537
 538   const ObjCQualifiedIdType *rhsQID = rhs->getAsObjCQualifiedIdType();
 539   assert(rhsQID && "One of the LHS/RHS should be id<x>");
 540
 541   if (!lhs->isPointerType())
 542     return false;
 543
 544   QualType ltype = lhs->getAsPointerType()->getPointeeType();
 545   if (const ObjCQualifiedInterfaceType *lhsQI =
 546          ltype->getAsObjCQualifiedInterfaceType()) {
 547     ObjCQualifiedIdType::qual_iterator LHSProtoI = lhsQI->qual_begin();
 548     ObjCQualifiedIdType::qual_iterator LHSProtoE = lhsQI->qual_end();
 549     for (; LHSProtoI != LHSProtoE; ++LHSProtoI) {
 550       bool match = false;
 551       ObjCProtocolDecl *lhsProto = *LHSProtoI;
 552       for (unsigned j = 0; j < rhsQID->getNumProtocols(); j++) {
 553         ObjCProtocolDecl *rhsProto = rhsQID->getProtocols(j);
 554         if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
 555             compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto)) {
 556           match = true;
 557           break;
 558         }
 559       }
 560       if (!match)
 561         return false;
 562     }
 563     return true;
 564   }
 565
 566   if (const ObjCInterfaceType *IT = ltype->getAsObjCInterfaceType()) {
 567     // for static type vs. qualified 'id' type, check that class implements
 568     // all of 'id's protocols.
 569     ObjCInterfaceDecl *lhsID = IT->getDecl();
 570     for (unsigned j = 0; j < rhsQID->getNumProtocols(); j++) {
 571       ObjCProtocolDecl *rhsProto = rhsQID->getProtocols(j);
 572       if (!ClassImplementsProtocol(rhsProto, lhsID, compare, true))
 573         return false;
 574     }
 575     return true;
 576   }
 577   return false;
 578 }
 579