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/AST/ASTContext.h"
  16 #include "clang/AST/DeclObjC.h"
  17 #include "clang/AST/ExprObjC.h"
  18 #include "clang/AST/StmtVisitor.h"
  19 #include "clang/AST/TypeLoc.h"
  20 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
  21 #include "clang/Edit/Commit.h"
  22 #include "clang/Edit/Rewriters.h"
  23 #include "clang/Lex/Preprocessor.h"
  24 #include "clang/Sema/Initialization.h"
  25 #include "clang/Sema/Lookup.h"
  26 #include "clang/Sema/Scope.h"
  27 #include "clang/Sema/ScopeInfo.h"
  28 #include "llvm/ADT/SmallString.h"
  29
  30 using namespace clang;
  31 using namespace sema;
  32 using llvm::makeArrayRef;
  33
  34 ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs,
  35                                         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   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                                              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, 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, 0);
 660       Params.push_back(objects);
 661       ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
 662                                              SourceLocation(),
 663                                              SourceLocation(),
 664                                              &Context.Idents.get("cnt"),
 665                                              Context.UnsignedLongTy,
 666                                              /*TInfo=*/0, SC_None, 0);
 667       Params.push_back(cnt);
 668       Method->setMethodParams(Context, Params, ArrayRef<SourceLocation>());
 669     }
 670
 671     if (!validateBoxingMethod(*this, SR.getBegin(), NSArrayDecl, Sel, Method))
 672       return ExprError();
 673
 674     // Dig out the type that all elements should be converted to.
 675     QualType T = Method->param_begin()[0]->getType();
 676     const PointerType *PtrT = T->getAs<PointerType>();
 677     if (!PtrT ||
 678         !Context.hasSameUnqualifiedType(PtrT->getPointeeType(), IdT)) {
 679       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
 680         << Sel;
 681       Diag(Method->param_begin()[0]->getLocation(),
 682            diag::note_objc_literal_method_param)
 683         << 0 << T
 684         << Context.getPointerType(IdT.withConst());
 685       return ExprError();
 686     }
 687
 688     // Check that the 'count' parameter is integral.
 689     if (!Method->param_begin()[1]->getType()->isIntegerType()) {
 690       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
 691         << Sel;
 692       Diag(Method->param_begin()[1]->getLocation(),
 693            diag::note_objc_literal_method_param)
 694         << 1
 695         << Method->param_begin()[1]->getType()
 696         << "integral";
 697       return ExprError();
 698     }
 699
 700     // We've found a good +arrayWithObjects:count: method. Save it!
 701     ArrayWithObjectsMethod = Method;
 702   }
 703
 704   QualType ObjectsType = ArrayWithObjectsMethod->param_begin()[0]->getType();
 705   QualType RequiredType = ObjectsType->castAs<PointerType>()->getPointeeType();
 706
 707   // Check that each of the elements provided is valid in a collection literal,
 708   // performing conversions as necessary.
 709   Expr **ElementsBuffer = Elements.data();
 710   for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
 711     ExprResult Converted = CheckObjCCollectionLiteralElement(*this,
 712                                                              ElementsBuffer[I],
 713                                                              RequiredType);
 714     if (Converted.isInvalid())
 715       return ExprError();
 716
 717     ElementsBuffer[I] = Converted.get();
 718   }
 719
 720   QualType Ty
 721     = Context.getObjCObjectPointerType(
 722                                     Context.getObjCInterfaceType(NSArrayDecl));
 723
 724   return MaybeBindToTemporary(
 725            ObjCArrayLiteral::Create(Context, Elements, Ty,
 726                                     ArrayWithObjectsMethod, SR));
 727 }
 728
 729 ExprResult Sema::BuildObjCDictionaryLiteral(SourceRange SR,
 730                                             ObjCDictionaryElement *Elements,
 731                                             unsigned NumElements) {
 732   // Look up the NSDictionary class, if we haven't done so already.
 733   if (!NSDictionaryDecl) {
 734     NamedDecl *IF = LookupSingleName(TUScope,
 735                             NSAPIObj->getNSClassId(NSAPI::ClassId_NSDictionary),
 736                             SR.getBegin(), LookupOrdinaryName);
 737     NSDictionaryDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
 738     if (!NSDictionaryDecl && getLangOpts().DebuggerObjCLiteral)
 739       NSDictionaryDecl =  ObjCInterfaceDecl::Create (Context,
 740                             Context.getTranslationUnitDecl(),
 741                             SourceLocation(),
 742                             NSAPIObj->getNSClassId(NSAPI::ClassId_NSDictionary),
 743                             0, SourceLocation());
 744
 745     if (!NSDictionaryDecl) {
 746       Diag(SR.getBegin(), diag::err_undeclared_nsdictionary);
 747       return ExprError();
 748     }
 749   }
 750
 751   // Find the dictionaryWithObjects:forKeys:count: method, if we haven't done
 752   // so already.
 753   QualType IdT = Context.getObjCIdType();
 754   if (!DictionaryWithObjectsMethod) {
 755     Selector Sel = NSAPIObj->getNSDictionarySelector(
 756                                NSAPI::NSDict_dictionaryWithObjectsForKeysCount);
 757     ObjCMethodDecl *Method = NSDictionaryDecl->lookupClassMethod(Sel);
 758     if (!Method && getLangOpts().DebuggerObjCLiteral) {
 759       Method = ObjCMethodDecl::Create(Context,
 760                            SourceLocation(), SourceLocation(), Sel,
 761                            IdT,
 762                            0 /*TypeSourceInfo */,
 763                            Context.getTranslationUnitDecl(),
 764                            false /*Instance*/, false/*isVariadic*/,
 765                            /*isPropertyAccessor=*/false,
 766                            /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
 767                            ObjCMethodDecl::Required,
 768                            false);
 769       SmallVector<ParmVarDecl *, 3> Params;
 770       ParmVarDecl *objects = ParmVarDecl::Create(Context, Method,
 771                                                  SourceLocation(),
 772                                                  SourceLocation(),
 773                                                  &Context.Idents.get("objects"),
 774                                                  Context.getPointerType(IdT),
 775                                                  /*TInfo=*/0, SC_None, 0);
 776       Params.push_back(objects);
 777       ParmVarDecl *keys = ParmVarDecl::Create(Context, Method,
 778                                               SourceLocation(),
 779                                               SourceLocation(),
 780                                               &Context.Idents.get("keys"),
 781                                               Context.getPointerType(IdT),
 782                                               /*TInfo=*/0, SC_None, 0);
 783       Params.push_back(keys);
 784       ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
 785                                              SourceLocation(),
 786                                              SourceLocation(),
 787                                              &Context.Idents.get("cnt"),
 788                                              Context.UnsignedLongTy,
 789                                              /*TInfo=*/0, SC_None, 0);
 790       Params.push_back(cnt);
 791       Method->setMethodParams(Context, Params, ArrayRef<SourceLocation>());
 792     }
 793
 794     if (!validateBoxingMethod(*this, SR.getBegin(), NSDictionaryDecl, Sel,
 795                               Method))
 796        return ExprError();
 797
 798     // Dig out the type that all values should be converted to.
 799     QualType ValueT = Method->param_begin()[0]->getType();
 800     const PointerType *PtrValue = ValueT->getAs<PointerType>();
 801     if (!PtrValue ||
 802         !Context.hasSameUnqualifiedType(PtrValue->getPointeeType(), IdT)) {
 803       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
 804         << Sel;
 805       Diag(Method->param_begin()[0]->getLocation(),
 806            diag::note_objc_literal_method_param)
 807         << 0 << ValueT
 808         << Context.getPointerType(IdT.withConst());
 809       return ExprError();
 810     }
 811
 812     // Dig out the type that all keys should be converted to.
 813     QualType KeyT = Method->param_begin()[1]->getType();
 814     const PointerType *PtrKey = KeyT->getAs<PointerType>();
 815     if (!PtrKey ||
 816         !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(),
 817                                         IdT)) {
 818       bool err = true;
 819       if (PtrKey) {
 820         if (QIDNSCopying.isNull()) {
 821           // key argument of selector is id<NSCopying>?
 822           if (ObjCProtocolDecl *NSCopyingPDecl =
 823               LookupProtocol(&Context.Idents.get("NSCopying"), SR.getBegin())) {
 824             ObjCProtocolDecl *PQ[] = {NSCopyingPDecl};
 825             QIDNSCopying =
 826               Context.getObjCObjectType(Context.ObjCBuiltinIdTy,
 827                                         (ObjCProtocolDecl**) PQ,1);
 828             QIDNSCopying = Context.getObjCObjectPointerType(QIDNSCopying);
 829           }
 830         }
 831         if (!QIDNSCopying.isNull())
 832           err = !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(),
 833                                                 QIDNSCopying);
 834       }
 835
 836       if (err) {
 837         Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
 838           << Sel;
 839         Diag(Method->param_begin()[1]->getLocation(),
 840              diag::note_objc_literal_method_param)
 841           << 1 << KeyT
 842           << Context.getPointerType(IdT.withConst());
 843         return ExprError();
 844       }
 845     }
 846
 847     // Check that the 'count' parameter is integral.
 848     QualType CountType = Method->param_begin()[2]->getType();
 849     if (!CountType->isIntegerType()) {
 850       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
 851         << Sel;
 852       Diag(Method->param_begin()[2]->getLocation(),
 853            diag::note_objc_literal_method_param)
 854         << 2 << CountType
 855         << "integral";
 856       return ExprError();
 857     }
 858
 859     // We've found a good +dictionaryWithObjects:keys:count: method; save it!
 860     DictionaryWithObjectsMethod = Method;
 861   }
 862
 863   QualType ValuesT = DictionaryWithObjectsMethod->param_begin()[0]->getType();
 864   QualType ValueT = ValuesT->castAs<PointerType>()->getPointeeType();
 865   QualType KeysT = DictionaryWithObjectsMethod->param_begin()[1]->getType();
 866   QualType KeyT = KeysT->castAs<PointerType>()->getPointeeType();
 867
 868   // Check that each of the keys and values provided is valid in a collection
 869   // literal, performing conversions as necessary.
 870   bool HasPackExpansions = false;
 871   for (unsigned I = 0, N = NumElements; I != N; ++I) {
 872     // Check the key.
 873     ExprResult Key = CheckObjCCollectionLiteralElement(*this, Elements[I].Key,
 874                                                        KeyT);
 875     if (Key.isInvalid())
 876       return ExprError();
 877
 878     // Check the value.
 879     ExprResult Value
 880       = CheckObjCCollectionLiteralElement(*this, Elements[I].Value, ValueT);
 881     if (Value.isInvalid())
 882       return ExprError();
 883
 884     Elements[I].Key = Key.get();
 885     Elements[I].Value = Value.get();
 886
 887     if (Elements[I].EllipsisLoc.isInvalid())
 888       continue;
 889
 890     if (!Elements[I].Key->containsUnexpandedParameterPack() &&
 891         !Elements[I].Value->containsUnexpandedParameterPack()) {
 892       Diag(Elements[I].EllipsisLoc,
 893            diag::err_pack_expansion_without_parameter_packs)
 894         << SourceRange(Elements[I].Key->getLocStart(),
 895                        Elements[I].Value->getLocEnd());
 896       return ExprError();
 897     }
 898
 899     HasPackExpansions = true;
 900   }
 901
 902
 903   QualType Ty
 904     = Context.getObjCObjectPointerType(
 905                                 Context.getObjCInterfaceType(NSDictionaryDecl));
 906   return MaybeBindToTemporary(
 907            ObjCDictionaryLiteral::Create(Context,
 908                                          llvm::makeArrayRef(Elements,
 909                                                             NumElements),
 910                                          HasPackExpansions,
 911                                          Ty,
 912                                          DictionaryWithObjectsMethod, SR));
 913 }
 914
 915 ExprResult Sema::BuildObjCEncodeExpression(SourceLocation AtLoc,
 916                                       TypeSourceInfo *EncodedTypeInfo,
 917                                       SourceLocation RParenLoc) {
 918   QualType EncodedType = EncodedTypeInfo->getType();
 919   QualType StrTy;
 920   if (EncodedType->isDependentType())
 921     StrTy = Context.DependentTy;
 922   else {
 923     if (!EncodedType->getAsArrayTypeUnsafe() && //// Incomplete array is handled.
 924         !EncodedType->isVoidType()) // void is handled too.
 925       if (RequireCompleteType(AtLoc, EncodedType,
 926                               diag::err_incomplete_type_objc_at_encode,
 927                               EncodedTypeInfo->getTypeLoc()))
 928         return ExprError();
 929
 930     std::string Str;
 931     Context.getObjCEncodingForType(EncodedType, Str);
 932
 933     // The type of @encode is the same as the type of the corresponding string,
 934     // which is an array type.
 935     StrTy = Context.CharTy;
 936     // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
 937     if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings)
 938       StrTy.addConst();
 939     StrTy = Context.getConstantArrayType(StrTy, llvm::APInt(32, Str.size()+1),
 940                                          ArrayType::Normal, 0);
 941   }
 942
 943   return new (Context) ObjCEncodeExpr(StrTy, EncodedTypeInfo, AtLoc, RParenLoc);
 944 }
 945
 946 ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc,
 947                                            SourceLocation EncodeLoc,
 948                                            SourceLocation LParenLoc,
 949                                            ParsedType ty,
 950                                            SourceLocation RParenLoc) {
 951   // FIXME: Preserve type source info ?
 952   TypeSourceInfo *TInfo;
 953   QualType EncodedType = GetTypeFromParser(ty, &TInfo);
 954   if (!TInfo)
 955     TInfo = Context.getTrivialTypeSourceInfo(EncodedType,
 956                                              PP.getLocForEndOfToken(LParenLoc));
 957
 958   return BuildObjCEncodeExpression(AtLoc, TInfo, RParenLoc);
 959 }
 960
 961 ExprResult Sema::ParseObjCSelectorExpression(Selector Sel,
 962                                              SourceLocation AtLoc,
 963                                              SourceLocation SelLoc,
 964                                              SourceLocation LParenLoc,
 965                                              SourceLocation RParenLoc) {
 966   ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(Sel,
 967                              SourceRange(LParenLoc, RParenLoc), false, false);
 968   if (!Method)
 969     Method = LookupFactoryMethodInGlobalPool(Sel,
 970                                           SourceRange(LParenLoc, RParenLoc));
 971   if (!Method)
 972     Diag(SelLoc, diag::warn_undeclared_selector) << Sel;
 973
 974   if (!Method ||
 975       Method->getImplementationControl() != ObjCMethodDecl::Optional) {
 976     llvm::DenseMap<Selector, SourceLocation>::iterator Pos
 977       = ReferencedSelectors.find(Sel);
 978     if (Pos == ReferencedSelectors.end())
 979       ReferencedSelectors.insert(std::make_pair(Sel, AtLoc));
 980   }
 981
 982   // In ARC, forbid the user from using @selector for
 983   // retain/release/autorelease/dealloc/retainCount.
 984   if (getLangOpts().ObjCAutoRefCount) {
 985     switch (Sel.getMethodFamily()) {
 986     case OMF_retain:
 987     case OMF_release:
 988     case OMF_autorelease:
 989     case OMF_retainCount:
 990     case OMF_dealloc:
 991       Diag(AtLoc, diag::err_arc_illegal_selector) <<
 992         Sel << SourceRange(LParenLoc, RParenLoc);
 993       break;
 994
 995     case OMF_None:
 996     case OMF_alloc:
 997     case OMF_copy:
 998     case OMF_finalize:
 999     case OMF_init:
1000     case OMF_mutableCopy:
1001     case OMF_new:
1002     case OMF_self:
1003     case OMF_performSelector:
1004       break;
1005     }
1006   }
1007   QualType Ty = Context.getObjCSelType();
1008   return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc);
1009 }
1010
1011 ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
1012                                              SourceLocation AtLoc,
1013                                              SourceLocation ProtoLoc,
1014                                              SourceLocation LParenLoc,
1015                                              SourceLocation ProtoIdLoc,
1016                                              SourceLocation RParenLoc) {
1017   ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId, ProtoIdLoc);
1018   if (!PDecl) {
1019     Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;
1020     return true;
1021   }
1022
1023   QualType Ty = Context.getObjCProtoType();
1024   if (Ty.isNull())
1025     return true;
1026   Ty = Context.getObjCObjectPointerType(Ty);
1027   return new (Context) ObjCProtocolExpr(Ty, PDecl, AtLoc, ProtoIdLoc, RParenLoc);
1028 }
1029
1030 /// Try to capture an implicit reference to 'self'.
1031 ObjCMethodDecl *Sema::tryCaptureObjCSelf(SourceLocation Loc) {
1032   DeclContext *DC = getFunctionLevelDeclContext();
1033
1034   // If we're not in an ObjC method, error out.  Note that, unlike the
1035   // C++ case, we don't require an instance method --- class methods
1036   // still have a 'self', and we really do still need to capture it!
1037   ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(DC);
1038   if (!method)
1039     return 0;
1040
1041   tryCaptureVariable(method->getSelfDecl(), Loc);
1042
1043   return method;
1044 }
1045
1046 static QualType stripObjCInstanceType(ASTContext &Context, QualType T) {
1047   if (T == Context.getObjCInstanceType())
1048     return Context.getObjCIdType();
1049
1050   return T;
1051 }
1052
1053 QualType Sema::getMessageSendResultType(QualType ReceiverType,
1054                                         ObjCMethodDecl *Method,
1055                                     bool isClassMessage, bool isSuperMessage) {
1056   assert(Method && "Must have a method");
1057   if (!Method->hasRelatedResultType())
1058     return Method->getSendResultType();
1059
1060   // If a method has a related return type:
1061   //   - if the method found is an instance method, but the message send
1062   //     was a class message send, T is the declared return type of the method
1063   //     found
1064   if (Method->isInstanceMethod() && isClassMessage)
1065     return stripObjCInstanceType(Context, Method->getSendResultType());
1066
1067   //   - if the receiver is super, T is a pointer to the class of the
1068   //     enclosing method definition
1069   if (isSuperMessage) {
1070     if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
1071       if (ObjCInterfaceDecl *Class = CurMethod->getClassInterface())
1072         return Context.getObjCObjectPointerType(
1073                                         Context.getObjCInterfaceType(Class));
1074   }
1075
1076   //   - if the receiver is the name of a class U, T is a pointer to U
1077   if (ReceiverType->getAs<ObjCInterfaceType>() ||
1078       ReceiverType->isObjCQualifiedInterfaceType())
1079     return Context.getObjCObjectPointerType(ReceiverType);
1080   //   - if the receiver is of type Class or qualified Class type,
1081   //     T is the declared return type of the method.
1082   if (ReceiverType->isObjCClassType() ||
1083       ReceiverType->isObjCQualifiedClassType())
1084     return stripObjCInstanceType(Context, Method->getSendResultType());
1085
1086   //   - if the receiver is id, qualified id, Class, or qualified Class, T
1087   //     is the receiver type, otherwise
1088   //   - T is the type of the receiver expression.
1089   return ReceiverType;
1090 }
1091
1092 /// Look for an ObjC method whose result type exactly matches the given type.
1093 static const ObjCMethodDecl *
1094 findExplicitInstancetypeDeclarer(const ObjCMethodDecl *MD,
1095                                  QualType instancetype) {
1096   if (MD->getResultType() == instancetype) return MD;
1097
1098   // For these purposes, a method in an @implementation overrides a
1099   // declaration in the @interface.
1100   if (const ObjCImplDecl *impl =
1101         dyn_cast<ObjCImplDecl>(MD->getDeclContext())) {
1102     const ObjCContainerDecl *iface;
1103     if (const ObjCCategoryImplDecl *catImpl =
1104           dyn_cast<ObjCCategoryImplDecl>(impl)) {
1105       iface = catImpl->getCategoryDecl();
1106     } else {
1107       iface = impl->getClassInterface();
1108     }
1109
1110     const ObjCMethodDecl *ifaceMD =
1111       iface->getMethod(MD->getSelector(), MD->isInstanceMethod());
1112     if (ifaceMD) return findExplicitInstancetypeDeclarer(ifaceMD, instancetype);
1113   }
1114
1115   SmallVector<const ObjCMethodDecl *, 4> overrides;
1116   MD->getOverriddenMethods(overrides);
1117   for (unsigned i = 0, e = overrides.size(); i != e; ++i) {
1118     if (const ObjCMethodDecl *result =
1119           findExplicitInstancetypeDeclarer(overrides[i], instancetype))
1120       return result;
1121   }
1122
1123   return 0;
1124 }
1125
1126 void Sema::EmitRelatedResultTypeNoteForReturn(QualType destType) {
1127   // Only complain if we're in an ObjC method and the required return
1128   // type doesn't match the method's declared return type.
1129   ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurContext);
1130   if (!MD || !MD->hasRelatedResultType() ||
1131       Context.hasSameUnqualifiedType(destType, MD->getResultType()))
1132     return;
1133
1134   // Look for a method overridden by this method which explicitly uses
1135   // 'instancetype'.
1136   if (const ObjCMethodDecl *overridden =
1137         findExplicitInstancetypeDeclarer(MD, Context.getObjCInstanceType())) {
1138     SourceLocation loc;
1139     SourceRange range;
1140     if (TypeSourceInfo *TSI = overridden->getResultTypeSourceInfo()) {
1141       range = TSI->getTypeLoc().getSourceRange();
1142       loc = range.getBegin();
1143     }
1144     if (loc.isInvalid())
1145       loc = overridden->getLocation();
1146     Diag(loc, diag::note_related_result_type_explicit)
1147       << /*current method*/ 1 << range;
1148     return;
1149   }
1150
1151   // Otherwise, if we have an interesting method family, note that.
1152   // This should always trigger if the above didn't.
1153   if (ObjCMethodFamily family = MD->getMethodFamily())
1154     Diag(MD->getLocation(), diag::note_related_result_type_family)
1155       << /*current method*/ 1
1156       << family;
1157 }
1158
1159 void Sema::EmitRelatedResultTypeNote(const Expr *E) {
1160   E = E->IgnoreParenImpCasts();
1161   const ObjCMessageExpr *MsgSend = dyn_cast<ObjCMessageExpr>(E);
1162   if (!MsgSend)
1163     return;
1164
1165   const ObjCMethodDecl *Method = MsgSend->getMethodDecl();
1166   if (!Method)
1167     return;
1168
1169   if (!Method->hasRelatedResultType())
1170     return;
1171
1172   if (Context.hasSameUnqualifiedType(Method->getResultType()
1173                                                         .getNonReferenceType(),
1174                                      MsgSend->getType()))
1175     return;
1176
1177   if (!Context.hasSameUnqualifiedType(Method->getResultType(),
1178                                       Context.getObjCInstanceType()))
1179     return;
1180
1181   Diag(Method->getLocation(), diag::note_related_result_type_inferred)
1182     << Method->isInstanceMethod() << Method->getSelector()
1183     << MsgSend->getType();
1184 }
1185
1186 bool Sema::CheckMessageArgumentTypes(QualType ReceiverType,
1187                                      Expr **Args, unsigned NumArgs,
1188                                      Selector Sel,
1189                                      ArrayRef<SourceLocation> SelectorLocs,
1190                                      ObjCMethodDecl *Method,
1191                                      bool isClassMessage, bool isSuperMessage,
1192                                      SourceLocation lbrac, SourceLocation rbrac,
1193                                      QualType &ReturnType, ExprValueKind &VK) {
1194   if (!Method) {
1195     // Apply default argument promotion as for (C99 6.5.2.2p6).
1196     for (unsigned i = 0; i != NumArgs; i++) {
1197       if (Args[i]->isTypeDependent())
1198         continue;
1199
1200       ExprResult result;
1201       if (getLangOpts().DebuggerSupport) {
1202         QualType paramTy; // ignored
1203         result = checkUnknownAnyArg(lbrac, Args[i], paramTy);
1204       } else {
1205         result = DefaultArgumentPromotion(Args[i]);
1206       }
1207       if (result.isInvalid())
1208         return true;
1209       Args[i] = result.take();
1210     }
1211
1212     unsigned DiagID;
1213     if (getLangOpts().ObjCAutoRefCount)
1214       DiagID = diag::err_arc_method_not_found;
1215     else
1216       DiagID = isClassMessage ? diag::warn_class_method_not_found
1217                               : diag::warn_inst_method_not_found;
1218     if (!getLangOpts().DebuggerSupport)
1219       Diag(lbrac, DiagID)
1220         << Sel << isClassMessage << SourceRange(SelectorLocs.front(),
1221                                                 SelectorLocs.back());
1222
1223     // In debuggers, we want to use __unknown_anytype for these
1224     // results so that clients can cast them.
1225     if (getLangOpts().DebuggerSupport) {
1226       ReturnType = Context.UnknownAnyTy;
1227     } else {
1228       ReturnType = Context.getObjCIdType();
1229     }
1230     VK = VK_RValue;
1231     return false;
1232   }
1233
1234   ReturnType = getMessageSendResultType(ReceiverType, Method, isClassMessage,
1235                                         isSuperMessage);
1236   VK = Expr::getValueKindForType(Method->getResultType());
1237
1238   unsigned NumNamedArgs = Sel.getNumArgs();
1239   // Method might have more arguments than selector indicates. This is due
1240   // to addition of c-style arguments in method.
1241   if (Method->param_size() > Sel.getNumArgs())
1242     NumNamedArgs = Method->param_size();
1243   // FIXME. This need be cleaned up.
1244   if (NumArgs < NumNamedArgs) {
1245     Diag(lbrac, diag::err_typecheck_call_too_few_args)
1246       << 2 << NumNamedArgs << NumArgs;
1247     return false;
1248   }
1249
1250   bool IsError = false;
1251   for (unsigned i = 0; i < NumNamedArgs; i++) {
1252     // We can't do any type-checking on a type-dependent argument.
1253     if (Args[i]->isTypeDependent())
1254       continue;
1255
1256     Expr *argExpr = Args[i];
1257
1258     ParmVarDecl *param = Method->param_begin()[i];
1259     assert(argExpr && "CheckMessageArgumentTypes(): missing expression");
1260
1261     // Strip the unbridged-cast placeholder expression off unless it's
1262     // a consumed argument.
1263     if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
1264         !param->hasAttr<CFConsumedAttr>())
1265       argExpr = stripARCUnbridgedCast(argExpr);
1266
1267     // If the parameter is __unknown_anytype, infer its type
1268     // from the argument.
1269     if (param->getType() == Context.UnknownAnyTy) {
1270       QualType paramType;
1271       ExprResult argE = checkUnknownAnyArg(lbrac, argExpr, paramType);
1272       if (argE.isInvalid()) {
1273         IsError = true;
1274       } else {
1275         Args[i] = argE.take();
1276
1277         // Update the parameter type in-place.
1278         param->setType(paramType);
1279       }
1280       continue;
1281     }
1282
1283     if (RequireCompleteType(argExpr->getSourceRange().getBegin(),
1284                             param->getType(),
1285                             diag::err_call_incomplete_argument, argExpr))
1286       return true;
1287
1288     InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
1289                                                                       param);
1290     ExprResult ArgE = PerformCopyInitialization(Entity, lbrac, Owned(argExpr));
1291     if (ArgE.isInvalid())
1292       IsError = true;
1293     else
1294       Args[i] = ArgE.takeAs<Expr>();
1295   }
1296
1297   // Promote additional arguments to variadic methods.
1298   if (Method->isVariadic()) {
1299     for (unsigned i = NumNamedArgs; i < NumArgs; ++i) {
1300       if (Args[i]->isTypeDependent())
1301         continue;
1302
1303       ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
1304                                                         0);
1305       IsError |= Arg.isInvalid();
1306       Args[i] = Arg.take();
1307     }
1308   } else {
1309     // Check for extra arguments to non-variadic methods.
1310     if (NumArgs != NumNamedArgs) {
1311       Diag(Args[NumNamedArgs]->getLocStart(),
1312            diag::err_typecheck_call_too_many_args)
1313         << 2 /*method*/ << NumNamedArgs << NumArgs
1314         << Method->getSourceRange()
1315         << SourceRange(Args[NumNamedArgs]->getLocStart(),
1316                        Args[NumArgs-1]->getLocEnd());
1317     }
1318   }
1319
1320   DiagnoseSentinelCalls(Method, lbrac, Args, NumArgs);
1321
1322   // Do additional checkings on method.
1323   IsError |= CheckObjCMethodCall(Method, lbrac, Args, NumArgs);
1324
1325   return IsError;
1326 }
1327
1328 bool Sema::isSelfExpr(Expr *receiver) {
1329   // 'self' is objc 'self' in an objc method only.
1330   ObjCMethodDecl *method =
1331     dyn_cast<ObjCMethodDecl>(CurContext->getNonClosureAncestor());
1332   if (!method) return false;
1333
1334   receiver = receiver->IgnoreParenLValueCasts();
1335   if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(receiver))
1336     if (DRE->getDecl() == method->getSelfDecl())
1337       return true;
1338   return false;
1339 }
1340
1341 /// LookupMethodInType - Look up a method in an ObjCObjectType.
1342 ObjCMethodDecl *Sema::LookupMethodInObjectType(Selector sel, QualType type,
1343                                                bool isInstance) {
1344   const ObjCObjectType *objType = type->castAs<ObjCObjectType>();
1345   if (ObjCInterfaceDecl *iface = objType->getInterface()) {
1346     // Look it up in the main interface (and categories, etc.)
1347     if (ObjCMethodDecl *method = iface->lookupMethod(sel, isInstance))
1348       return method;
1349
1350     // Okay, look for "private" methods declared in any
1351     // @implementations we've seen.
1352     if (ObjCMethodDecl *method = iface->lookupPrivateMethod(sel, isInstance))
1353       return method;
1354   }
1355
1356   // Check qualifiers.
1357   for (ObjCObjectType::qual_iterator
1358          i = objType->qual_begin(), e = objType->qual_end(); i != e; ++i)
1359     if (ObjCMethodDecl *method = (*i)->lookupMethod(sel, isInstance))
1360       return method;
1361
1362   return 0;
1363 }
1364
1365 /// LookupMethodInQualifiedType - Lookups up a method in protocol qualifier
1366 /// list of a qualified objective pointer type.
1367 ObjCMethodDecl *Sema::LookupMethodInQualifiedType(Selector Sel,
1368                                               const ObjCObjectPointerType *OPT,
1369                                               bool Instance)
1370 {
1371   ObjCMethodDecl *MD = 0;
1372   for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
1373        E = OPT->qual_end(); I != E; ++I) {
1374     ObjCProtocolDecl *PROTO = (*I);
1375     if ((MD = PROTO->lookupMethod(Sel, Instance))) {
1376       return MD;
1377     }
1378   }
1379   return 0;
1380 }
1381
1382 static void DiagnoseARCUseOfWeakReceiver(Sema &S, Expr *Receiver) {
1383   if (!Receiver)
1384     return;
1385
1386   if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Receiver))
1387     Receiver = OVE->getSourceExpr();
1388
1389   Expr *RExpr = Receiver->IgnoreParenImpCasts();
1390   SourceLocation Loc = RExpr->getLocStart();
1391   QualType T = RExpr->getType();
1392   const ObjCPropertyDecl *PDecl = 0;
1393   const ObjCMethodDecl *GDecl = 0;
1394   if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(RExpr)) {
1395     RExpr = POE->getSyntacticForm();
1396     if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(RExpr)) {
1397       if (PRE->isImplicitProperty()) {
1398         GDecl = PRE->getImplicitPropertyGetter();
1399         if (GDecl) {
1400           T = GDecl->getResultType();
1401         }
1402       }
1403       else {
1404         PDecl = PRE->getExplicitProperty();
1405         if (PDecl) {
1406           T = PDecl->getType();
1407         }
1408       }
1409     }
1410   }
1411   else if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(RExpr)) {
1412     // See if receiver is a method which envokes a synthesized getter
1413     // backing a 'weak' property.
1414     ObjCMethodDecl *Method = ME->getMethodDecl();
1415     if (Method && Method->getSelector().getNumArgs() == 0) {
1416       PDecl = Method->findPropertyDecl();
1417       if (PDecl)
1418         T = PDecl->getType();
1419     }
1420   }
1421
1422   if (T.getObjCLifetime() != Qualifiers::OCL_Weak) {
1423     if (!PDecl)
1424       return;
1425     if (!(PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak))
1426       return;
1427   }
1428
1429   S.Diag(Loc, diag::warn_receiver_is_weak)
1430     << ((!PDecl && !GDecl) ? 0 : (PDecl ? 1 : 2));
1431
1432   if (PDecl)
1433     S.Diag(PDecl->getLocation(), diag::note_property_declare);
1434   else if (GDecl)
1435     S.Diag(GDecl->getLocation(), diag::note_method_declared_at) << GDecl;
1436
1437   S.Diag(Loc, diag::note_arc_assign_to_strong);
1438 }
1439
1440 /// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an
1441 /// objective C interface.  This is a property reference expression.
1442 ExprResult Sema::
1443 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
1444                           Expr *BaseExpr, SourceLocation OpLoc,
1445                           DeclarationName MemberName,
1446                           SourceLocation MemberLoc,
1447                           SourceLocation SuperLoc, QualType SuperType,
1448                           bool Super) {
1449   const ObjCInterfaceType *IFaceT = OPT->getInterfaceType();
1450   ObjCInterfaceDecl *IFace = IFaceT->getDecl();
1451
1452   if (!MemberName.isIdentifier()) {
1453     Diag(MemberLoc, diag::err_invalid_property_name)
1454       << MemberName << QualType(OPT, 0);
1455     return ExprError();
1456   }
1457
1458   IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1459
1460   SourceRange BaseRange = Super? SourceRange(SuperLoc)
1461                                : BaseExpr->getSourceRange();
1462   if (RequireCompleteType(MemberLoc, OPT->getPointeeType(),
1463                           diag::err_property_not_found_forward_class,
1464                           MemberName, BaseRange))
1465     return ExprError();
1466
1467   // Search for a declared property first.
1468   if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(Member)) {
1469     // Check whether we can reference this property.
1470     if (DiagnoseUseOfDecl(PD, MemberLoc))
1471       return ExprError();
1472     if (Super)
1473       return Owned(new (Context) ObjCPropertyRefExpr(PD, Context.PseudoObjectTy,
1474                                                      VK_LValue, OK_ObjCProperty,
1475                                                      MemberLoc,
1476                                                      SuperLoc, SuperType));
1477     else
1478       return Owned(new (Context) ObjCPropertyRefExpr(PD, Context.PseudoObjectTy,
1479                                                      VK_LValue, OK_ObjCProperty,
1480                                                      MemberLoc, BaseExpr));
1481   }
1482   // Check protocols on qualified interfaces.
1483   for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
1484        E = OPT->qual_end(); I != E; ++I)
1485     if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Member)) {
1486       // Check whether we can reference this property.
1487       if (DiagnoseUseOfDecl(PD, MemberLoc))
1488         return ExprError();
1489
1490       if (Super)
1491         return Owned(new (Context) ObjCPropertyRefExpr(PD,
1492                                                        Context.PseudoObjectTy,
1493                                                        VK_LValue,
1494                                                        OK_ObjCProperty,
1495                                                        MemberLoc,
1496                                                        SuperLoc, SuperType));
1497       else
1498         return Owned(new (Context) ObjCPropertyRefExpr(PD,
1499                                                        Context.PseudoObjectTy,
1500                                                        VK_LValue,
1501                                                        OK_ObjCProperty,
1502                                                        MemberLoc,
1503                                                        BaseExpr));
1504     }
1505   // If that failed, look for an "implicit" property by seeing if the nullary
1506   // selector is implemented.
1507
1508   // FIXME: The logic for looking up nullary and unary selectors should be
1509   // shared with the code in ActOnInstanceMessage.
1510
1511   Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
1512   ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
1513
1514   // May be founf in property's qualified list.
1515   if (!Getter)
1516     Getter = LookupMethodInQualifiedType(Sel, OPT, true);
1517
1518   // If this reference is in an @implementation, check for 'private' methods.
1519   if (!Getter)
1520     Getter = IFace->lookupPrivateMethod(Sel);
1521
1522   if (Getter) {
1523     // Check if we can reference this property.
1524     if (DiagnoseUseOfDecl(Getter, MemberLoc))
1525       return ExprError();
1526   }
1527   // If we found a getter then this may be a valid dot-reference, we
1528   // will look for the matching setter, in case it is needed.
1529   Selector SetterSel =
1530     SelectorTable::constructSetterName(PP.getIdentifierTable(),
1531                                        PP.getSelectorTable(), Member);
1532   ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel);
1533
1534   // May be founf in property's qualified list.
1535   if (!Setter)
1536     Setter = LookupMethodInQualifiedType(SetterSel, OPT, true);
1537
1538   if (!Setter) {
1539     // If this reference is in an @implementation, also check for 'private'
1540     // methods.
1541     Setter = IFace->lookupPrivateMethod(SetterSel);
1542   }
1543
1544   if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
1545     return ExprError();
1546
1547   if (Getter || Setter) {
1548     if (Super)
1549       return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
1550                                                      Context.PseudoObjectTy,
1551                                                      VK_LValue, OK_ObjCProperty,
1552                                                      MemberLoc,
1553                                                      SuperLoc, SuperType));
1554     else
1555       return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
1556                                                      Context.PseudoObjectTy,
1557                                                      VK_LValue, OK_ObjCProperty,
1558                                                      MemberLoc, BaseExpr));
1559
1560   }
1561
1562   // Attempt to correct for typos in property names.
1563   DeclFilterCCC<ObjCPropertyDecl> Validator;
1564   if (TypoCorrection Corrected = CorrectTypo(
1565       DeclarationNameInfo(MemberName, MemberLoc), LookupOrdinaryName, NULL,
1566       NULL, Validator, IFace, false, OPT)) {
1567     ObjCPropertyDecl *Property =
1568         Corrected.getCorrectionDeclAs<ObjCPropertyDecl>();
1569     DeclarationName TypoResult = Corrected.getCorrection();
1570     Diag(MemberLoc, diag::err_property_not_found_suggest)
1571       << MemberName << QualType(OPT, 0) << TypoResult
1572       << FixItHint::CreateReplacement(MemberLoc, TypoResult.getAsString());
1573     Diag(Property->getLocation(), diag::note_previous_decl)
1574       << Property->getDeclName();
1575     return HandleExprPropertyRefExpr(OPT, BaseExpr, OpLoc,
1576                                      TypoResult, MemberLoc,
1577                                      SuperLoc, SuperType, Super);
1578   }
1579   ObjCInterfaceDecl *ClassDeclared;
1580   if (ObjCIvarDecl *Ivar =
1581       IFace->lookupInstanceVariable(Member, ClassDeclared)) {
1582     QualType T = Ivar->getType();
1583     if (const ObjCObjectPointerType * OBJPT =
1584         T->getAsObjCInterfacePointerType()) {
1585       if (RequireCompleteType(MemberLoc, OBJPT->getPointeeType(),
1586                               diag::err_property_not_as_forward_class,
1587                               MemberName, BaseExpr))
1588         return ExprError();
1589     }
1590     Diag(MemberLoc,
1591          diag::err_ivar_access_using_property_syntax_suggest)
1592     << MemberName << QualType(OPT, 0) << Ivar->getDeclName()
1593     << FixItHint::CreateReplacement(OpLoc, "->");
1594     return ExprError();
1595   }
1596
1597   Diag(MemberLoc, diag::err_property_not_found)
1598     << MemberName << QualType(OPT, 0);
1599   if (Setter)
1600     Diag(Setter->getLocation(), diag::note_getter_unavailable)
1601           << MemberName << BaseExpr->getSourceRange();
1602   return ExprError();
1603 }
1604
1605
1606
1607 ExprResult Sema::
1608 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
1609                           IdentifierInfo &propertyName,
1610                           SourceLocation receiverNameLoc,
1611                           SourceLocation propertyNameLoc) {
1612
1613   IdentifierInfo *receiverNamePtr = &receiverName;
1614   ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(receiverNamePtr,
1615                                                   receiverNameLoc);
1616
1617   bool IsSuper = false;
1618   if (IFace == 0) {
1619     // If the "receiver" is 'super' in a method, handle it as an expression-like
1620     // property reference.
1621     if (receiverNamePtr->isStr("super")) {
1622       IsSuper = true;
1623
1624       if (ObjCMethodDecl *CurMethod = tryCaptureObjCSelf(receiverNameLoc)) {
1625         if (CurMethod->isInstanceMethod()) {
1626           ObjCInterfaceDecl *Super =
1627             CurMethod->getClassInterface()->getSuperClass();
1628           if (!Super) {
1629             // The current class does not have a superclass.
1630             Diag(receiverNameLoc, diag::error_root_class_cannot_use_super)
1631             << CurMethod->getClassInterface()->getIdentifier();
1632             return ExprError();
1633           }
1634           QualType T = Context.getObjCInterfaceType(Super);
1635           T = Context.getObjCObjectPointerType(T);
1636
1637           return HandleExprPropertyRefExpr(T->getAsObjCInterfacePointerType(),
1638                                            /*BaseExpr*/0,
1639                                            SourceLocation()/*OpLoc*/,
1640                                            &propertyName,
1641                                            propertyNameLoc,
1642                                            receiverNameLoc, T, true);
1643         }
1644
1645         // Otherwise, if this is a class method, try dispatching to our
1646         // superclass.
1647         IFace = CurMethod->getClassInterface()->getSuperClass();
1648       }
1649     }
1650
1651     if (IFace == 0) {
1652       Diag(receiverNameLoc, diag::err_expected_ident_or_lparen);
1653       return ExprError();
1654     }
1655   }
1656
1657   // Search for a declared property first.
1658   Selector Sel = PP.getSelectorTable().getNullarySelector(&propertyName);
1659   ObjCMethodDecl *Getter = IFace->lookupClassMethod(Sel);
1660
1661   // If this reference is in an @implementation, check for 'private' methods.
1662   if (!Getter)
1663     if (ObjCMethodDecl *CurMeth = getCurMethodDecl())
1664       if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
1665         if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation())
1666           Getter = ImpDecl->getClassMethod(Sel);
1667
1668   if (Getter) {
1669     // FIXME: refactor/share with ActOnMemberReference().
1670     // Check if we can reference this property.
1671     if (DiagnoseUseOfDecl(Getter, propertyNameLoc))
1672       return ExprError();
1673   }
1674
1675   // Look for the matching setter, in case it is needed.
1676   Selector SetterSel =
1677     SelectorTable::constructSetterName(PP.getIdentifierTable(),
1678                                        PP.getSelectorTable(), &propertyName);
1679
1680   ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
1681   if (!Setter) {
1682     // If this reference is in an @implementation, also check for 'private'
1683     // methods.
1684     if (ObjCMethodDecl *CurMeth = getCurMethodDecl())
1685       if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
1686         if (ObjCImplementationDecl *ImpDecl = ClassDecl->getImplementation())
1687           Setter = ImpDecl->getClassMethod(SetterSel);
1688   }
1689   // Look through local category implementations associated with the class.
1690   if (!Setter)
1691     Setter = IFace->getCategoryClassMethod(SetterSel);
1692
1693   if (Setter && DiagnoseUseOfDecl(Setter, propertyNameLoc))
1694     return ExprError();
1695
1696   if (Getter || Setter) {
1697     if (IsSuper)
1698     return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
1699                                                    Context.PseudoObjectTy,
1700                                                    VK_LValue, OK_ObjCProperty,
1701                                                    propertyNameLoc,
1702                                                    receiverNameLoc,
1703                                           Context.getObjCInterfaceType(IFace)));
1704
1705     return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
1706                                                    Context.PseudoObjectTy,
1707                                                    VK_LValue, OK_ObjCProperty,
1708                                                    propertyNameLoc,
1709                                                    receiverNameLoc, IFace));
1710   }
1711   return ExprError(Diag(propertyNameLoc, diag::err_property_not_found)
1712                      << &propertyName << Context.getObjCInterfaceType(IFace));
1713 }
1714
1715 namespace {
1716
1717 class ObjCInterfaceOrSuperCCC : public CorrectionCandidateCallback {
1718  public:
1719   ObjCInterfaceOrSuperCCC(ObjCMethodDecl *Method) {
1720     // Determine whether "super" is acceptable in the current context.
1721     if (Method && Method->getClassInterface())
1722       WantObjCSuper = Method->getClassInterface()->getSuperClass();
1723   }
1724
1725   virtual bool ValidateCandidate(const TypoCorrection &candidate) {
1726     return candidate.getCorrectionDeclAs<ObjCInterfaceDecl>() ||
1727         candidate.isKeyword("super");
1728   }
1729 };
1730
1731 }
1732
1733 Sema::ObjCMessageKind Sema::getObjCMessageKind(Scope *S,
1734                                                IdentifierInfo *Name,
1735                                                SourceLocation NameLoc,
1736                                                bool IsSuper,
1737                                                bool HasTrailingDot,
1738                                                ParsedType &ReceiverType) {
1739   ReceiverType = ParsedType();
1740
1741   // If the identifier is "super" and there is no trailing dot, we're
1742   // messaging super. If the identifier is "super" and there is a
1743   // trailing dot, it's an instance message.
1744   if (IsSuper && S->isInObjcMethodScope())
1745     return HasTrailingDot? ObjCInstanceMessage : ObjCSuperMessage;
1746
1747   LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
1748   LookupName(Result, S);
1749
1750   switch (Result.getResultKind()) {
1751   case LookupResult::NotFound:
1752     // Normal name lookup didn't find anything. If we're in an
1753     // Objective-C method, look for ivars. If we find one, we're done!
1754     // FIXME: This is a hack. Ivar lookup should be part of normal
1755     // lookup.
1756     if (ObjCMethodDecl *Method = getCurMethodDecl()) {
1757       if (!Method->getClassInterface()) {
1758         // Fall back: let the parser try to parse it as an instance message.
1759         return ObjCInstanceMessage;
1760       }
1761
1762       ObjCInterfaceDecl *ClassDeclared;
1763       if (Method->getClassInterface()->lookupInstanceVariable(Name,
1764                                                               ClassDeclared))
1765         return ObjCInstanceMessage;
1766     }
1767
1768     // Break out; we'll perform typo correction below.
1769     break;
1770
1771   case LookupResult::NotFoundInCurrentInstantiation:
1772   case LookupResult::FoundOverloaded:
1773   case LookupResult::FoundUnresolvedValue:
1774   case LookupResult::Ambiguous:
1775     Result.suppressDiagnostics();
1776     return ObjCInstanceMessage;
1777
1778   case LookupResult::Found: {
1779     // If the identifier is a class or not, and there is a trailing dot,
1780     // it's an instance message.
1781     if (HasTrailingDot)
1782       return ObjCInstanceMessage;
1783     // We found something. If it's a type, then we have a class
1784     // message. Otherwise, it's an instance message.
1785     NamedDecl *ND = Result.getFoundDecl();
1786     QualType T;
1787     if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(ND))
1788       T = Context.getObjCInterfaceType(Class);
1789     else if (TypeDecl *Type = dyn_cast<TypeDecl>(ND)) {
1790       T = Context.getTypeDeclType(Type);
1791       DiagnoseUseOfDecl(Type, NameLoc);
1792     }
1793     else
1794       return ObjCInstanceMessage;
1795
1796     //  We have a class message, and T is the type we're
1797     //  messaging. Build source-location information for it.
1798     TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
1799     ReceiverType = CreateParsedType(T, TSInfo);
1800     return ObjCClassMessage;
1801   }
1802   }
1803
1804   ObjCInterfaceOrSuperCCC Validator(getCurMethodDecl());
1805   if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
1806                                              Result.getLookupKind(), S, NULL,
1807                                              Validator)) {
1808     if (Corrected.isKeyword()) {
1809       // If we've found the keyword "super" (the only keyword that would be
1810       // returned by CorrectTypo), this is a send to super.
1811       Diag(NameLoc, diag::err_unknown_receiver_suggest)
1812         << Name << Corrected.getCorrection()
1813         << FixItHint::CreateReplacement(SourceRange(NameLoc), "super");
1814       return ObjCSuperMessage;
1815     } else if (ObjCInterfaceDecl *Class =
1816                Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
1817       // If we found a declaration, correct when it refers to an Objective-C
1818       // class.
1819       Diag(NameLoc, diag::err_unknown_receiver_suggest)
1820         << Name << Corrected.getCorrection()
1821         << FixItHint::CreateReplacement(SourceRange(NameLoc),
1822                                         Class->getNameAsString());
1823       Diag(Class->getLocation(), diag::note_previous_decl)
1824         << Corrected.getCorrection();
1825
1826       QualType T = Context.getObjCInterfaceType(Class);
1827       TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(T, NameLoc);
1828       ReceiverType = CreateParsedType(T, TSInfo);
1829       return ObjCClassMessage;
1830     }
1831   }
1832
1833   // Fall back: let the parser try to parse it as an instance message.
1834   return ObjCInstanceMessage;
1835 }
1836
1837 ExprResult Sema::ActOnSuperMessage(Scope *S,
1838                                    SourceLocation SuperLoc,
1839                                    Selector Sel,
1840                                    SourceLocation LBracLoc,
1841                                    ArrayRef<SourceLocation> SelectorLocs,
1842                                    SourceLocation RBracLoc,
1843                                    MultiExprArg Args) {
1844   // Determine whether we are inside a method or not.
1845   ObjCMethodDecl *Method = tryCaptureObjCSelf(SuperLoc);
1846   if (!Method) {
1847     Diag(SuperLoc, diag::err_invalid_receiver_to_message_super);
1848     return ExprError();
1849   }
1850
1851   ObjCInterfaceDecl *Class = Method->getClassInterface();
1852   if (!Class) {
1853     Diag(SuperLoc, diag::error_no_super_class_message)
1854       << Method->getDeclName();
1855     return ExprError();
1856   }
1857
1858   ObjCInterfaceDecl *Super = Class->getSuperClass();
1859   if (!Super) {
1860     // The current class does not have a superclass.
1861     Diag(SuperLoc, diag::error_root_class_cannot_use_super)
1862       << Class->getIdentifier();
1863     return ExprError();
1864   }
1865
1866   // We are in a method whose class has a superclass, so 'super'
1867   // is acting as a keyword.
1868   if (Method->getSelector() == Sel)
1869     getCurFunction()->ObjCShouldCallSuper = false;
1870
1871   if (Method->isInstanceMethod()) {
1872     // Since we are in an instance method, this is an instance
1873     // message to the superclass instance.
1874     QualType SuperTy = Context.getObjCInterfaceType(Super);
1875     SuperTy = Context.getObjCObjectPointerType(SuperTy);
1876     return BuildInstanceMessage(0, SuperTy, SuperLoc,
1877                                 Sel, /*Method=*/0,
1878                                 LBracLoc, SelectorLocs, RBracLoc, Args);
1879   }
1880
1881   // Since we are in a class method, this is a class message to
1882   // the superclass.
1883   return BuildClassMessage(/*ReceiverTypeInfo=*/0,
1884                            Context.getObjCInterfaceType(Super),
1885                            SuperLoc, Sel, /*Method=*/0,
1886                            LBracLoc, SelectorLocs, RBracLoc, Args);
1887 }
1888
1889
1890 ExprResult Sema::BuildClassMessageImplicit(QualType ReceiverType,
1891                                            bool isSuperReceiver,
1892                                            SourceLocation Loc,
1893                                            Selector Sel,
1894                                            ObjCMethodDecl *Method,
1895                                            MultiExprArg Args) {
1896   TypeSourceInfo *receiverTypeInfo = 0;
1897   if (!ReceiverType.isNull())
1898     receiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType);
1899
1900   return BuildClassMessage(receiverTypeInfo, ReceiverType,
1901                           /*SuperLoc=*/isSuperReceiver ? Loc : SourceLocation(),
1902                            Sel, Method, Loc, Loc, Loc, Args,
1903                            /*isImplicit=*/true);
1904
1905 }
1906
1907 static void applyCocoaAPICheck(Sema &S, const ObjCMessageExpr *Msg,
1908                                unsigned DiagID,
1909                                bool (*refactor)(const ObjCMessageExpr *,
1910                                               const NSAPI &, edit::Commit &)) {
1911   SourceLocation MsgLoc = Msg->getExprLoc();
1912   if (S.Diags.getDiagnosticLevel(DiagID, MsgLoc) == DiagnosticsEngine::Ignored)
1913     return;
1914
1915   SourceManager &SM = S.SourceMgr;
1916   edit::Commit ECommit(SM, S.LangOpts);
1917   if (refactor(Msg,*S.NSAPIObj, ECommit)) {
1918     DiagnosticBuilder Builder = S.Diag(MsgLoc, DiagID)
1919                         << Msg->getSelector() << Msg->getSourceRange();
1920     // FIXME: Don't emit diagnostic at all if fixits are non-commitable.
1921     if (!ECommit.isCommitable())
1922       return;
1923     for (edit::Commit::edit_iterator
1924            I = ECommit.edit_begin(), E = ECommit.edit_end(); I != E; ++I) {
1925       const edit::Commit::Edit &Edit = *I;
1926       switch (Edit.Kind) {
1927       case edit::Commit::Act_Insert:
1928         Builder.AddFixItHint(FixItHint::CreateInsertion(Edit.OrigLoc,
1929                                                         Edit.Text,
1930                                                         Edit.BeforePrev));
1931         break;
1932       case edit::Commit::Act_InsertFromRange:
1933         Builder.AddFixItHint(
1934             FixItHint::CreateInsertionFromRange(Edit.OrigLoc,
1935                                                 Edit.getInsertFromRange(SM),
1936                                                 Edit.BeforePrev));
1937         break;
1938       case edit::Commit::Act_Remove:
1939         Builder.AddFixItHint(FixItHint::CreateRemoval(Edit.getFileRange(SM)));
1940         break;
1941       }
1942     }
1943   }
1944 }
1945
1946 static void checkCocoaAPI(Sema &S, const ObjCMessageExpr *Msg) {
1947   applyCocoaAPICheck(S, Msg, diag::warn_objc_redundant_literal_use,
1948                      edit::rewriteObjCRedundantCallWithLiteral);
1949 }
1950
1951 /// \brief Build an Objective-C class message expression.
1952 ///
1953 /// This routine takes care of both normal class messages and
1954 /// class messages to the superclass.
1955 ///
1956 /// \param ReceiverTypeInfo Type source information that describes the
1957 /// receiver of this message. This may be NULL, in which case we are
1958 /// sending to the superclass and \p SuperLoc must be a valid source
1959 /// location.
1960
1961 /// \param ReceiverType The type of the object receiving the
1962 /// message. When \p ReceiverTypeInfo is non-NULL, this is the same
1963 /// type as that refers to. For a superclass send, this is the type of
1964 /// the superclass.
1965 ///
1966 /// \param SuperLoc The location of the "super" keyword in a
1967 /// superclass message.
1968 ///
1969 /// \param Sel The selector to which the message is being sent.
1970 ///
1971 /// \param Method The method that this class message is invoking, if
1972 /// already known.
1973 ///
1974 /// \param LBracLoc The location of the opening square bracket ']'.
1975 ///
1976 /// \param RBracLoc The location of the closing square bracket ']'.
1977 ///
1978 /// \param ArgsIn The message arguments.
1979 ExprResult Sema::BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
1980                                    QualType ReceiverType,
1981                                    SourceLocation SuperLoc,
1982                                    Selector Sel,
1983                                    ObjCMethodDecl *Method,
1984                                    SourceLocation LBracLoc,
1985                                    ArrayRef<SourceLocation> SelectorLocs,
1986                                    SourceLocation RBracLoc,
1987                                    MultiExprArg ArgsIn,
1988                                    bool isImplicit) {
1989   SourceLocation Loc = SuperLoc.isValid()? SuperLoc
1990     : ReceiverTypeInfo->getTypeLoc().getSourceRange().getBegin();
1991   if (LBracLoc.isInvalid()) {
1992     Diag(Loc, diag::err_missing_open_square_message_send)
1993       << FixItHint::CreateInsertion(Loc, "[");
1994     LBracLoc = Loc;
1995   }
1996
1997   if (ReceiverType->isDependentType()) {
1998     // If the receiver type is dependent, we can't type-check anything
1999     // at this point. Build a dependent expression.
2000     unsigned NumArgs = ArgsIn.size();
2001     Expr **Args = ArgsIn.data();
2002     assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2003     return Owned(ObjCMessageExpr::Create(Context, ReceiverType,
2004                                          VK_RValue, LBracLoc, ReceiverTypeInfo,
2005                                          Sel, SelectorLocs, /*Method=*/0,
2006                                          makeArrayRef(Args, NumArgs),RBracLoc,
2007                                          isImplicit));
2008   }
2009
2010   // Find the class to which we are sending this message.
2011   ObjCInterfaceDecl *Class = 0;
2012   const ObjCObjectType *ClassType = ReceiverType->getAs<ObjCObjectType>();
2013   if (!ClassType || !(Class = ClassType->getInterface())) {
2014     Diag(Loc, diag::err_invalid_receiver_class_message)
2015       << ReceiverType;
2016     return ExprError();
2017   }
2018   assert(Class && "We don't know which class we're messaging?");
2019   // objc++ diagnoses during typename annotation.
2020   if (!getLangOpts().CPlusPlus)
2021     (void)DiagnoseUseOfDecl(Class, Loc);
2022   // Find the method we are messaging.
2023   if (!Method) {
2024     SourceRange TypeRange
2025       = SuperLoc.isValid()? SourceRange(SuperLoc)
2026                           : ReceiverTypeInfo->getTypeLoc().getSourceRange();
2027     if (RequireCompleteType(Loc, Context.getObjCInterfaceType(Class),
2028                             (getLangOpts().ObjCAutoRefCount
2029                                ? diag::err_arc_receiver_forward_class
2030                                : diag::warn_receiver_forward_class),
2031                             TypeRange)) {
2032       // A forward class used in messaging is treated as a 'Class'
2033       Method = LookupFactoryMethodInGlobalPool(Sel,
2034                                                SourceRange(LBracLoc, RBracLoc));
2035       if (Method && !getLangOpts().ObjCAutoRefCount)
2036         Diag(Method->getLocation(), diag::note_method_sent_forward_class)
2037           << Method->getDeclName();
2038     }
2039     if (!Method)
2040       Method = Class->lookupClassMethod(Sel);
2041
2042     // If we have an implementation in scope, check "private" methods.
2043     if (!Method)
2044       Method = Class->lookupPrivateClassMethod(Sel);
2045
2046     if (Method && DiagnoseUseOfDecl(Method, Loc))
2047       return ExprError();
2048   }
2049
2050   // Check the argument types and determine the result type.
2051   QualType ReturnType;
2052   ExprValueKind VK = VK_RValue;
2053
2054   unsigned NumArgs = ArgsIn.size();
2055   Expr **Args = ArgsIn.data();
2056   if (CheckMessageArgumentTypes(ReceiverType, Args, NumArgs, Sel, SelectorLocs,
2057                                 Method, true,
2058                                 SuperLoc.isValid(), LBracLoc, RBracLoc,
2059                                 ReturnType, VK))
2060     return ExprError();
2061
2062   if (Method && !Method->getResultType()->isVoidType() &&
2063       RequireCompleteType(LBracLoc, Method->getResultType(),
2064                           diag::err_illegal_message_expr_incomplete_type))
2065     return ExprError();
2066
2067   // Construct the appropriate ObjCMessageExpr.
2068   ObjCMessageExpr *Result;
2069   if (SuperLoc.isValid())
2070     Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2071                                      SuperLoc, /*IsInstanceSuper=*/false,
2072                                      ReceiverType, Sel, SelectorLocs,
2073                                      Method, makeArrayRef(Args, NumArgs),
2074                                      RBracLoc, isImplicit);
2075   else {
2076     Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2077                                      ReceiverTypeInfo, Sel, SelectorLocs,
2078                                      Method, makeArrayRef(Args, NumArgs),
2079                                      RBracLoc, isImplicit);
2080     if (!isImplicit)
2081       checkCocoaAPI(*this, Result);
2082   }
2083   return MaybeBindToTemporary(Result);
2084 }
2085
2086 // ActOnClassMessage - used for both unary and keyword messages.
2087 // ArgExprs is optional - if it is present, the number of expressions
2088 // is obtained from Sel.getNumArgs().
2089 ExprResult Sema::ActOnClassMessage(Scope *S,
2090                                    ParsedType Receiver,
2091                                    Selector Sel,
2092                                    SourceLocation LBracLoc,
2093                                    ArrayRef<SourceLocation> SelectorLocs,
2094                                    SourceLocation RBracLoc,
2095                                    MultiExprArg Args) {
2096   TypeSourceInfo *ReceiverTypeInfo;
2097   QualType ReceiverType = GetTypeFromParser(Receiver, &ReceiverTypeInfo);
2098   if (ReceiverType.isNull())
2099     return ExprError();
2100
2101
2102   if (!ReceiverTypeInfo)
2103     ReceiverTypeInfo = Context.getTrivialTypeSourceInfo(ReceiverType, LBracLoc);
2104
2105   return BuildClassMessage(ReceiverTypeInfo, ReceiverType,
2106                            /*SuperLoc=*/SourceLocation(), Sel, /*Method=*/0,
2107                            LBracLoc, SelectorLocs, RBracLoc, Args);
2108 }
2109
2110 ExprResult Sema::BuildInstanceMessageImplicit(Expr *Receiver,
2111                                               QualType ReceiverType,
2112                                               SourceLocation Loc,
2113                                               Selector Sel,
2114                                               ObjCMethodDecl *Method,
2115                                               MultiExprArg Args) {
2116   return BuildInstanceMessage(Receiver, ReceiverType,
2117                               /*SuperLoc=*/!Receiver ? Loc : SourceLocation(),
2118                               Sel, Method, Loc, Loc, Loc, Args,
2119                               /*isImplicit=*/true);
2120 }
2121
2122 /// \brief Build an Objective-C instance message expression.
2123 ///
2124 /// This routine takes care of both normal instance messages and
2125 /// instance messages to the superclass instance.
2126 ///
2127 /// \param Receiver The expression that computes the object that will
2128 /// receive this message. This may be empty, in which case we are
2129 /// sending to the superclass instance and \p SuperLoc must be a valid
2130 /// source location.
2131 ///
2132 /// \param ReceiverType The (static) type of the object receiving the
2133 /// message. When a \p Receiver expression is provided, this is the
2134 /// same type as that expression. For a superclass instance send, this
2135 /// is a pointer to the type of the superclass.
2136 ///
2137 /// \param SuperLoc The location of the "super" keyword in a
2138 /// superclass instance message.
2139 ///
2140 /// \param Sel The selector to which the message is being sent.
2141 ///
2142 /// \param Method The method that this instance message is invoking, if
2143 /// already known.
2144 ///
2145 /// \param LBracLoc The location of the opening square bracket ']'.
2146 ///
2147 /// \param RBracLoc The location of the closing square bracket ']'.
2148 ///
2149 /// \param ArgsIn The message arguments.
2150 ExprResult Sema::BuildInstanceMessage(Expr *Receiver,
2151                                       QualType ReceiverType,
2152                                       SourceLocation SuperLoc,
2153                                       Selector Sel,
2154                                       ObjCMethodDecl *Method,
2155                                       SourceLocation LBracLoc,
2156                                       ArrayRef<SourceLocation> SelectorLocs,
2157                                       SourceLocation RBracLoc,
2158                                       MultiExprArg ArgsIn,
2159                                       bool isImplicit) {
2160   // The location of the receiver.
2161   SourceLocation Loc = SuperLoc.isValid()? SuperLoc : Receiver->getLocStart();
2162
2163   if (LBracLoc.isInvalid()) {
2164     Diag(Loc, diag::err_missing_open_square_message_send)
2165       << FixItHint::CreateInsertion(Loc, "[");
2166     LBracLoc = Loc;
2167   }
2168
2169   // If we have a receiver expression, perform appropriate promotions
2170   // and determine receiver type.
2171   if (Receiver) {
2172     if (Receiver->hasPlaceholderType()) {
2173       ExprResult Result;
2174       if (Receiver->getType() == Context.UnknownAnyTy)
2175         Result = forceUnknownAnyToType(Receiver, Context.getObjCIdType());
2176       else
2177         Result = CheckPlaceholderExpr(Receiver);
2178       if (Result.isInvalid()) return ExprError();
2179       Receiver = Result.take();
2180     }
2181
2182     if (Receiver->isTypeDependent()) {
2183       // If the receiver is type-dependent, we can't type-check anything
2184       // at this point. Build a dependent expression.
2185       unsigned NumArgs = ArgsIn.size();
2186       Expr **Args = ArgsIn.data();
2187       assert(SuperLoc.isInvalid() && "Message to super with dependent type");
2188       return Owned(ObjCMessageExpr::Create(Context, Context.DependentTy,
2189                                            VK_RValue, LBracLoc, Receiver, Sel,
2190                                            SelectorLocs, /*Method=*/0,
2191                                            makeArrayRef(Args, NumArgs),
2192                                            RBracLoc, isImplicit));
2193     }
2194
2195     // If necessary, apply function/array conversion to the receiver.
2196     // C99 6.7.5.3p[7,8].
2197     ExprResult Result = DefaultFunctionArrayLvalueConversion(Receiver);
2198     if (Result.isInvalid())
2199       return ExprError();
2200     Receiver = Result.take();
2201     ReceiverType = Receiver->getType();
2202
2203     // If the receiver is an ObjC pointer, a block pointer, or an
2204     // __attribute__((NSObject)) pointer, we don't need to do any
2205     // special conversion in order to look up a receiver.
2206     if (ReceiverType->isObjCRetainableType()) {
2207       // do nothing
2208     } else if (!getLangOpts().ObjCAutoRefCount &&
2209                !Context.getObjCIdType().isNull() &&
2210                (ReceiverType->isPointerType() ||
2211                 ReceiverType->isIntegerType())) {
2212       // Implicitly convert integers and pointers to 'id' but emit a warning.
2213       // But not in ARC.
2214       Diag(Loc, diag::warn_bad_receiver_type)
2215         << ReceiverType
2216         << Receiver->getSourceRange();
2217       if (ReceiverType->isPointerType()) {
2218         Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2219                                      CK_CPointerToObjCPointerCast).take();
2220       } else {
2221         // TODO: specialized warning on null receivers?
2222         bool IsNull = Receiver->isNullPointerConstant(Context,
2223                                               Expr::NPC_ValueDependentIsNull);
2224         CastKind Kind = IsNull ? CK_NullToPointer : CK_IntegralToPointer;
2225         Receiver = ImpCastExprToType(Receiver, Context.getObjCIdType(),
2226                                      Kind).take();
2227       }
2228       ReceiverType = Receiver->getType();
2229     } else if (getLangOpts().CPlusPlus) {
2230       ExprResult result = PerformContextuallyConvertToObjCPointer(Receiver);
2231       if (result.isUsable()) {
2232         Receiver = result.take();
2233         ReceiverType = Receiver->getType();
2234       }
2235     }
2236   }
2237
2238   // There's a somewhat weird interaction here where we assume that we
2239   // won't actually have a method unless we also don't need to do some
2240   // of the more detailed type-checking on the receiver.
2241
2242   if (!Method) {
2243     // Handle messages to id.
2244     bool receiverIsId = ReceiverType->isObjCIdType();
2245     if (receiverIsId || ReceiverType->isBlockPointerType() ||
2246         (Receiver && Context.isObjCNSObjectType(Receiver->getType()))) {
2247       Method = LookupInstanceMethodInGlobalPool(Sel,
2248                                                 SourceRange(LBracLoc, RBracLoc),
2249                                                 receiverIsId);
2250       if (!Method)
2251         Method = LookupFactoryMethodInGlobalPool(Sel,
2252                                                  SourceRange(LBracLoc,RBracLoc),
2253                                                  receiverIsId);
2254     } else if (ReceiverType->isObjCClassType() ||
2255                ReceiverType->isObjCQualifiedClassType()) {
2256       // Handle messages to Class.
2257       // We allow sending a message to a qualified Class ("Class<foo>"), which
2258       // is ok as long as one of the protocols implements the selector (if not, warn).
2259       if (const ObjCObjectPointerType *QClassTy
2260             = ReceiverType->getAsObjCQualifiedClassType()) {
2261         // Search protocols for class methods.
2262         Method = LookupMethodInQualifiedType(Sel, QClassTy, false);
2263         if (!Method) {
2264           Method = LookupMethodInQualifiedType(Sel, QClassTy, true);
2265           // warn if instance method found for a Class message.
2266           if (Method) {
2267             Diag(Loc, diag::warn_instance_method_on_class_found)
2268               << Method->getSelector() << Sel;
2269             Diag(Method->getLocation(), diag::note_method_declared_at)
2270               << Method->getDeclName();
2271           }
2272         }
2273       } else {
2274         if (ObjCMethodDecl *CurMeth = getCurMethodDecl()) {
2275           if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface()) {
2276             // First check the public methods in the class interface.
2277             Method = ClassDecl->lookupClassMethod(Sel);
2278
2279             if (!Method)
2280               Method = ClassDecl->lookupPrivateClassMethod(Sel);
2281           }
2282           if (Method && DiagnoseUseOfDecl(Method, Loc))
2283             return ExprError();
2284         }
2285         if (!Method) {
2286           // If not messaging 'self', look for any factory method named 'Sel'.
2287           if (!Receiver || !isSelfExpr(Receiver)) {
2288             Method = LookupFactoryMethodInGlobalPool(Sel,
2289                                                 SourceRange(LBracLoc, RBracLoc),
2290                                                      true);
2291             if (!Method) {
2292               // If no class (factory) method was found, check if an _instance_
2293               // method of the same name exists in the root class only.
2294               Method = LookupInstanceMethodInGlobalPool(Sel,
2295                                                SourceRange(LBracLoc, RBracLoc),
2296                                                         true);
2297               if (Method)
2298                   if (const ObjCInterfaceDecl *ID =
2299                       dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {
2300                     if (ID->getSuperClass())
2301                       Diag(Loc, diag::warn_root_inst_method_not_found)
2302                       << Sel << SourceRange(LBracLoc, RBracLoc);
2303                   }
2304             }
2305           }
2306         }
2307       }
2308     } else {
2309       ObjCInterfaceDecl* ClassDecl = 0;
2310
2311       // We allow sending a message to a qualified ID ("id<foo>"), which is ok as
2312       // long as one of the protocols implements the selector (if not, warn).
2313       // And as long as message is not deprecated/unavailable (warn if it is).
2314       if (const ObjCObjectPointerType *QIdTy
2315                                    = ReceiverType->getAsObjCQualifiedIdType()) {
2316         // Search protocols for instance methods.
2317         Method = LookupMethodInQualifiedType(Sel, QIdTy, true);
2318         if (!Method)
2319           Method = LookupMethodInQualifiedType(Sel, QIdTy, false);
2320         if (Method && DiagnoseUseOfDecl(Method, Loc))
2321           return ExprError();
2322       } else if (const ObjCObjectPointerType *OCIType
2323                    = ReceiverType->getAsObjCInterfacePointerType()) {
2324         // We allow sending a message to a pointer to an interface (an object).
2325         ClassDecl = OCIType->getInterfaceDecl();
2326
2327         // Try to complete the type. Under ARC, this is a hard error from which
2328         // we don't try to recover.
2329         const ObjCInterfaceDecl *forwardClass = 0;
2330         if (RequireCompleteType(Loc, OCIType->getPointeeType(),
2331               getLangOpts().ObjCAutoRefCount
2332                 ? diag::err_arc_receiver_forward_instance
2333                 : diag::warn_receiver_forward_instance,
2334                                 Receiver? Receiver->getSourceRange()
2335                                         : SourceRange(SuperLoc))) {
2336           if (getLangOpts().ObjCAutoRefCount)
2337             return ExprError();
2338
2339           forwardClass = OCIType->getInterfaceDecl();
2340           Diag(Receiver ? Receiver->getLocStart()
2341                         : SuperLoc, diag::note_receiver_is_id);
2342           Method = 0;
2343         } else {
2344           Method = ClassDecl->lookupInstanceMethod(Sel);
2345         }
2346
2347         if (!Method)
2348           // Search protocol qualifiers.
2349           Method = LookupMethodInQualifiedType(Sel, OCIType, true);
2350
2351         if (!Method) {
2352           // If we have implementations in scope, check "private" methods.
2353           Method = ClassDecl->lookupPrivateMethod(Sel);
2354
2355           if (!Method && getLangOpts().ObjCAutoRefCount) {
2356             Diag(Loc, diag::err_arc_may_not_respond)
2357               << OCIType->getPointeeType() << Sel
2358               << SourceRange(SelectorLocs.front(), SelectorLocs.back());
2359             return ExprError();
2360           }
2361
2362           if (!Method && (!Receiver || !isSelfExpr(Receiver))) {
2363             // If we still haven't found a method, look in the global pool. This
2364             // behavior isn't very desirable, however we need it for GCC
2365             // compatibility. FIXME: should we deviate??
2366             if (OCIType->qual_empty()) {
2367               Method = LookupInstanceMethodInGlobalPool(Sel,
2368                                               SourceRange(LBracLoc, RBracLoc));
2369               if (Method && !forwardClass)
2370                 Diag(Loc, diag::warn_maynot_respond)
2371                   << OCIType->getInterfaceDecl()->getIdentifier() << Sel;
2372             }
2373           }
2374         }
2375         if (Method && DiagnoseUseOfDecl(Method, Loc, forwardClass))
2376           return ExprError();
2377       } else {
2378         // Reject other random receiver types (e.g. structs).
2379         Diag(Loc, diag::err_bad_receiver_type)
2380           << ReceiverType << Receiver->getSourceRange();
2381         return ExprError();
2382       }
2383     }
2384   }
2385
2386   // Check the message arguments.
2387   unsigned NumArgs = ArgsIn.size();
2388   Expr **Args = ArgsIn.data();
2389   QualType ReturnType;
2390   ExprValueKind VK = VK_RValue;
2391   bool ClassMessage = (ReceiverType->isObjCClassType() ||
2392                        ReceiverType->isObjCQualifiedClassType());
2393   if (CheckMessageArgumentTypes(ReceiverType, Args, NumArgs, Sel,
2394                                 SelectorLocs, Method,
2395                                 ClassMessage, SuperLoc.isValid(),
2396                                 LBracLoc, RBracLoc, ReturnType, VK))
2397     return ExprError();
2398
2399   if (Method && !Method->getResultType()->isVoidType() &&
2400       RequireCompleteType(LBracLoc, Method->getResultType(),
2401                           diag::err_illegal_message_expr_incomplete_type))
2402     return ExprError();
2403
2404   SourceLocation SelLoc = SelectorLocs.front();
2405
2406   // In ARC, forbid the user from sending messages to
2407   // retain/release/autorelease/dealloc/retainCount explicitly.
2408   if (getLangOpts().ObjCAutoRefCount) {
2409     ObjCMethodFamily family =
2410       (Method ? Method->getMethodFamily() : Sel.getMethodFamily());
2411     switch (family) {
2412     case OMF_init:
2413       if (Method)
2414         checkInitMethod(Method, ReceiverType);
2415
2416     case OMF_None:
2417     case OMF_alloc:
2418     case OMF_copy:
2419     case OMF_finalize:
2420     case OMF_mutableCopy:
2421     case OMF_new:
2422     case OMF_self:
2423       break;
2424
2425     case OMF_dealloc:
2426     case OMF_retain:
2427     case OMF_release:
2428     case OMF_autorelease:
2429     case OMF_retainCount:
2430       Diag(Loc, diag::err_arc_illegal_explicit_message)
2431         << Sel << SelLoc;
2432       break;
2433
2434     case OMF_performSelector:
2435       if (Method && NumArgs >= 1) {
2436         if (ObjCSelectorExpr *SelExp = dyn_cast<ObjCSelectorExpr>(Args[0])) {
2437           Selector ArgSel = SelExp->getSelector();
2438           ObjCMethodDecl *SelMethod =
2439             LookupInstanceMethodInGlobalPool(ArgSel,
2440                                              SelExp->getSourceRange());
2441           if (!SelMethod)
2442             SelMethod =
2443               LookupFactoryMethodInGlobalPool(ArgSel,
2444                                               SelExp->getSourceRange());
2445           if (SelMethod) {
2446             ObjCMethodFamily SelFamily = SelMethod->getMethodFamily();
2447             switch (SelFamily) {
2448               case OMF_alloc:
2449               case OMF_copy:
2450               case OMF_mutableCopy:
2451               case OMF_new:
2452               case OMF_self:
2453               case OMF_init:
2454                 // Issue error, unless ns_returns_not_retained.
2455                 if (!SelMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
2456                   // selector names a +1 method
2457                   Diag(SelLoc,
2458                        diag::err_arc_perform_selector_retains);
2459                   Diag(SelMethod->getLocation(), diag::note_method_declared_at)
2460                     << SelMethod->getDeclName();
2461                 }
2462                 break;
2463               default:
2464                 // +0 call. OK. unless ns_returns_retained.
2465                 if (SelMethod->hasAttr<NSReturnsRetainedAttr>()) {
2466                   // selector names a +1 method
2467                   Diag(SelLoc,
2468                        diag::err_arc_perform_selector_retains);
2469                   Diag(SelMethod->getLocation(), diag::note_method_declared_at)
2470                     << SelMethod->getDeclName();
2471                 }
2472                 break;
2473             }
2474           }
2475         } else {
2476           // error (may leak).
2477           Diag(SelLoc, diag::warn_arc_perform_selector_leaks);
2478           Diag(Args[0]->getExprLoc(), diag::note_used_here);
2479         }
2480       }
2481       break;
2482     }
2483   }
2484
2485   // Construct the appropriate ObjCMessageExpr instance.
2486   ObjCMessageExpr *Result;
2487   if (SuperLoc.isValid())
2488     Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2489                                      SuperLoc,  /*IsInstanceSuper=*/true,
2490                                      ReceiverType, Sel, SelectorLocs, Method,
2491                                      makeArrayRef(Args, NumArgs), RBracLoc,
2492                                      isImplicit);
2493   else {
2494     Result = ObjCMessageExpr::Create(Context, ReturnType, VK, LBracLoc,
2495                                      Receiver, Sel, SelectorLocs, Method,
2496                                      makeArrayRef(Args, NumArgs), RBracLoc,
2497                                      isImplicit);
2498     if (!isImplicit)
2499       checkCocoaAPI(*this, Result);
2500   }
2501
2502   if (getLangOpts().ObjCAutoRefCount) {
2503     DiagnoseARCUseOfWeakReceiver(*this, Receiver);
2504
2505     // In ARC, annotate delegate init calls.
2506     if (Result->getMethodFamily() == OMF_init &&
2507         (SuperLoc.isValid() || isSelfExpr(Receiver))) {
2508       // Only consider init calls *directly* in init implementations,
2509       // not within blocks.
2510       ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(CurContext);
2511       if (method && method->getMethodFamily() == OMF_init) {
2512         // The implicit assignment to self means we also don't want to
2513         // consume the result.
2514         Result->setDelegateInitCall(true);
2515         return Owned(Result);
2516       }
2517     }
2518
2519     // In ARC, check for message sends which are likely to introduce
2520     // retain cycles.
2521     checkRetainCycles(Result);
2522
2523     if (!isImplicit && Method) {
2524       if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) {
2525         bool IsWeak =
2526           Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak;
2527         if (!IsWeak && Sel.isUnarySelector())
2528           IsWeak = ReturnType.getObjCLifetime() & Qualifiers::OCL_Weak;
2529
2530         if (IsWeak) {
2531           DiagnosticsEngine::Level Level =
2532             Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak,
2533                                      LBracLoc);
2534           if (Level != DiagnosticsEngine::Ignored)
2535             getCurFunction()->recordUseOfWeak(Result, Prop);
2536
2537         }
2538       }
2539     }
2540   }
2541
2542   return MaybeBindToTemporary(Result);
2543 }
2544
2545 static void RemoveSelectorFromWarningCache(Sema &S, Expr* Arg) {
2546   if (ObjCSelectorExpr *OSE =
2547       dyn_cast<ObjCSelectorExpr>(Arg->IgnoreParenCasts())) {
2548     Selector Sel = OSE->getSelector();
2549     SourceLocation Loc = OSE->getAtLoc();
2550     llvm::DenseMap<Selector, SourceLocation>::iterator Pos
2551     = S.ReferencedSelectors.find(Sel);
2552     if (Pos != S.ReferencedSelectors.end() && Pos->second == Loc)
2553       S.ReferencedSelectors.erase(Pos);
2554   }
2555 }
2556
2557 // ActOnInstanceMessage - used for both unary and keyword messages.
2558 // ArgExprs is optional - if it is present, the number of expressions
2559 // is obtained from Sel.getNumArgs().
2560 ExprResult Sema::ActOnInstanceMessage(Scope *S,
2561                                       Expr *Receiver,
2562                                       Selector Sel,
2563                                       SourceLocation LBracLoc,
2564                                       ArrayRef<SourceLocation> SelectorLocs,
2565                                       SourceLocation RBracLoc,
2566                                       MultiExprArg Args) {
2567   if (!Receiver)
2568     return ExprError();
2569
2570   // A ParenListExpr can show up while doing error recovery with invalid code.
2571   if (isa<ParenListExpr>(Receiver)) {
2572     ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Receiver);
2573     if (Result.isInvalid()) return ExprError();
2574     Receiver = Result.take();
2575   }
2576
2577   if (RespondsToSelectorSel.isNull()) {
2578     IdentifierInfo *SelectorId = &Context.Idents.get("respondsToSelector");
2579     RespondsToSelectorSel = Context.Selectors.getUnarySelector(SelectorId);
2580   }
2581   if (Sel == RespondsToSelectorSel)
2582     RemoveSelectorFromWarningCache(*this, Args[0]);
2583
2584   return BuildInstanceMessage(Receiver, Receiver->getType(),
2585                               /*SuperLoc=*/SourceLocation(), Sel, /*Method=*/0,
2586                               LBracLoc, SelectorLocs, RBracLoc, Args);
2587 }
2588
2589 enum ARCConversionTypeClass {
2590   /// int, void, struct A
2591   ACTC_none,
2592
2593   /// id, void (^)()
2594   ACTC_retainable,
2595
2596   /// id*, id***, void (^*)(),
2597   ACTC_indirectRetainable,
2598
2599   /// void* might be a normal C type, or it might a CF type.
2600   ACTC_voidPtr,
2601
2602   /// struct A*
2603   ACTC_coreFoundation
2604 };
2605 static bool isAnyRetainable(ARCConversionTypeClass ACTC) {
2606   return (ACTC == ACTC_retainable ||
2607           ACTC == ACTC_coreFoundation ||
2608           ACTC == ACTC_voidPtr);
2609 }
2610 static bool isAnyCLike(ARCConversionTypeClass ACTC) {
2611   return ACTC == ACTC_none ||
2612          ACTC == ACTC_voidPtr ||
2613          ACTC == ACTC_coreFoundation;
2614 }
2615
2616 static ARCConversionTypeClass classifyTypeForARCConversion(QualType type) {
2617   bool isIndirect = false;
2618
2619   // Ignore an outermost reference type.
2620   if (const ReferenceType *ref = type->getAs<ReferenceType>()) {
2621     type = ref->getPointeeType();
2622     isIndirect = true;
2623   }
2624
2625   // Drill through pointers and arrays recursively.
2626   while (true) {
2627     if (const PointerType *ptr = type->getAs<PointerType>()) {
2628       type = ptr->getPointeeType();
2629
2630       // The first level of pointer may be the innermost pointer on a CF type.
2631       if (!isIndirect) {
2632         if (type->isVoidType()) return ACTC_voidPtr;
2633         if (type->isRecordType()) return ACTC_coreFoundation;
2634       }
2635     } else if (const ArrayType *array = type->getAsArrayTypeUnsafe()) {
2636       type = QualType(array->getElementType()->getBaseElementTypeUnsafe(), 0);
2637     } else {
2638       break;
2639     }
2640     isIndirect = true;
2641   }
2642
2643   if (isIndirect) {
2644     if (type->isObjCARCBridgableType())
2645       return ACTC_indirectRetainable;
2646     return ACTC_none;
2647   }
2648
2649   if (type->isObjCARCBridgableType())
2650     return ACTC_retainable;
2651
2652   return ACTC_none;
2653 }
2654
2655 namespace {
2656   /// A result from the cast checker.
2657   enum ACCResult {
2658     /// Cannot be casted.
2659     ACC_invalid,
2660
2661     /// Can be safely retained or not retained.
2662     ACC_bottom,
2663
2664     /// Can be casted at +0.
2665     ACC_plusZero,
2666
2667     /// Can be casted at +1.
2668     ACC_plusOne
2669   };
2670   ACCResult merge(ACCResult left, ACCResult right) {
2671     if (left == right) return left;
2672     if (left == ACC_bottom) return right;
2673     if (right == ACC_bottom) return left;
2674     return ACC_invalid;
2675   }
2676
2677   /// A checker which white-lists certain expressions whose conversion
2678   /// to or from retainable type would otherwise be forbidden in ARC.
2679   class ARCCastChecker : public StmtVisitor<ARCCastChecker, ACCResult> {
2680     typedef StmtVisitor<ARCCastChecker, ACCResult> super;
2681
2682     ASTContext &Context;
2683     ARCConversionTypeClass SourceClass;
2684     ARCConversionTypeClass TargetClass;
2685     bool Diagnose;
2686
2687     static bool isCFType(QualType type) {
2688       // Someday this can use ns_bridged.  For now, it has to do this.
2689       return type->isCARCBridgableType();
2690     }
2691
2692   public:
2693     ARCCastChecker(ASTContext &Context, ARCConversionTypeClass source,
2694                    ARCConversionTypeClass target, bool diagnose)
2695       : Context(Context), SourceClass(source), TargetClass(target),
2696         Diagnose(diagnose) {}
2697
2698     using super::Visit;
2699     ACCResult Visit(Expr *e) {
2700       return super::Visit(e->IgnoreParens());
2701     }
2702
2703     ACCResult VisitStmt(Stmt *s) {
2704       return ACC_invalid;
2705     }
2706
2707     /// Null pointer constants can be casted however you please.
2708     ACCResult VisitExpr(Expr *e) {
2709       if (e->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull))
2710         return ACC_bottom;
2711       return ACC_invalid;
2712     }
2713
2714     /// Objective-C string literals can be safely casted.
2715     ACCResult VisitObjCStringLiteral(ObjCStringLiteral *e) {
2716       // If we're casting to any retainable type, go ahead.  Global
2717       // strings are immune to retains, so this is bottom.
2718       if (isAnyRetainable(TargetClass)) return ACC_bottom;
2719
2720       return ACC_invalid;
2721     }
2722
2723     /// Look through certain implicit and explicit casts.
2724     ACCResult VisitCastExpr(CastExpr *e) {
2725       switch (e->getCastKind()) {
2726         case CK_NullToPointer:
2727           return ACC_bottom;
2728
2729         case CK_NoOp:
2730         case CK_LValueToRValue:
2731         case CK_BitCast:
2732         case CK_CPointerToObjCPointerCast:
2733         case CK_BlockPointerToObjCPointerCast:
2734         case CK_AnyPointerToBlockPointerCast:
2735           return Visit(e->getSubExpr());
2736
2737         default:
2738           return ACC_invalid;
2739       }
2740     }
2741
2742     /// Look through unary extension.
2743     ACCResult VisitUnaryExtension(UnaryOperator *e) {
2744       return Visit(e->getSubExpr());
2745     }
2746
2747     /// Ignore the LHS of a comma operator.
2748     ACCResult VisitBinComma(BinaryOperator *e) {
2749       return Visit(e->getRHS());
2750     }
2751
2752     /// Conditional operators are okay if both sides are okay.
2753     ACCResult VisitConditionalOperator(ConditionalOperator *e) {
2754       ACCResult left = Visit(e->getTrueExpr());
2755       if (left == ACC_invalid) return ACC_invalid;
2756       return merge(left, Visit(e->getFalseExpr()));
2757     }
2758
2759     /// Look through pseudo-objects.
2760     ACCResult VisitPseudoObjectExpr(PseudoObjectExpr *e) {
2761       // If we're getting here, we should always have a result.
2762       return Visit(e->getResultExpr());
2763     }
2764
2765     /// Statement expressions are okay if their result expression is okay.
2766     ACCResult VisitStmtExpr(StmtExpr *e) {
2767       return Visit(e->getSubStmt()->body_back());
2768     }
2769
2770     /// Some declaration references are okay.
2771     ACCResult VisitDeclRefExpr(DeclRefExpr *e) {
2772       // References to global constants from system headers are okay.
2773       // These are things like 'kCFStringTransformToLatin'.  They are
2774       // can also be assumed to be immune to retains.
2775       VarDecl *var = dyn_cast<VarDecl>(e->getDecl());
2776       if (isAnyRetainable(TargetClass) &&
2777           isAnyRetainable(SourceClass) &&
2778           var &&
2779           var->getStorageClass() == SC_Extern &&
2780           var->getType().isConstQualified() &&
2781           Context.getSourceManager().isInSystemHeader(var->getLocation())) {
2782         return ACC_bottom;
2783       }
2784
2785       // Nothing else.
2786       return ACC_invalid;
2787     }
2788
2789     /// Some calls are okay.
2790     ACCResult VisitCallExpr(CallExpr *e) {
2791       if (FunctionDecl *fn = e->getDirectCallee())
2792         if (ACCResult result = checkCallToFunction(fn))
2793           return result;
2794
2795       return super::VisitCallExpr(e);
2796     }
2797
2798     ACCResult checkCallToFunction(FunctionDecl *fn) {
2799       // Require a CF*Ref return type.
2800       if (!isCFType(fn->getResultType()))
2801         return ACC_invalid;
2802
2803       if (!isAnyRetainable(TargetClass))
2804         return ACC_invalid;
2805
2806       // Honor an explicit 'not retained' attribute.
2807       if (fn->hasAttr<CFReturnsNotRetainedAttr>())
2808         return ACC_plusZero;
2809
2810       // Honor an explicit 'retained' attribute, except that for
2811       // now we're not going to permit implicit handling of +1 results,
2812       // because it's a bit frightening.
2813       if (fn->hasAttr<CFReturnsRetainedAttr>())
2814         return Diagnose ? ACC_plusOne
2815                         : ACC_invalid; // ACC_plusOne if we start accepting this
2816
2817       // Recognize this specific builtin function, which is used by CFSTR.
2818       unsigned builtinID = fn->getBuiltinID();
2819       if (builtinID == Builtin::BI__builtin___CFStringMakeConstantString)
2820         return ACC_bottom;
2821
2822       // Otherwise, don't do anything implicit with an unaudited function.
2823       if (!fn->hasAttr<CFAuditedTransferAttr>())
2824         return ACC_invalid;
2825
2826       // Otherwise, it's +0 unless it follows the create convention.
2827       if (ento::coreFoundation::followsCreateRule(fn))
2828         return Diagnose ? ACC_plusOne
2829                         : ACC_invalid; // ACC_plusOne if we start accepting this
2830
2831       return ACC_plusZero;
2832     }
2833
2834     ACCResult VisitObjCMessageExpr(ObjCMessageExpr *e) {
2835       return checkCallToMethod(e->getMethodDecl());
2836     }
2837
2838     ACCResult VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *e) {
2839       ObjCMethodDecl *method;
2840       if (e->isExplicitProperty())
2841         method = e->getExplicitProperty()->getGetterMethodDecl();
2842       else
2843         method = e->getImplicitPropertyGetter();
2844       return checkCallToMethod(method);
2845     }
2846
2847     ACCResult checkCallToMethod(ObjCMethodDecl *method) {
2848       if (!method) return ACC_invalid;
2849
2850       // Check for message sends to functions returning CF types.  We
2851       // just obey the Cocoa conventions with these, even though the
2852       // return type is CF.
2853       if (!isAnyRetainable(TargetClass) || !isCFType(method->getResultType()))
2854         return ACC_invalid;
2855
2856       // If the method is explicitly marked not-retained, it's +0.
2857       if (method->hasAttr<CFReturnsNotRetainedAttr>())
2858         return ACC_plusZero;
2859
2860       // If the method is explicitly marked as returning retained, or its
2861       // selector follows a +1 Cocoa convention, treat it as +1.
2862       if (method->hasAttr<CFReturnsRetainedAttr>())
2863         return ACC_plusOne;
2864
2865       switch (method->getSelector().getMethodFamily()) {
2866       case OMF_alloc:
2867       case OMF_copy:
2868       case OMF_mutableCopy:
2869       case OMF_new:
2870         return ACC_plusOne;
2871
2872       default:
2873         // Otherwise, treat it as +0.
2874         return ACC_plusZero;
2875       }
2876     }
2877   };
2878 }
2879
2880 bool Sema::isKnownName(StringRef name) {
2881   if (name.empty())
2882     return false;
2883   LookupResult R(*this, &Context.Idents.get(name), SourceLocation(),
2884                  Sema::LookupOrdinaryName);
2885   return LookupName(R, TUScope, false);
2886 }
2887
2888 static void addFixitForObjCARCConversion(Sema &S,
2889                                          DiagnosticBuilder &DiagB,
2890                                          Sema::CheckedConversionKind CCK,
2891                                          SourceLocation afterLParen,
2892                                          QualType castType,
2893                                          Expr *castExpr,
2894                                          Expr *realCast,
2895                                          const char *bridgeKeyword,
2896                                          const char *CFBridgeName) {
2897   // We handle C-style and implicit casts here.
2898   switch (CCK) {
2899   case Sema::CCK_ImplicitConversion:
2900   case Sema::CCK_CStyleCast:
2901   case Sema::CCK_OtherCast:
2902     break;
2903   case Sema::CCK_FunctionalCast:
2904     return;
2905   }
2906
2907   if (CFBridgeName) {
2908     if (CCK == Sema::CCK_OtherCast) {
2909       if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
2910         SourceRange range(NCE->getOperatorLoc(),
2911                           NCE->getAngleBrackets().getEnd());
2912         SmallString<32> BridgeCall;
2913
2914         SourceManager &SM = S.getSourceManager();
2915         char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
2916         if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
2917           BridgeCall += ' ';
2918
2919         BridgeCall += CFBridgeName;
2920         DiagB.AddFixItHint(FixItHint::CreateReplacement(range, BridgeCall));
2921       }
2922       return;
2923     }
2924     Expr *castedE = castExpr;
2925     if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(castedE))
2926       castedE = CCE->getSubExpr();
2927     castedE = castedE->IgnoreImpCasts();
2928     SourceRange range = castedE->getSourceRange();
2929
2930     SmallString<32> BridgeCall;
2931
2932     SourceManager &SM = S.getSourceManager();
2933     char PrevChar = *SM.getCharacterData(range.getBegin().getLocWithOffset(-1));
2934     if (Lexer::isIdentifierBodyChar(PrevChar, S.getLangOpts()))
2935       BridgeCall += ' ';
2936
2937     BridgeCall += CFBridgeName;
2938
2939     if (isa<ParenExpr>(castedE)) {
2940       DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
2941                          BridgeCall));
2942     } else {
2943       BridgeCall += '(';
2944       DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
2945                                                     BridgeCall));
2946       DiagB.AddFixItHint(FixItHint::CreateInsertion(
2947                                        S.PP.getLocForEndOfToken(range.getEnd()),
2948                                        ")"));
2949     }
2950     return;
2951   }
2952
2953   if (CCK == Sema::CCK_CStyleCast) {
2954     DiagB.AddFixItHint(FixItHint::CreateInsertion(afterLParen, bridgeKeyword));
2955   } else if (CCK == Sema::CCK_OtherCast) {
2956     if (const CXXNamedCastExpr *NCE = dyn_cast<CXXNamedCastExpr>(realCast)) {
2957       std::string castCode = "(";
2958       castCode += bridgeKeyword;
2959       castCode += castType.getAsString();
2960       castCode += ")";
2961       SourceRange Range(NCE->getOperatorLoc(),
2962                         NCE->getAngleBrackets().getEnd());
2963       DiagB.AddFixItHint(FixItHint::CreateReplacement(Range, castCode));
2964     }
2965   } else {
2966     std::string castCode = "(";
2967     castCode += bridgeKeyword;
2968     castCode += castType.getAsString();
2969     castCode += ")";
2970     Expr *castedE = castExpr->IgnoreImpCasts();
2971     SourceRange range = castedE->getSourceRange();
2972     if (isa<ParenExpr>(castedE)) {
2973       DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
2974                          castCode));
2975     } else {
2976       castCode += "(";
2977       DiagB.AddFixItHint(FixItHint::CreateInsertion(range.getBegin(),
2978                                                     castCode));
2979       DiagB.AddFixItHint(FixItHint::CreateInsertion(
2980                                        S.PP.getLocForEndOfToken(range.getEnd()),
2981                                        ")"));
2982     }
2983   }
2984 }
2985
2986 static void
2987 diagnoseObjCARCConversion(Sema &S, SourceRange castRange,
2988                           QualType castType, ARCConversionTypeClass castACTC,
2989                           Expr *castExpr, Expr *realCast,
2990                           ARCConversionTypeClass exprACTC,
2991                           Sema::CheckedConversionKind CCK) {
2992   SourceLocation loc =
2993     (castRange.isValid() ? castRange.getBegin() : castExpr->getExprLoc());
2994
2995   if (S.makeUnavailableInSystemHeader(loc,
2996                 "converts between Objective-C and C pointers in -fobjc-arc"))
2997     return;
2998
2999   QualType castExprType = castExpr->getType();
3000
3001   unsigned srcKind = 0;
3002   switch (exprACTC) {
3003   case ACTC_none:
3004   case ACTC_coreFoundation:
3005   case ACTC_voidPtr:
3006     srcKind = (castExprType->isPointerType() ? 1 : 0);
3007     break;
3008   case ACTC_retainable:
3009     srcKind = (castExprType->isBlockPointerType() ? 2 : 3);
3010     break;
3011   case ACTC_indirectRetainable:
3012     srcKind = 4;
3013     break;
3014   }
3015
3016   // Check whether this could be fixed with a bridge cast.
3017   SourceLocation afterLParen = S.PP.getLocForEndOfToken(castRange.getBegin());
3018   SourceLocation noteLoc = afterLParen.isValid() ? afterLParen : loc;
3019
3020   // Bridge from an ARC type to a CF type.
3021   if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {
3022
3023     S.Diag(loc, diag::err_arc_cast_requires_bridge)
3024       << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit
3025       << 2 // of C pointer type
3026       << castExprType
3027       << unsigned(castType->isBlockPointerType()) // to ObjC|block type
3028       << castType
3029       << castRange
3030       << castExpr->getSourceRange();
3031     bool br = S.isKnownName("CFBridgingRelease");
3032     ACCResult CreateRule =
3033       ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3034     assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3035     if (CreateRule != ACC_plusOne)
3036     {
3037       DiagnosticBuilder DiagB =
3038         (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3039                               : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3040
3041       addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3042                                    castType, castExpr, realCast, "__bridge ", 0);
3043     }
3044     if (CreateRule != ACC_plusZero)
3045     {
3046       DiagnosticBuilder DiagB =
3047         (CCK == Sema::CCK_OtherCast && !br) ?
3048           S.Diag(noteLoc, diag::note_arc_cstyle_bridge_transfer) << castExprType :
3049           S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3050                  diag::note_arc_bridge_transfer)
3051             << castExprType << br;
3052
3053       addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3054                                    castType, castExpr, realCast, "__bridge_transfer ",
3055                                    br ? "CFBridgingRelease" : 0);
3056     }
3057
3058     return;
3059   }
3060
3061   // Bridge from a CF type to an ARC type.
3062   if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {
3063     bool br = S.isKnownName("CFBridgingRetain");
3064     S.Diag(loc, diag::err_arc_cast_requires_bridge)
3065       << unsigned(CCK == Sema::CCK_ImplicitConversion) // cast|implicit
3066       << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type
3067       << castExprType
3068       << 2 // to C pointer type
3069       << castType
3070       << castRange
3071       << castExpr->getSourceRange();
3072     ACCResult CreateRule =
3073       ARCCastChecker(S.Context, exprACTC, castACTC, true).Visit(castExpr);
3074     assert(CreateRule != ACC_bottom && "This cast should already be accepted.");
3075     if (CreateRule != ACC_plusOne)
3076     {
3077       DiagnosticBuilder DiagB =
3078       (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge)
3079                                : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);
3080       addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3081                                    castType, castExpr, realCast, "__bridge ", 0);
3082     }
3083     if (CreateRule != ACC_plusZero)
3084     {
3085       DiagnosticBuilder DiagB =
3086         (CCK == Sema::CCK_OtherCast && !br) ?
3087           S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained) << castType :
3088           S.Diag(br ? castExpr->getExprLoc() : noteLoc,
3089                  diag::note_arc_bridge_retained)
3090             << castType << br;
3091
3092       addFixitForObjCARCConversion(S, DiagB, CCK, afterLParen,
3093                                    castType, castExpr, realCast, "__bridge_retained ",
3094                                    br ? "CFBridgingRetain" : 0);
3095     }
3096
3097     return;
3098   }
3099
3100   S.Diag(loc, diag::err_arc_mismatched_cast)
3101     << (CCK != Sema::CCK_ImplicitConversion)
3102     << srcKind << castExprType << castType
3103     << castRange << castExpr->getSourceRange();
3104 }
3105
3106 Sema::ARCConversionResult
3107 Sema::CheckObjCARCConversion(SourceRange castRange, QualType castType,
3108                              Expr *&castExpr, CheckedConversionKind CCK) {
3109   QualType castExprType = castExpr->getType();
3110
3111   // For the purposes of the classification, we assume reference types
3112   // will bind to temporaries.
3113   QualType effCastType = castType;
3114   if (const ReferenceType *ref = castType->getAs<ReferenceType>())
3115     effCastType = ref->getPointeeType();
3116
3117   ARCConversionTypeClass exprACTC = classifyTypeForARCConversion(castExprType);
3118   ARCConversionTypeClass castACTC = classifyTypeForARCConversion(effCastType);
3119   if (exprACTC == castACTC) {
3120     // check for viablity and report error if casting an rvalue to a
3121     // life-time qualifier.
3122     if ((castACTC == ACTC_retainable) &&
3123         (CCK == CCK_CStyleCast || CCK == CCK_OtherCast) &&
3124         (castType != castExprType)) {
3125       const Type *DT = castType.getTypePtr();
3126       QualType QDT = castType;
3127       // We desugar some types but not others. We ignore those
3128       // that cannot happen in a cast; i.e. auto, and those which
3129       // should not be de-sugared; i.e typedef.
3130       if (const ParenType *PT = dyn_cast<ParenType>(DT))
3131         QDT = PT->desugar();
3132       else if (const TypeOfType *TP = dyn_cast<TypeOfType>(DT))
3133         QDT = TP->desugar();
3134       else if (const AttributedType *AT = dyn_cast<AttributedType>(DT))
3135         QDT = AT->desugar();
3136       if (QDT != castType &&
3137           QDT.getObjCLifetime() !=  Qualifiers::OCL_None) {
3138         SourceLocation loc =
3139           (castRange.isValid() ? castRange.getBegin()
3140                               : castExpr->getExprLoc());
3141         Diag(loc, diag::err_arc_nolifetime_behavior);
3142       }
3143     }
3144     return ACR_okay;
3145   }
3146
3147   if (isAnyCLike(exprACTC) && isAnyCLike(castACTC)) return ACR_okay;
3148
3149   // Allow all of these types to be cast to integer types (but not
3150   // vice-versa).
3151   if (castACTC == ACTC_none && castType->isIntegralType(Context))
3152     return ACR_okay;
3153
3154   // Allow casts between pointers to lifetime types (e.g., __strong id*)
3155   // and pointers to void (e.g., cv void *). Casting from void* to lifetime*
3156   // must be explicit.
3157   if (exprACTC == ACTC_indirectRetainable && castACTC == ACTC_voidPtr)
3158     return ACR_okay;
3159   if (castACTC == ACTC_indirectRetainable && exprACTC == ACTC_voidPtr &&
3160       CCK != CCK_ImplicitConversion)
3161     return ACR_okay;
3162
3163   switch (ARCCastChecker(Context, exprACTC, castACTC, false).Visit(castExpr)) {
3164   // For invalid casts, fall through.
3165   case ACC_invalid:
3166     break;
3167
3168   // Do nothing for both bottom and +0.
3169   case ACC_bottom:
3170   case ACC_plusZero:
3171     return ACR_okay;
3172
3173   // If the result is +1, consume it here.
3174   case ACC_plusOne:
3175     castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(),
3176                                         CK_ARCConsumeObject, castExpr,
3177                                         0, VK_RValue);
3178     ExprNeedsCleanups = true;
3179     return ACR_okay;
3180   }
3181
3182   // If this is a non-implicit cast from id or block type to a
3183   // CoreFoundation type, delay complaining in case the cast is used
3184   // in an acceptable context.
3185   if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC) &&
3186       CCK != CCK_ImplicitConversion)
3187     return ACR_unbridged;
3188
3189   diagnoseObjCARCConversion(*this, castRange, castType, castACTC,
3190                             castExpr, castExpr, exprACTC, CCK);
3191   return ACR_okay;
3192 }
3193
3194 /// Given that we saw an expression with the ARCUnbridgedCastTy
3195 /// placeholder type, complain bitterly.
3196 void Sema::diagnoseARCUnbridgedCast(Expr *e) {
3197   // We expect the spurious ImplicitCastExpr to already have been stripped.
3198   assert(!e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
3199   CastExpr *realCast = cast<CastExpr>(e->IgnoreParens());
3200
3201   SourceRange castRange;
3202   QualType castType;
3203   CheckedConversionKind CCK;
3204
3205   if (CStyleCastExpr *cast = dyn_cast<CStyleCastExpr>(realCast)) {
3206     castRange = SourceRange(cast->getLParenLoc(), cast->getRParenLoc());
3207     castType = cast->getTypeAsWritten();
3208     CCK = CCK_CStyleCast;
3209   } else if (ExplicitCastExpr *cast = dyn_cast<ExplicitCastExpr>(realCast)) {
3210     castRange = cast->getTypeInfoAsWritten()->getTypeLoc().getSourceRange();
3211     castType = cast->getTypeAsWritten();
3212     CCK = CCK_OtherCast;
3213   } else {
3214     castType = cast->getType();
3215     CCK = CCK_ImplicitConversion;
3216   }
3217
3218   ARCConversionTypeClass castACTC =
3219     classifyTypeForARCConversion(castType.getNonReferenceType());
3220
3221   Expr *castExpr = realCast->getSubExpr();
3222   assert(classifyTypeForARCConversion(castExpr->getType()) == ACTC_retainable);
3223
3224   diagnoseObjCARCConversion(*this, castRange, castType, castACTC,
3225                             castExpr, realCast, ACTC_retainable, CCK);
3226 }
3227
3228 /// stripARCUnbridgedCast - Given an expression of ARCUnbridgedCast
3229 /// type, remove the placeholder cast.
3230 Expr *Sema::stripARCUnbridgedCast(Expr *e) {
3231   assert(e->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
3232
3233   if (ParenExpr *pe = dyn_cast<ParenExpr>(e)) {
3234     Expr *sub = stripARCUnbridgedCast(pe->getSubExpr());
3235     return new (Context) ParenExpr(pe->getLParen(), pe->getRParen(), sub);
3236   } else if (UnaryOperator *uo = dyn_cast<UnaryOperator>(e)) {
3237     assert(uo->getOpcode() == UO_Extension);
3238     Expr *sub = stripARCUnbridgedCast(uo->getSubExpr());
3239     return new (Context) UnaryOperator(sub, UO_Extension, sub->getType(),
3240                                    sub->getValueKind(), sub->getObjectKind(),
3241                                        uo->getOperatorLoc());
3242   } else if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
3243     assert(!gse->isResultDependent());
3244
3245     unsigned n = gse->getNumAssocs();
3246     SmallVector<Expr*, 4> subExprs(n);
3247     SmallVector<TypeSourceInfo*, 4> subTypes(n);
3248     for (unsigned i = 0; i != n; ++i) {
3249       subTypes[i] = gse->getAssocTypeSourceInfo(i);
3250       Expr *sub = gse->getAssocExpr(i);
3251       if (i == gse->getResultIndex())
3252         sub = stripARCUnbridgedCast(sub);
3253       subExprs[i] = sub;
3254     }
3255
3256     return new (Context) GenericSelectionExpr(Context, gse->getGenericLoc(),
3257                                               gse->getControllingExpr(),
3258                                               subTypes, subExprs,
3259                                               gse->getDefaultLoc(),
3260                                               gse->getRParenLoc(),
3261                                        gse->containsUnexpandedParameterPack(),
3262                                               gse->getResultIndex());
3263   } else {
3264     assert(isa<ImplicitCastExpr>(e) && "bad form of unbridged cast!");
3265     return cast<ImplicitCastExpr>(e)->getSubExpr();
3266   }
3267 }
3268
3269 bool Sema::CheckObjCARCUnavailableWeakConversion(QualType castType,
3270                                                  QualType exprType) {
3271   QualType canCastType =
3272     Context.getCanonicalType(castType).getUnqualifiedType();
3273   QualType canExprType =
3274     Context.getCanonicalType(exprType).getUnqualifiedType();
3275   if (isa<ObjCObjectPointerType>(canCastType) &&
3276       castType.getObjCLifetime() == Qualifiers::OCL_Weak &&
3277       canExprType->isObjCObjectPointerType()) {
3278     if (const ObjCObjectPointerType *ObjT =
3279         canExprType->getAs<ObjCObjectPointerType>())
3280       if (const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl())
3281         return !ObjI->isArcWeakrefUnavailable();
3282   }
3283   return true;
3284 }
3285
3286 /// Look for an ObjCReclaimReturnedObject cast and destroy it.
3287 static Expr *maybeUndoReclaimObject(Expr *e) {
3288   // For now, we just undo operands that are *immediately* reclaim
3289   // expressions, which prevents the vast majority of potential
3290   // problems here.  To catch them all, we'd need to rebuild arbitrary
3291   // value-propagating subexpressions --- we can't reliably rebuild
3292   // in-place because of expression sharing.
3293   if (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
3294     if (ice->getCastKind() == CK_ARCReclaimReturnedObject)
3295       return ice->getSubExpr();
3296
3297   return e;
3298 }
3299
3300 ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc,
3301                                       ObjCBridgeCastKind Kind,
3302                                       SourceLocation BridgeKeywordLoc,
3303                                       TypeSourceInfo *TSInfo,
3304                                       Expr *SubExpr) {
3305   ExprResult SubResult = UsualUnaryConversions(SubExpr);
3306   if (SubResult.isInvalid()) return ExprError();
3307   SubExpr = SubResult.take();
3308
3309   QualType T = TSInfo->getType();
3310   QualType FromType = SubExpr->getType();
3311
3312   CastKind CK;
3313
3314   bool MustConsume = false;
3315   if (T->isDependentType() || SubExpr->isTypeDependent()) {
3316     // Okay: we'll build a dependent expression type.
3317     CK = CK_Dependent;
3318   } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {
3319     // Casting CF -> id
3320     CK = (T->isBlockPointerType() ? CK_AnyPointerToBlockPointerCast
3321                                   : CK_CPointerToObjCPointerCast);
3322     switch (Kind) {
3323     case OBC_Bridge:
3324       break;
3325
3326     case OBC_BridgeRetained: {
3327       bool br = isKnownName("CFBridgingRelease");
3328       Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
3329         << 2
3330         << FromType
3331         << (T->isBlockPointerType()? 1 : 0)
3332         << T
3333         << SubExpr->getSourceRange()
3334         << Kind;
3335       Diag(BridgeKeywordLoc, diag::note_arc_bridge)
3336         << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge");
3337       Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer)
3338         << FromType << br
3339         << FixItHint::CreateReplacement(BridgeKeywordLoc,
3340                                         br ? "CFBridgingRelease "
3341                                            : "__bridge_transfer ");
3342
3343       Kind = OBC_Bridge;
3344       break;
3345     }
3346
3347     case OBC_BridgeTransfer:
3348       // We must consume the Objective-C object produced by the cast.
3349       MustConsume = true;
3350       break;
3351     }
3352   } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {
3353     // Okay: id -> CF
3354     CK = CK_BitCast;
3355     switch (Kind) {
3356     case OBC_Bridge:
3357       // Reclaiming a value that's going to be __bridge-casted to CF
3358       // is very dangerous, so we don't do it.
3359       SubExpr = maybeUndoReclaimObject(SubExpr);
3360       break;
3361
3362     case OBC_BridgeRetained:
3363       // Produce the object before casting it.
3364       SubExpr = ImplicitCastExpr::Create(Context, FromType,
3365                                          CK_ARCProduceObject,
3366                                          SubExpr, 0, VK_RValue);
3367       break;
3368
3369     case OBC_BridgeTransfer: {
3370       bool br = isKnownName("CFBridgingRetain");
3371       Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
3372         << (FromType->isBlockPointerType()? 1 : 0)
3373         << FromType
3374         << 2
3375         << T
3376         << SubExpr->getSourceRange()
3377         << Kind;
3378
3379       Diag(BridgeKeywordLoc, diag::note_arc_bridge)
3380         << FixItHint::CreateReplacement(BridgeKeywordLoc, "__bridge ");
3381       Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained)
3382         << T << br
3383         << FixItHint::CreateReplacement(BridgeKeywordLoc,
3384                           br ? "CFBridgingRetain " : "__bridge_retained");
3385
3386       Kind = OBC_Bridge;
3387       break;
3388     }
3389     }
3390   } else {
3391     Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible)
3392       << FromType << T << Kind
3393       << SubExpr->getSourceRange()
3394       << TSInfo->getTypeLoc().getSourceRange();
3395     return ExprError();
3396   }
3397
3398   Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK,
3399                                                    BridgeKeywordLoc,
3400                                                    TSInfo, SubExpr);
3401
3402   if (MustConsume) {
3403     ExprNeedsCleanups = true;
3404     Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result,
3405                                       0, VK_RValue);
3406   }
3407
3408   return Result;
3409 }
3410
3411 ExprResult Sema::ActOnObjCBridgedCast(Scope *S,
3412                                       SourceLocation LParenLoc,
3413                                       ObjCBridgeCastKind Kind,
3414                                       SourceLocation BridgeKeywordLoc,
3415                                       ParsedType Type,
3416                                       SourceLocation RParenLoc,
3417                                       Expr *SubExpr) {
3418   TypeSourceInfo *TSInfo = 0;
3419   QualType T = GetTypeFromParser(Type, &TSInfo);
3420   if (!TSInfo)
3421     TSInfo = Context.getTrivialTypeSourceInfo(T, LParenLoc);
3422   return BuildObjCBridgedCast(LParenLoc, Kind, BridgeKeywordLoc, TSInfo,
3423                               SubExpr);
3424 }