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