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