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