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