contrib/llvm/tools/clang/lib/Sema/SemaCast.cpp

   1 //===--- SemaCast.cpp - Semantic Analysis for Casts -----------------------===//
   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 cast expressions, including
  11 //  1) C-style casts like '(int) x'
  12 //  2) C++ functional casts like 'int(x)'
  13 //  3) C++ named casts like 'static_cast<int>(x)'
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "clang/Sema/SemaInternal.h"
  18 #include "clang/AST/ASTContext.h"
  19 #include "clang/AST/CXXInheritance.h"
  20 #include "clang/AST/ExprCXX.h"
  21 #include "clang/AST/ExprObjC.h"
  22 #include "clang/AST/RecordLayout.h"
  23 #include "clang/Basic/PartialDiagnostic.h"
  24 #include "clang/Basic/TargetInfo.h"
  25 #include "clang/Sema/Initialization.h"
  26 #include "llvm/ADT/SmallVector.h"
  27 #include <set>
  28 using namespace clang;
  29
  30
  31
  32 enum TryCastResult {
  33   TC_NotApplicable, ///< The cast method is not applicable.
  34   TC_Success,       ///< The cast method is appropriate and successful.
  35   TC_Failed         ///< The cast method is appropriate, but failed. A
  36                     ///< diagnostic has been emitted.
  37 };
  38
  39 enum CastType {
  40   CT_Const,       ///< const_cast
  41   CT_Static,      ///< static_cast
  42   CT_Reinterpret, ///< reinterpret_cast
  43   CT_Dynamic,     ///< dynamic_cast
  44   CT_CStyle,      ///< (Type)expr
  45   CT_Functional   ///< Type(expr)
  46 };
  47
  48 namespace {
  49   struct CastOperation {
  50     CastOperation(Sema &S, QualType destType, ExprResult src)
  51       : Self(S), SrcExpr(src), DestType(destType),
  52         ResultType(destType.getNonLValueExprType(S.Context)),
  53         ValueKind(Expr::getValueKindForType(destType)),
  54         Kind(CK_Dependent), IsARCUnbridgedCast(false) {
  55
  56       if (const BuiltinType *placeholder =
  57             src.get()->getType()->getAsPlaceholderType()) {
  58         PlaceholderKind = placeholder->getKind();
  59       } else {
  60         PlaceholderKind = (BuiltinType::Kind) 0;
  61       }
  62     }
  63
  64     Sema &Self;
  65     ExprResult SrcExpr;
  66     QualType DestType;
  67     QualType ResultType;
  68     ExprValueKind ValueKind;
  69     CastKind Kind;
  70     BuiltinType::Kind PlaceholderKind;
  71     CXXCastPath BasePath;
  72     bool IsARCUnbridgedCast;
  73
  74     SourceRange OpRange;
  75     SourceRange DestRange;
  76
  77     // Top-level semantics-checking routines.
  78     void CheckConstCast();
  79     void CheckReinterpretCast();
  80     void CheckStaticCast();
  81     void CheckDynamicCast();
  82     void CheckCXXCStyleCast(bool FunctionalCast, bool ListInitialization);
  83     void CheckCStyleCast();
  84
  85     /// Complete an apparently-successful cast operation that yields
  86     /// the given expression.
  87     ExprResult complete(CastExpr *castExpr) {
  88       // If this is an unbridged cast, wrap the result in an implicit
  89       // cast that yields the unbridged-cast placeholder type.
  90       if (IsARCUnbridgedCast) {
  91         castExpr = ImplicitCastExpr::Create(Self.Context,
  92                                             Self.Context.ARCUnbridgedCastTy,
  93                                             CK_Dependent, castExpr, nullptr,
  94                                             castExpr->getValueKind());
  95       }
  96       return castExpr;
  97     }
  98
  99     // Internal convenience methods.
 100
 101     /// Try to handle the given placeholder expression kind.  Return
 102     /// true if the source expression has the appropriate placeholder
 103     /// kind.  A placeholder can only be claimed once.
 104     bool claimPlaceholder(BuiltinType::Kind K) {
 105       if (PlaceholderKind != K) return false;
 106
 107       PlaceholderKind = (BuiltinType::Kind) 0;
 108       return true;
 109     }
 110
 111     bool isPlaceholder() const {
 112       return PlaceholderKind != 0;
 113     }
 114     bool isPlaceholder(BuiltinType::Kind K) const {
 115       return PlaceholderKind == K;
 116     }
 117
 118     void checkCastAlign() {
 119       Self.CheckCastAlign(SrcExpr.get(), DestType, OpRange);
 120     }
 121
 122     void checkObjCARCConversion(Sema::CheckedConversionKind CCK) {
 123       assert(Self.getLangOpts().ObjCAutoRefCount);
 124
 125       Expr *src = SrcExpr.get();
 126       if (Self.CheckObjCARCConversion(OpRange, DestType, src, CCK) ==
 127             Sema::ACR_unbridged)
 128         IsARCUnbridgedCast = true;
 129       SrcExpr = src;
 130     }
 131
 132     /// Check for and handle non-overload placeholder expressions.
 133     void checkNonOverloadPlaceholders() {
 134       if (!isPlaceholder() || isPlaceholder(BuiltinType::Overload))
 135         return;
 136
 137       SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get());
 138       if (SrcExpr.isInvalid())
 139         return;
 140       PlaceholderKind = (BuiltinType::Kind) 0;
 141     }
 142   };
 143 }
 144
 145 static bool CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType,
 146                                bool CheckCVR, bool CheckObjCLifetime);
 147
 148 // The Try functions attempt a specific way of casting. If they succeed, they
 149 // return TC_Success. If their way of casting is not appropriate for the given
 150 // arguments, they return TC_NotApplicable and *may* set diag to a diagnostic
 151 // to emit if no other way succeeds. If their way of casting is appropriate but
 152 // fails, they return TC_Failed and *must* set diag; they can set it to 0 if
 153 // they emit a specialized diagnostic.
 154 // All diagnostics returned by these functions must expect the same three
 155 // arguments:
 156 // %0: Cast Type (a value from the CastType enumeration)
 157 // %1: Source Type
 158 // %2: Destination Type
 159 static TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr,
 160                                            QualType DestType, bool CStyle,
 161                                            CastKind &Kind,
 162                                            CXXCastPath &BasePath,
 163                                            unsigned &msg);
 164 static TryCastResult TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr,
 165                                                QualType DestType, bool CStyle,
 166                                                const SourceRange &OpRange,
 167                                                unsigned &msg,
 168                                                CastKind &Kind,
 169                                                CXXCastPath &BasePath);
 170 static TryCastResult TryStaticPointerDowncast(Sema &Self, QualType SrcType,
 171                                               QualType DestType, bool CStyle,
 172                                               const SourceRange &OpRange,
 173                                               unsigned &msg,
 174                                               CastKind &Kind,
 175                                               CXXCastPath &BasePath);
 176 static TryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType,
 177                                        CanQualType DestType, bool CStyle,
 178                                        const SourceRange &OpRange,
 179                                        QualType OrigSrcType,
 180                                        QualType OrigDestType, unsigned &msg,
 181                                        CastKind &Kind,
 182                                        CXXCastPath &BasePath);
 183 static TryCastResult TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr,
 184                                                QualType SrcType,
 185                                                QualType DestType,bool CStyle,
 186                                                const SourceRange &OpRange,
 187                                                unsigned &msg,
 188                                                CastKind &Kind,
 189                                                CXXCastPath &BasePath);
 190
 191 static TryCastResult TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr,
 192                                            QualType DestType,
 193                                            Sema::CheckedConversionKind CCK,
 194                                            const SourceRange &OpRange,
 195                                            unsigned &msg, CastKind &Kind,
 196                                            bool ListInitialization);
 197 static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr,
 198                                    QualType DestType,
 199                                    Sema::CheckedConversionKind CCK,
 200                                    const SourceRange &OpRange,
 201                                    unsigned &msg, CastKind &Kind,
 202                                    CXXCastPath &BasePath,
 203                                    bool ListInitialization);
 204 static TryCastResult TryConstCast(Sema &Self, ExprResult &SrcExpr,
 205                                   QualType DestType, bool CStyle,
 206                                   unsigned &msg);
 207 static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
 208                                         QualType DestType, bool CStyle,
 209                                         const SourceRange &OpRange,
 210                                         unsigned &msg,
 211                                         CastKind &Kind);
 212
 213
 214 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
 215 ExprResult
 216 Sema::ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind,
 217                         SourceLocation LAngleBracketLoc, Declarator &D,
 218                         SourceLocation RAngleBracketLoc,
 219                         SourceLocation LParenLoc, Expr *E,
 220                         SourceLocation RParenLoc) {
 221
 222   assert(!D.isInvalidType());
 223
 224   TypeSourceInfo *TInfo = GetTypeForDeclaratorCast(D, E->getType());
 225   if (D.isInvalidType())
 226     return ExprError();
 227
 228   if (getLangOpts().CPlusPlus) {
 229     // Check that there are no default arguments (C++ only).
 230     CheckExtraCXXDefaultArguments(D);
 231   }
 232
 233   return BuildCXXNamedCast(OpLoc, Kind, TInfo, E,
 234                            SourceRange(LAngleBracketLoc, RAngleBracketLoc),
 235                            SourceRange(LParenLoc, RParenLoc));
 236 }
 237
 238 ExprResult
 239 Sema::BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind,
 240                         TypeSourceInfo *DestTInfo, Expr *E,
 241                         SourceRange AngleBrackets, SourceRange Parens) {
 242   ExprResult Ex = E;
 243   QualType DestType = DestTInfo->getType();
 244
 245   // If the type is dependent, we won't do the semantic analysis now.
 246   // FIXME: should we check this in a more fine-grained manner?
 247   bool TypeDependent = DestType->isDependentType() ||
 248                        Ex.get()->isTypeDependent() ||
 249                        Ex.get()->isValueDependent();
 250
 251   CastOperation Op(*this, DestType, E);
 252   Op.OpRange = SourceRange(OpLoc, Parens.getEnd());
 253   Op.DestRange = AngleBrackets;
 254
 255   switch (Kind) {
 256   default: llvm_unreachable("Unknown C++ cast!");
 257
 258   case tok::kw_const_cast:
 259     if (!TypeDependent) {
 260       Op.CheckConstCast();
 261       if (Op.SrcExpr.isInvalid())
 262         return ExprError();
 263     }
 264     return Op.complete(CXXConstCastExpr::Create(Context, Op.ResultType,
 265                                   Op.ValueKind, Op.SrcExpr.get(), DestTInfo,
 266                                                 OpLoc, Parens.getEnd(),
 267                                                 AngleBrackets));
 268
 269   case tok::kw_dynamic_cast: {
 270     if (!TypeDependent) {
 271       Op.CheckDynamicCast();
 272       if (Op.SrcExpr.isInvalid())
 273         return ExprError();
 274     }
 275     return Op.complete(CXXDynamicCastExpr::Create(Context, Op.ResultType,
 276                                     Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
 277                                                   &Op.BasePath, DestTInfo,
 278                                                   OpLoc, Parens.getEnd(),
 279                                                   AngleBrackets));
 280   }
 281   case tok::kw_reinterpret_cast: {
 282     if (!TypeDependent) {
 283       Op.CheckReinterpretCast();
 284       if (Op.SrcExpr.isInvalid())
 285         return ExprError();
 286     }
 287     return Op.complete(CXXReinterpretCastExpr::Create(Context, Op.ResultType,
 288                                     Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
 289                                                       nullptr, DestTInfo, OpLoc,
 290                                                       Parens.getEnd(),
 291                                                       AngleBrackets));
 292   }
 293   case tok::kw_static_cast: {
 294     if (!TypeDependent) {
 295       Op.CheckStaticCast();
 296       if (Op.SrcExpr.isInvalid())
 297         return ExprError();
 298     }
 299
 300     return Op.complete(CXXStaticCastExpr::Create(Context, Op.ResultType,
 301                                    Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
 302                                                  &Op.BasePath, DestTInfo,
 303                                                  OpLoc, Parens.getEnd(),
 304                                                  AngleBrackets));
 305   }
 306   }
 307 }
 308
 309 /// Try to diagnose a failed overloaded cast.  Returns true if
 310 /// diagnostics were emitted.
 311 static bool tryDiagnoseOverloadedCast(Sema &S, CastType CT,
 312                                       SourceRange range, Expr *src,
 313                                       QualType destType,
 314                                       bool listInitialization) {
 315   switch (CT) {
 316   // These cast kinds don't consider user-defined conversions.
 317   case CT_Const:
 318   case CT_Reinterpret:
 319   case CT_Dynamic:
 320     return false;
 321
 322   // These do.
 323   case CT_Static:
 324   case CT_CStyle:
 325   case CT_Functional:
 326     break;
 327   }
 328
 329   QualType srcType = src->getType();
 330   if (!destType->isRecordType() && !srcType->isRecordType())
 331     return false;
 332
 333   InitializedEntity entity = InitializedEntity::InitializeTemporary(destType);
 334   InitializationKind initKind
 335     = (CT == CT_CStyle)? InitializationKind::CreateCStyleCast(range.getBegin(),
 336                                                       range, listInitialization)
 337     : (CT == CT_Functional)? InitializationKind::CreateFunctionalCast(range,
 338                                                              listInitialization)
 339     : InitializationKind::CreateCast(/*type range?*/ range);
 340   InitializationSequence sequence(S, entity, initKind, src);
 341
 342   assert(sequence.Failed() && "initialization succeeded on second try?");
 343   switch (sequence.getFailureKind()) {
 344   default: return false;
 345
 346   case InitializationSequence::FK_ConstructorOverloadFailed:
 347   case InitializationSequence::FK_UserConversionOverloadFailed:
 348     break;
 349   }
 350
 351   OverloadCandidateSet &candidates = sequence.getFailedCandidateSet();
 352
 353   unsigned msg = 0;
 354   OverloadCandidateDisplayKind howManyCandidates = OCD_AllCandidates;
 355
 356   switch (sequence.getFailedOverloadResult()) {
 357   case OR_Success: llvm_unreachable("successful failed overload");
 358   case OR_No_Viable_Function:
 359     if (candidates.empty())
 360       msg = diag::err_ovl_no_conversion_in_cast;
 361     else
 362       msg = diag::err_ovl_no_viable_conversion_in_cast;
 363     howManyCandidates = OCD_AllCandidates;
 364     break;
 365
 366   case OR_Ambiguous:
 367     msg = diag::err_ovl_ambiguous_conversion_in_cast;
 368     howManyCandidates = OCD_ViableCandidates;
 369     break;
 370
 371   case OR_Deleted:
 372     msg = diag::err_ovl_deleted_conversion_in_cast;
 373     howManyCandidates = OCD_ViableCandidates;
 374     break;
 375   }
 376
 377   S.Diag(range.getBegin(), msg)
 378     << CT << srcType << destType
 379     << range << src->getSourceRange();
 380
 381   candidates.NoteCandidates(S, howManyCandidates, src);
 382
 383   return true;
 384 }
 385
 386 /// Diagnose a failed cast.
 387 static void diagnoseBadCast(Sema &S, unsigned msg, CastType castType,
 388                             SourceRange opRange, Expr *src, QualType destType,
 389                             bool listInitialization) {
 390   if (msg == diag::err_bad_cxx_cast_generic &&
 391       tryDiagnoseOverloadedCast(S, castType, opRange, src, destType,
 392                                 listInitialization))
 393     return;
 394
 395   S.Diag(opRange.getBegin(), msg) << castType
 396     << src->getType() << destType << opRange << src->getSourceRange();
 397 }
 398
 399 /// UnwrapDissimilarPointerTypes - Like Sema::UnwrapSimilarPointerTypes,
 400 /// this removes one level of indirection from both types, provided that they're
 401 /// the same kind of pointer (plain or to-member). Unlike the Sema function,
 402 /// this one doesn't care if the two pointers-to-member don't point into the
 403 /// same class. This is because CastsAwayConstness doesn't care.
 404 static bool UnwrapDissimilarPointerTypes(QualType& T1, QualType& T2) {
 405   const PointerType *T1PtrType = T1->getAs<PointerType>(),
 406                     *T2PtrType = T2->getAs<PointerType>();
 407   if (T1PtrType && T2PtrType) {
 408     T1 = T1PtrType->getPointeeType();
 409     T2 = T2PtrType->getPointeeType();
 410     return true;
 411   }
 412   const ObjCObjectPointerType *T1ObjCPtrType =
 413                                             T1->getAs<ObjCObjectPointerType>(),
 414                               *T2ObjCPtrType =
 415                                             T2->getAs<ObjCObjectPointerType>();
 416   if (T1ObjCPtrType) {
 417     if (T2ObjCPtrType) {
 418       T1 = T1ObjCPtrType->getPointeeType();
 419       T2 = T2ObjCPtrType->getPointeeType();
 420       return true;
 421     }
 422     else if (T2PtrType) {
 423       T1 = T1ObjCPtrType->getPointeeType();
 424       T2 = T2PtrType->getPointeeType();
 425       return true;
 426     }
 427   }
 428   else if (T2ObjCPtrType) {
 429     if (T1PtrType) {
 430       T2 = T2ObjCPtrType->getPointeeType();
 431       T1 = T1PtrType->getPointeeType();
 432       return true;
 433     }
 434   }
 435
 436   const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(),
 437                           *T2MPType = T2->getAs<MemberPointerType>();
 438   if (T1MPType && T2MPType) {
 439     T1 = T1MPType->getPointeeType();
 440     T2 = T2MPType->getPointeeType();
 441     return true;
 442   }
 443
 444   const BlockPointerType *T1BPType = T1->getAs<BlockPointerType>(),
 445                          *T2BPType = T2->getAs<BlockPointerType>();
 446   if (T1BPType && T2BPType) {
 447     T1 = T1BPType->getPointeeType();
 448     T2 = T2BPType->getPointeeType();
 449     return true;
 450   }
 451
 452   return false;
 453 }
 454
 455 /// CastsAwayConstness - Check if the pointer conversion from SrcType to
 456 /// DestType casts away constness as defined in C++ 5.2.11p8ff. This is used by
 457 /// the cast checkers.  Both arguments must denote pointer (possibly to member)
 458 /// types.
 459 ///
 460 /// \param CheckCVR Whether to check for const/volatile/restrict qualifiers.
 461 ///
 462 /// \param CheckObjCLifetime Whether to check Objective-C lifetime qualifiers.
 463 static bool
 464 CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType,
 465                    bool CheckCVR, bool CheckObjCLifetime) {
 466   // If the only checking we care about is for Objective-C lifetime qualifiers,
 467   // and we're not in ARC mode, there's nothing to check.
 468   if (!CheckCVR && CheckObjCLifetime &&
 469       !Self.Context.getLangOpts().ObjCAutoRefCount)
 470     return false;
 471
 472   // Casting away constness is defined in C++ 5.2.11p8 with reference to
 473   // C++ 4.4. We piggyback on Sema::IsQualificationConversion for this, since
 474   // the rules are non-trivial. So first we construct Tcv *...cv* as described
 475   // in C++ 5.2.11p8.
 476   assert((SrcType->isAnyPointerType() || SrcType->isMemberPointerType() ||
 477           SrcType->isBlockPointerType()) &&
 478          "Source type is not pointer or pointer to member.");
 479   assert((DestType->isAnyPointerType() || DestType->isMemberPointerType() ||
 480           DestType->isBlockPointerType()) &&
 481          "Destination type is not pointer or pointer to member.");
 482
 483   QualType UnwrappedSrcType = Self.Context.getCanonicalType(SrcType),
 484            UnwrappedDestType = Self.Context.getCanonicalType(DestType);
 485   SmallVector<Qualifiers, 8> cv1, cv2;
 486
 487   // Find the qualifiers. We only care about cvr-qualifiers for the
 488   // purpose of this check, because other qualifiers (address spaces,
 489   // Objective-C GC, etc.) are part of the type's identity.
 490   while (UnwrapDissimilarPointerTypes(UnwrappedSrcType, UnwrappedDestType)) {
 491     // Determine the relevant qualifiers at this level.
 492     Qualifiers SrcQuals, DestQuals;
 493     Self.Context.getUnqualifiedArrayType(UnwrappedSrcType, SrcQuals);
 494     Self.Context.getUnqualifiedArrayType(UnwrappedDestType, DestQuals);
 495
 496     Qualifiers RetainedSrcQuals, RetainedDestQuals;
 497     if (CheckCVR) {
 498       RetainedSrcQuals.setCVRQualifiers(SrcQuals.getCVRQualifiers());
 499       RetainedDestQuals.setCVRQualifiers(DestQuals.getCVRQualifiers());
 500     }
 501
 502     if (CheckObjCLifetime &&
 503         !DestQuals.compatiblyIncludesObjCLifetime(SrcQuals))
 504       return true;
 505
 506     cv1.push_back(RetainedSrcQuals);
 507     cv2.push_back(RetainedDestQuals);
 508   }
 509   if (cv1.empty())
 510     return false;
 511
 512   // Construct void pointers with those qualifiers (in reverse order of
 513   // unwrapping, of course).
 514   QualType SrcConstruct = Self.Context.VoidTy;
 515   QualType DestConstruct = Self.Context.VoidTy;
 516   ASTContext &Context = Self.Context;
 517   for (SmallVectorImpl<Qualifiers>::reverse_iterator i1 = cv1.rbegin(),
 518                                                      i2 = cv2.rbegin();
 519        i1 != cv1.rend(); ++i1, ++i2) {
 520     SrcConstruct
 521       = Context.getPointerType(Context.getQualifiedType(SrcConstruct, *i1));
 522     DestConstruct
 523       = Context.getPointerType(Context.getQualifiedType(DestConstruct, *i2));
 524   }
 525
 526   // Test if they're compatible.
 527   bool ObjCLifetimeConversion;
 528   return SrcConstruct != DestConstruct &&
 529     !Self.IsQualificationConversion(SrcConstruct, DestConstruct, false,
 530                                     ObjCLifetimeConversion);
 531 }
 532
 533 /// CheckDynamicCast - Check that a dynamic_cast\<DestType\>(SrcExpr) is valid.
 534 /// Refer to C++ 5.2.7 for details. Dynamic casts are used mostly for runtime-
 535 /// checked downcasts in class hierarchies.
 536 void CastOperation::CheckDynamicCast() {
 537   if (ValueKind == VK_RValue)
 538     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
 539   else if (isPlaceholder())
 540     SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get());
 541   if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 542     return;
 543
 544   QualType OrigSrcType = SrcExpr.get()->getType();
 545   QualType DestType = Self.Context.getCanonicalType(this->DestType);
 546
 547   // C++ 5.2.7p1: T shall be a pointer or reference to a complete class type,
 548   //   or "pointer to cv void".
 549
 550   QualType DestPointee;
 551   const PointerType *DestPointer = DestType->getAs<PointerType>();
 552   const ReferenceType *DestReference = nullptr;
 553   if (DestPointer) {
 554     DestPointee = DestPointer->getPointeeType();
 555   } else if ((DestReference = DestType->getAs<ReferenceType>())) {
 556     DestPointee = DestReference->getPointeeType();
 557   } else {
 558     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ref_or_ptr)
 559       << this->DestType << DestRange;
 560     SrcExpr = ExprError();
 561     return;
 562   }
 563
 564   const RecordType *DestRecord = DestPointee->getAs<RecordType>();
 565   if (DestPointee->isVoidType()) {
 566     assert(DestPointer && "Reference to void is not possible");
 567   } else if (DestRecord) {
 568     if (Self.RequireCompleteType(OpRange.getBegin(), DestPointee,
 569                                  diag::err_bad_dynamic_cast_incomplete,
 570                                  DestRange)) {
 571       SrcExpr = ExprError();
 572       return;
 573     }
 574   } else {
 575     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)
 576       << DestPointee.getUnqualifiedType() << DestRange;
 577     SrcExpr = ExprError();
 578     return;
 579   }
 580
 581   // C++0x 5.2.7p2: If T is a pointer type, v shall be an rvalue of a pointer to
 582   //   complete class type, [...]. If T is an lvalue reference type, v shall be
 583   //   an lvalue of a complete class type, [...]. If T is an rvalue reference
 584   //   type, v shall be an expression having a complete class type, [...]
 585   QualType SrcType = Self.Context.getCanonicalType(OrigSrcType);
 586   QualType SrcPointee;
 587   if (DestPointer) {
 588     if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) {
 589       SrcPointee = SrcPointer->getPointeeType();
 590     } else {
 591       Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ptr)
 592         << OrigSrcType << SrcExpr.get()->getSourceRange();
 593       SrcExpr = ExprError();
 594       return;
 595     }
 596   } else if (DestReference->isLValueReferenceType()) {
 597     if (!SrcExpr.get()->isLValue()) {
 598       Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_rvalue)
 599         << CT_Dynamic << OrigSrcType << this->DestType << OpRange;
 600     }
 601     SrcPointee = SrcType;
 602   } else {
 603     // If we're dynamic_casting from a prvalue to an rvalue reference, we need
 604     // to materialize the prvalue before we bind the reference to it.
 605     if (SrcExpr.get()->isRValue())
 606       SrcExpr = new (Self.Context) MaterializeTemporaryExpr(
 607           SrcType, SrcExpr.get(), /*IsLValueReference*/false);
 608     SrcPointee = SrcType;
 609   }
 610
 611   const RecordType *SrcRecord = SrcPointee->getAs<RecordType>();
 612   if (SrcRecord) {
 613     if (Self.RequireCompleteType(OpRange.getBegin(), SrcPointee,
 614                                  diag::err_bad_dynamic_cast_incomplete,
 615                                  SrcExpr.get())) {
 616       SrcExpr = ExprError();
 617       return;
 618     }
 619   } else {
 620     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)
 621       << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange();
 622     SrcExpr = ExprError();
 623     return;
 624   }
 625
 626   assert((DestPointer || DestReference) &&
 627     "Bad destination non-ptr/ref slipped through.");
 628   assert((DestRecord || DestPointee->isVoidType()) &&
 629     "Bad destination pointee slipped through.");
 630   assert(SrcRecord && "Bad source pointee slipped through.");
 631
 632   // C++ 5.2.7p1: The dynamic_cast operator shall not cast away constness.
 633   if (!DestPointee.isAtLeastAsQualifiedAs(SrcPointee)) {
 634     Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_qualifiers_away)
 635       << CT_Dynamic << OrigSrcType << this->DestType << OpRange;
 636     SrcExpr = ExprError();
 637     return;
 638   }
 639
 640   // C++ 5.2.7p3: If the type of v is the same as the required result type,
 641   //   [except for cv].
 642   if (DestRecord == SrcRecord) {
 643     Kind = CK_NoOp;
 644     return;
 645   }
 646
 647   // C++ 5.2.7p5
 648   // Upcasts are resolved statically.
 649   if (DestRecord && Self.IsDerivedFrom(SrcPointee, DestPointee)) {
 650     if (Self.CheckDerivedToBaseConversion(SrcPointee, DestPointee,
 651                                            OpRange.getBegin(), OpRange,
 652                                            &BasePath)) {
 653       SrcExpr = ExprError();
 654       return;
 655     }
 656
 657     Kind = CK_DerivedToBase;
 658
 659     // If we are casting to or through a virtual base class, we need a
 660     // vtable.
 661     if (Self.BasePathInvolvesVirtualBase(BasePath))
 662       Self.MarkVTableUsed(OpRange.getBegin(),
 663                           cast<CXXRecordDecl>(SrcRecord->getDecl()));
 664     return;
 665   }
 666
 667   // C++ 5.2.7p6: Otherwise, v shall be [polymorphic].
 668   const RecordDecl *SrcDecl = SrcRecord->getDecl()->getDefinition();
 669   assert(SrcDecl && "Definition missing");
 670   if (!cast<CXXRecordDecl>(SrcDecl)->isPolymorphic()) {
 671     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_polymorphic)
 672       << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange();
 673     SrcExpr = ExprError();
 674   }
 675   Self.MarkVTableUsed(OpRange.getBegin(),
 676                       cast<CXXRecordDecl>(SrcRecord->getDecl()));
 677
 678   // dynamic_cast is not available with -fno-rtti.
 679   // As an exception, dynamic_cast to void* is available because it doesn't
 680   // use RTTI.
 681   if (!Self.getLangOpts().RTTI && !DestPointee->isVoidType()) {
 682     Self.Diag(OpRange.getBegin(), diag::err_no_dynamic_cast_with_fno_rtti);
 683     SrcExpr = ExprError();
 684     return;
 685   }
 686
 687   // Done. Everything else is run-time checks.
 688   Kind = CK_Dynamic;
 689 }
 690
 691 /// CheckConstCast - Check that a const_cast\<DestType\>(SrcExpr) is valid.
 692 /// Refer to C++ 5.2.11 for details. const_cast is typically used in code
 693 /// like this:
 694 /// const char *str = "literal";
 695 /// legacy_function(const_cast\<char*\>(str));
 696 void CastOperation::CheckConstCast() {
 697   if (ValueKind == VK_RValue)
 698     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
 699   else if (isPlaceholder())
 700     SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get());
 701   if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 702     return;
 703
 704   unsigned msg = diag::err_bad_cxx_cast_generic;
 705   if (TryConstCast(Self, SrcExpr, DestType, /*CStyle*/false, msg) != TC_Success
 706       && msg != 0) {
 707     Self.Diag(OpRange.getBegin(), msg) << CT_Const
 708       << SrcExpr.get()->getType() << DestType << OpRange;
 709     SrcExpr = ExprError();
 710   }
 711 }
 712
 713 /// Check that a reinterpret_cast\<DestType\>(SrcExpr) is not used as upcast
 714 /// or downcast between respective pointers or references.
 715 static void DiagnoseReinterpretUpDownCast(Sema &Self, const Expr *SrcExpr,
 716                                           QualType DestType,
 717                                           SourceRange OpRange) {
 718   QualType SrcType = SrcExpr->getType();
 719   // When casting from pointer or reference, get pointee type; use original
 720   // type otherwise.
 721   const CXXRecordDecl *SrcPointeeRD = SrcType->getPointeeCXXRecordDecl();
 722   const CXXRecordDecl *SrcRD =
 723     SrcPointeeRD ? SrcPointeeRD : SrcType->getAsCXXRecordDecl();
 724
 725   // Examining subobjects for records is only possible if the complete and
 726   // valid definition is available.  Also, template instantiation is not
 727   // allowed here.
 728   if (!SrcRD || !SrcRD->isCompleteDefinition() || SrcRD->isInvalidDecl())
 729     return;
 730
 731   const CXXRecordDecl *DestRD = DestType->getPointeeCXXRecordDecl();
 732
 733   if (!DestRD || !DestRD->isCompleteDefinition() || DestRD->isInvalidDecl())
 734     return;
 735
 736   enum {
 737     ReinterpretUpcast,
 738     ReinterpretDowncast
 739   } ReinterpretKind;
 740
 741   CXXBasePaths BasePaths;
 742
 743   if (SrcRD->isDerivedFrom(DestRD, BasePaths))
 744     ReinterpretKind = ReinterpretUpcast;
 745   else if (DestRD->isDerivedFrom(SrcRD, BasePaths))
 746     ReinterpretKind = ReinterpretDowncast;
 747   else
 748     return;
 749
 750   bool VirtualBase = true;
 751   bool NonZeroOffset = false;
 752   for (CXXBasePaths::const_paths_iterator I = BasePaths.begin(),
 753                                           E = BasePaths.end();
 754        I != E; ++I) {
 755     const CXXBasePath &Path = *I;
 756     CharUnits Offset = CharUnits::Zero();
 757     bool IsVirtual = false;
 758     for (CXXBasePath::const_iterator IElem = Path.begin(), EElem = Path.end();
 759          IElem != EElem; ++IElem) {
 760       IsVirtual = IElem->Base->isVirtual();
 761       if (IsVirtual)
 762         break;
 763       const CXXRecordDecl *BaseRD = IElem->Base->getType()->getAsCXXRecordDecl();
 764       assert(BaseRD && "Base type should be a valid unqualified class type");
 765       // Don't check if any base has invalid declaration or has no definition
 766       // since it has no layout info.
 767       const CXXRecordDecl *Class = IElem->Class,
 768                           *ClassDefinition = Class->getDefinition();
 769       if (Class->isInvalidDecl() || !ClassDefinition ||
 770           !ClassDefinition->isCompleteDefinition())
 771         return;
 772
 773       const ASTRecordLayout &DerivedLayout =
 774           Self.Context.getASTRecordLayout(Class);
 775       Offset += DerivedLayout.getBaseClassOffset(BaseRD);
 776     }
 777     if (!IsVirtual) {
 778       // Don't warn if any path is a non-virtually derived base at offset zero.
 779       if (Offset.isZero())
 780         return;
 781       // Offset makes sense only for non-virtual bases.
 782       else
 783         NonZeroOffset = true;
 784     }
 785     VirtualBase = VirtualBase && IsVirtual;
 786   }
 787
 788   (void) NonZeroOffset; // Silence set but not used warning.
 789   assert((VirtualBase || NonZeroOffset) &&
 790          "Should have returned if has non-virtual base with zero offset");
 791
 792   QualType BaseType =
 793       ReinterpretKind == ReinterpretUpcast? DestType : SrcType;
 794   QualType DerivedType =
 795       ReinterpretKind == ReinterpretUpcast? SrcType : DestType;
 796
 797   SourceLocation BeginLoc = OpRange.getBegin();
 798   Self.Diag(BeginLoc, diag::warn_reinterpret_different_from_static)
 799     << DerivedType << BaseType << !VirtualBase << int(ReinterpretKind)
 800     << OpRange;
 801   Self.Diag(BeginLoc, diag::note_reinterpret_updowncast_use_static)
 802     << int(ReinterpretKind)
 803     << FixItHint::CreateReplacement(BeginLoc, "static_cast");
 804 }
 805
 806 /// CheckReinterpretCast - Check that a reinterpret_cast\<DestType\>(SrcExpr) is
 807 /// valid.
 808 /// Refer to C++ 5.2.10 for details. reinterpret_cast is typically used in code
 809 /// like this:
 810 /// char *bytes = reinterpret_cast\<char*\>(int_ptr);
 811 void CastOperation::CheckReinterpretCast() {
 812   if (ValueKind == VK_RValue && !isPlaceholder(BuiltinType::Overload))
 813     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
 814   else
 815     checkNonOverloadPlaceholders();
 816   if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 817     return;
 818
 819   unsigned msg = diag::err_bad_cxx_cast_generic;
 820   TryCastResult tcr =
 821     TryReinterpretCast(Self, SrcExpr, DestType,
 822                        /*CStyle*/false, OpRange, msg, Kind);
 823   if (tcr != TC_Success && msg != 0)
 824   {
 825     if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 826       return;
 827     if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
 828       //FIXME: &f<int>; is overloaded and resolvable
 829       Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_overload)
 830         << OverloadExpr::find(SrcExpr.get()).Expression->getName()
 831         << DestType << OpRange;
 832       Self.NoteAllOverloadCandidates(SrcExpr.get());
 833
 834     } else {
 835       diagnoseBadCast(Self, msg, CT_Reinterpret, OpRange, SrcExpr.get(),
 836                       DestType, /*listInitialization=*/false);
 837     }
 838     SrcExpr = ExprError();
 839   } else if (tcr == TC_Success) {
 840     if (Self.getLangOpts().ObjCAutoRefCount)
 841       checkObjCARCConversion(Sema::CCK_OtherCast);
 842     DiagnoseReinterpretUpDownCast(Self, SrcExpr.get(), DestType, OpRange);
 843   }
 844 }
 845
 846
 847 /// CheckStaticCast - Check that a static_cast\<DestType\>(SrcExpr) is valid.
 848 /// Refer to C++ 5.2.9 for details. Static casts are mostly used for making
 849 /// implicit conversions explicit and getting rid of data loss warnings.
 850 void CastOperation::CheckStaticCast() {
 851   if (isPlaceholder()) {
 852     checkNonOverloadPlaceholders();
 853     if (SrcExpr.isInvalid())
 854       return;
 855   }
 856
 857   // This test is outside everything else because it's the only case where
 858   // a non-lvalue-reference target type does not lead to decay.
 859   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
 860   if (DestType->isVoidType()) {
 861     Kind = CK_ToVoid;
 862
 863     if (claimPlaceholder(BuiltinType::Overload)) {
 864       Self.ResolveAndFixSingleFunctionTemplateSpecialization(SrcExpr,
 865                 false, // Decay Function to ptr
 866                 true, // Complain
 867                 OpRange, DestType, diag::err_bad_static_cast_overload);
 868       if (SrcExpr.isInvalid())
 869         return;
 870     }
 871
 872     SrcExpr = Self.IgnoredValueConversions(SrcExpr.get());
 873     return;
 874   }
 875
 876   if (ValueKind == VK_RValue && !DestType->isRecordType() &&
 877       !isPlaceholder(BuiltinType::Overload)) {
 878     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
 879     if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 880       return;
 881   }
 882
 883   unsigned msg = diag::err_bad_cxx_cast_generic;
 884   TryCastResult tcr
 885     = TryStaticCast(Self, SrcExpr, DestType, Sema::CCK_OtherCast, OpRange, msg,
 886                     Kind, BasePath, /*ListInitialization=*/false);
 887   if (tcr != TC_Success && msg != 0) {
 888     if (SrcExpr.isInvalid())
 889       return;
 890     if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
 891       OverloadExpr* oe = OverloadExpr::find(SrcExpr.get()).Expression;
 892       Self.Diag(OpRange.getBegin(), diag::err_bad_static_cast_overload)
 893         << oe->getName() << DestType << OpRange
 894         << oe->getQualifierLoc().getSourceRange();
 895       Self.NoteAllOverloadCandidates(SrcExpr.get());
 896     } else {
 897       diagnoseBadCast(Self, msg, CT_Static, OpRange, SrcExpr.get(), DestType,
 898                       /*listInitialization=*/false);
 899     }
 900     SrcExpr = ExprError();
 901   } else if (tcr == TC_Success) {
 902     if (Kind == CK_BitCast)
 903       checkCastAlign();
 904     if (Self.getLangOpts().ObjCAutoRefCount)
 905       checkObjCARCConversion(Sema::CCK_OtherCast);
 906   } else if (Kind == CK_BitCast) {
 907     checkCastAlign();
 908   }
 909 }
 910
 911 /// TryStaticCast - Check if a static cast can be performed, and do so if
 912 /// possible. If @p CStyle, ignore access restrictions on hierarchy casting
 913 /// and casting away constness.
 914 static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr,
 915                                    QualType DestType,
 916                                    Sema::CheckedConversionKind CCK,
 917                                    const SourceRange &OpRange, unsigned &msg,
 918                                    CastKind &Kind, CXXCastPath &BasePath,
 919                                    bool ListInitialization) {
 920   // Determine whether we have the semantics of a C-style cast.
 921   bool CStyle
 922     = (CCK == Sema::CCK_CStyleCast || CCK == Sema::CCK_FunctionalCast);
 923
 924   // The order the tests is not entirely arbitrary. There is one conversion
 925   // that can be handled in two different ways. Given:
 926   // struct A {};
 927   // struct B : public A {
 928   //   B(); B(const A&);
 929   // };
 930   // const A &a = B();
 931   // the cast static_cast<const B&>(a) could be seen as either a static
 932   // reference downcast, or an explicit invocation of the user-defined
 933   // conversion using B's conversion constructor.
 934   // DR 427 specifies that the downcast is to be applied here.
 935
 936   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
 937   // Done outside this function.
 938
 939   TryCastResult tcr;
 940
 941   // C++ 5.2.9p5, reference downcast.
 942   // See the function for details.
 943   // DR 427 specifies that this is to be applied before paragraph 2.
 944   tcr = TryStaticReferenceDowncast(Self, SrcExpr.get(), DestType, CStyle,
 945                                    OpRange, msg, Kind, BasePath);
 946   if (tcr != TC_NotApplicable)
 947     return tcr;
 948
 949   // C++0x [expr.static.cast]p3:
 950   //   A glvalue of type "cv1 T1" can be cast to type "rvalue reference to cv2
 951   //   T2" if "cv2 T2" is reference-compatible with "cv1 T1".
 952   tcr = TryLValueToRValueCast(Self, SrcExpr.get(), DestType, CStyle, Kind,
 953                               BasePath, msg);
 954   if (tcr != TC_NotApplicable)
 955     return tcr;
 956
 957   // C++ 5.2.9p2: An expression e can be explicitly converted to a type T
 958   //   [...] if the declaration "T t(e);" is well-formed, [...].
 959   tcr = TryStaticImplicitCast(Self, SrcExpr, DestType, CCK, OpRange, msg,
 960                               Kind, ListInitialization);
 961   if (SrcExpr.isInvalid())
 962     return TC_Failed;
 963   if (tcr != TC_NotApplicable)
 964     return tcr;
 965
 966   // C++ 5.2.9p6: May apply the reverse of any standard conversion, except
 967   // lvalue-to-rvalue, array-to-pointer, function-to-pointer, and boolean
 968   // conversions, subject to further restrictions.
 969   // Also, C++ 5.2.9p1 forbids casting away constness, which makes reversal
 970   // of qualification conversions impossible.
 971   // In the CStyle case, the earlier attempt to const_cast should have taken
 972   // care of reverse qualification conversions.
 973
 974   QualType SrcType = Self.Context.getCanonicalType(SrcExpr.get()->getType());
 975
 976   // C++0x 5.2.9p9: A value of a scoped enumeration type can be explicitly
 977   // converted to an integral type. [...] A value of a scoped enumeration type
 978   // can also be explicitly converted to a floating-point type [...].
 979   if (const EnumType *Enum = SrcType->getAs<EnumType>()) {
 980     if (Enum->getDecl()->isScoped()) {
 981       if (DestType->isBooleanType()) {
 982         Kind = CK_IntegralToBoolean;
 983         return TC_Success;
 984       } else if (DestType->isIntegralType(Self.Context)) {
 985         Kind = CK_IntegralCast;
 986         return TC_Success;
 987       } else if (DestType->isRealFloatingType()) {
 988         Kind = CK_IntegralToFloating;
 989         return TC_Success;
 990       }
 991     }
 992   }
 993
 994   // Reverse integral promotion/conversion. All such conversions are themselves
 995   // again integral promotions or conversions and are thus already handled by
 996   // p2 (TryDirectInitialization above).
 997   // (Note: any data loss warnings should be suppressed.)
 998   // The exception is the reverse of enum->integer, i.e. integer->enum (and
 999   // enum->enum). See also C++ 5.2.9p7.
1000   // The same goes for reverse floating point promotion/conversion and
1001   // floating-integral conversions. Again, only floating->enum is relevant.
1002   if (DestType->isEnumeralType()) {
1003     if (SrcType->isIntegralOrEnumerationType()) {
1004       Kind = CK_IntegralCast;
1005       return TC_Success;
1006     } else if (SrcType->isRealFloatingType())   {
1007       Kind = CK_FloatingToIntegral;
1008       return TC_Success;
1009     }
1010   }
1011
1012   // Reverse pointer upcast. C++ 4.10p3 specifies pointer upcast.
1013   // C++ 5.2.9p8 additionally disallows a cast path through virtual inheritance.
1014   tcr = TryStaticPointerDowncast(Self, SrcType, DestType, CStyle, OpRange, msg,
1015                                  Kind, BasePath);
1016   if (tcr != TC_NotApplicable)
1017     return tcr;
1018
1019   // Reverse member pointer conversion. C++ 4.11 specifies member pointer
1020   // conversion. C++ 5.2.9p9 has additional information.
1021   // DR54's access restrictions apply here also.
1022   tcr = TryStaticMemberPointerUpcast(Self, SrcExpr, SrcType, DestType, CStyle,
1023                                      OpRange, msg, Kind, BasePath);
1024   if (tcr != TC_NotApplicable)
1025     return tcr;
1026
1027   // Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to
1028   // void*. C++ 5.2.9p10 specifies additional restrictions, which really is
1029   // just the usual constness stuff.
1030   if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) {
1031     QualType SrcPointee = SrcPointer->getPointeeType();
1032     if (SrcPointee->isVoidType()) {
1033       if (const PointerType *DestPointer = DestType->getAs<PointerType>()) {
1034         QualType DestPointee = DestPointer->getPointeeType();
1035         if (DestPointee->isIncompleteOrObjectType()) {
1036           // This is definitely the intended conversion, but it might fail due
1037           // to a qualifier violation. Note that we permit Objective-C lifetime
1038           // and GC qualifier mismatches here.
1039           if (!CStyle) {
1040             Qualifiers DestPointeeQuals = DestPointee.getQualifiers();
1041             Qualifiers SrcPointeeQuals = SrcPointee.getQualifiers();
1042             DestPointeeQuals.removeObjCGCAttr();
1043             DestPointeeQuals.removeObjCLifetime();
1044             SrcPointeeQuals.removeObjCGCAttr();
1045             SrcPointeeQuals.removeObjCLifetime();
1046             if (DestPointeeQuals != SrcPointeeQuals &&
1047                 !DestPointeeQuals.compatiblyIncludes(SrcPointeeQuals)) {
1048               msg = diag::err_bad_cxx_cast_qualifiers_away;
1049               return TC_Failed;
1050             }
1051           }
1052           Kind = CK_BitCast;
1053           return TC_Success;
1054         }
1055       }
1056       else if (DestType->isObjCObjectPointerType()) {
1057         // allow both c-style cast and static_cast of objective-c pointers as
1058         // they are pervasive.
1059         Kind = CK_CPointerToObjCPointerCast;
1060         return TC_Success;
1061       }
1062       else if (CStyle && DestType->isBlockPointerType()) {
1063         // allow c-style cast of void * to block pointers.
1064         Kind = CK_AnyPointerToBlockPointerCast;
1065         return TC_Success;
1066       }
1067     }
1068   }
1069   // Allow arbitray objective-c pointer conversion with static casts.
1070   if (SrcType->isObjCObjectPointerType() &&
1071       DestType->isObjCObjectPointerType()) {
1072     Kind = CK_BitCast;
1073     return TC_Success;
1074   }
1075   // Allow ns-pointer to cf-pointer conversion in either direction
1076   // with static casts.
1077   if (!CStyle &&
1078       Self.CheckTollFreeBridgeStaticCast(DestType, SrcExpr.get(), Kind))
1079     return TC_Success;
1080
1081   // We tried everything. Everything! Nothing works! :-(
1082   return TC_NotApplicable;
1083 }
1084
1085 /// Tests whether a conversion according to N2844 is valid.
1086 TryCastResult
1087 TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, QualType DestType,
1088                       bool CStyle, CastKind &Kind, CXXCastPath &BasePath,
1089                       unsigned &msg) {
1090   // C++0x [expr.static.cast]p3:
1091   //   A glvalue of type "cv1 T1" can be cast to type "rvalue reference to
1092   //   cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1".
1093   const RValueReferenceType *R = DestType->getAs<RValueReferenceType>();
1094   if (!R)
1095     return TC_NotApplicable;
1096
1097   if (!SrcExpr->isGLValue())
1098     return TC_NotApplicable;
1099
1100   // Because we try the reference downcast before this function, from now on
1101   // this is the only cast possibility, so we issue an error if we fail now.
1102   // FIXME: Should allow casting away constness if CStyle.
1103   bool DerivedToBase;
1104   bool ObjCConversion;
1105   bool ObjCLifetimeConversion;
1106   QualType FromType = SrcExpr->getType();
1107   QualType ToType = R->getPointeeType();
1108   if (CStyle) {
1109     FromType = FromType.getUnqualifiedType();
1110     ToType = ToType.getUnqualifiedType();
1111   }
1112
1113   if (Self.CompareReferenceRelationship(SrcExpr->getLocStart(),
1114                                         ToType, FromType,
1115                                         DerivedToBase, ObjCConversion,
1116                                         ObjCLifetimeConversion)
1117         < Sema::Ref_Compatible_With_Added_Qualification) {
1118     msg = diag::err_bad_lvalue_to_rvalue_cast;
1119     return TC_Failed;
1120   }
1121
1122   if (DerivedToBase) {
1123     Kind = CK_DerivedToBase;
1124     CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1125                        /*DetectVirtual=*/true);
1126     if (!Self.IsDerivedFrom(SrcExpr->getType(), R->getPointeeType(), Paths))
1127       return TC_NotApplicable;
1128
1129     Self.BuildBasePathArray(Paths, BasePath);
1130   } else
1131     Kind = CK_NoOp;
1132
1133   return TC_Success;
1134 }
1135
1136 /// Tests whether a conversion according to C++ 5.2.9p5 is valid.
1137 TryCastResult
1138 TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType,
1139                            bool CStyle, const SourceRange &OpRange,
1140                            unsigned &msg, CastKind &Kind,
1141                            CXXCastPath &BasePath) {
1142   // C++ 5.2.9p5: An lvalue of type "cv1 B", where B is a class type, can be
1143   //   cast to type "reference to cv2 D", where D is a class derived from B,
1144   //   if a valid standard conversion from "pointer to D" to "pointer to B"
1145   //   exists, cv2 >= cv1, and B is not a virtual base class of D.
1146   // In addition, DR54 clarifies that the base must be accessible in the
1147   // current context. Although the wording of DR54 only applies to the pointer
1148   // variant of this rule, the intent is clearly for it to apply to the this
1149   // conversion as well.
1150
1151   const ReferenceType *DestReference = DestType->getAs<ReferenceType>();
1152   if (!DestReference) {
1153     return TC_NotApplicable;
1154   }
1155   bool RValueRef = DestReference->isRValueReferenceType();
1156   if (!RValueRef && !SrcExpr->isLValue()) {
1157     // We know the left side is an lvalue reference, so we can suggest a reason.
1158     msg = diag::err_bad_cxx_cast_rvalue;
1159     return TC_NotApplicable;
1160   }
1161
1162   QualType DestPointee = DestReference->getPointeeType();
1163
1164   // FIXME: If the source is a prvalue, we should issue a warning (because the
1165   // cast always has undefined behavior), and for AST consistency, we should
1166   // materialize a temporary.
1167   return TryStaticDowncast(Self,
1168                            Self.Context.getCanonicalType(SrcExpr->getType()),
1169                            Self.Context.getCanonicalType(DestPointee), CStyle,
1170                            OpRange, SrcExpr->getType(), DestType, msg, Kind,
1171                            BasePath);
1172 }
1173
1174 /// Tests whether a conversion according to C++ 5.2.9p8 is valid.
1175 TryCastResult
1176 TryStaticPointerDowncast(Sema &Self, QualType SrcType, QualType DestType,
1177                          bool CStyle, const SourceRange &OpRange,
1178                          unsigned &msg, CastKind &Kind,
1179                          CXXCastPath &BasePath) {
1180   // C++ 5.2.9p8: An rvalue of type "pointer to cv1 B", where B is a class
1181   //   type, can be converted to an rvalue of type "pointer to cv2 D", where D
1182   //   is a class derived from B, if a valid standard conversion from "pointer
1183   //   to D" to "pointer to B" exists, cv2 >= cv1, and B is not a virtual base
1184   //   class of D.
1185   // In addition, DR54 clarifies that the base must be accessible in the
1186   // current context.
1187
1188   const PointerType *DestPointer = DestType->getAs<PointerType>();
1189   if (!DestPointer) {
1190     return TC_NotApplicable;
1191   }
1192
1193   const PointerType *SrcPointer = SrcType->getAs<PointerType>();
1194   if (!SrcPointer) {
1195     msg = diag::err_bad_static_cast_pointer_nonpointer;
1196     return TC_NotApplicable;
1197   }
1198
1199   return TryStaticDowncast(Self,
1200                    Self.Context.getCanonicalType(SrcPointer->getPointeeType()),
1201                   Self.Context.getCanonicalType(DestPointer->getPointeeType()),
1202                            CStyle, OpRange, SrcType, DestType, msg, Kind,
1203                            BasePath);
1204 }
1205
1206 /// TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and
1207 /// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to
1208 /// DestType is possible and allowed.
1209 TryCastResult
1210 TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType,
1211                   bool CStyle, const SourceRange &OpRange, QualType OrigSrcType,
1212                   QualType OrigDestType, unsigned &msg,
1213                   CastKind &Kind, CXXCastPath &BasePath) {
1214   // We can only work with complete types. But don't complain if it doesn't work
1215   if (Self.RequireCompleteType(OpRange.getBegin(), SrcType, 0) ||
1216       Self.RequireCompleteType(OpRange.getBegin(), DestType, 0))
1217     return TC_NotApplicable;
1218
1219   // Downcast can only happen in class hierarchies, so we need classes.
1220   if (!DestType->getAs<RecordType>() || !SrcType->getAs<RecordType>()) {
1221     return TC_NotApplicable;
1222   }
1223
1224   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1225                      /*DetectVirtual=*/true);
1226   if (!Self.IsDerivedFrom(DestType, SrcType, Paths)) {
1227     return TC_NotApplicable;
1228   }
1229
1230   // Target type does derive from source type. Now we're serious. If an error
1231   // appears now, it's not ignored.
1232   // This may not be entirely in line with the standard. Take for example:
1233   // struct A {};
1234   // struct B : virtual A {
1235   //   B(A&);
1236   // };
1237   //
1238   // void f()
1239   // {
1240   //   (void)static_cast<const B&>(*((A*)0));
1241   // }
1242   // As far as the standard is concerned, p5 does not apply (A is virtual), so
1243   // p2 should be used instead - "const B& t(*((A*)0));" is perfectly valid.
1244   // However, both GCC and Comeau reject this example, and accepting it would
1245   // mean more complex code if we're to preserve the nice error message.
1246   // FIXME: Being 100% compliant here would be nice to have.
1247
1248   // Must preserve cv, as always, unless we're in C-style mode.
1249   if (!CStyle && !DestType.isAtLeastAsQualifiedAs(SrcType)) {
1250     msg = diag::err_bad_cxx_cast_qualifiers_away;
1251     return TC_Failed;
1252   }
1253
1254   if (Paths.isAmbiguous(SrcType.getUnqualifiedType())) {
1255     // This code is analoguous to that in CheckDerivedToBaseConversion, except
1256     // that it builds the paths in reverse order.
1257     // To sum up: record all paths to the base and build a nice string from
1258     // them. Use it to spice up the error message.
1259     if (!Paths.isRecordingPaths()) {
1260       Paths.clear();
1261       Paths.setRecordingPaths(true);
1262       Self.IsDerivedFrom(DestType, SrcType, Paths);
1263     }
1264     std::string PathDisplayStr;
1265     std::set<unsigned> DisplayedPaths;
1266     for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end();
1267          PI != PE; ++PI) {
1268       if (DisplayedPaths.insert(PI->back().SubobjectNumber).second) {
1269         // We haven't displayed a path to this particular base
1270         // class subobject yet.
1271         PathDisplayStr += "\n    ";
1272         for (CXXBasePath::const_reverse_iterator EI = PI->rbegin(),
1273                                                  EE = PI->rend();
1274              EI != EE; ++EI)
1275           PathDisplayStr += EI->Base->getType().getAsString() + " -> ";
1276         PathDisplayStr += QualType(DestType).getAsString();
1277       }
1278     }
1279
1280     Self.Diag(OpRange.getBegin(), diag::err_ambiguous_base_to_derived_cast)
1281       << QualType(SrcType).getUnqualifiedType()
1282       << QualType(DestType).getUnqualifiedType()
1283       << PathDisplayStr << OpRange;
1284     msg = 0;
1285     return TC_Failed;
1286   }
1287
1288   if (Paths.getDetectedVirtual() != nullptr) {
1289     QualType VirtualBase(Paths.getDetectedVirtual(), 0);
1290     Self.Diag(OpRange.getBegin(), diag::err_static_downcast_via_virtual)
1291       << OrigSrcType << OrigDestType << VirtualBase << OpRange;
1292     msg = 0;
1293     return TC_Failed;
1294   }
1295
1296   if (!CStyle) {
1297     switch (Self.CheckBaseClassAccess(OpRange.getBegin(),
1298                                       SrcType, DestType,
1299                                       Paths.front(),
1300                                 diag::err_downcast_from_inaccessible_base)) {
1301     case Sema::AR_accessible:
1302     case Sema::AR_delayed:     // be optimistic
1303     case Sema::AR_dependent:   // be optimistic
1304       break;
1305
1306     case Sema::AR_inaccessible:
1307       msg = 0;
1308       return TC_Failed;
1309     }
1310   }
1311
1312   Self.BuildBasePathArray(Paths, BasePath);
1313   Kind = CK_BaseToDerived;
1314   return TC_Success;
1315 }
1316
1317 /// TryStaticMemberPointerUpcast - Tests whether a conversion according to
1318 /// C++ 5.2.9p9 is valid:
1319 ///
1320 ///   An rvalue of type "pointer to member of D of type cv1 T" can be
1321 ///   converted to an rvalue of type "pointer to member of B of type cv2 T",
1322 ///   where B is a base class of D [...].
1323 ///
1324 TryCastResult
1325 TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType,
1326                              QualType DestType, bool CStyle,
1327                              const SourceRange &OpRange,
1328                              unsigned &msg, CastKind &Kind,
1329                              CXXCastPath &BasePath) {
1330   const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>();
1331   if (!DestMemPtr)
1332     return TC_NotApplicable;
1333
1334   bool WasOverloadedFunction = false;
1335   DeclAccessPair FoundOverload;
1336   if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
1337     if (FunctionDecl *Fn
1338           = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(), DestType, false,
1339                                                     FoundOverload)) {
1340       CXXMethodDecl *M = cast<CXXMethodDecl>(Fn);
1341       SrcType = Self.Context.getMemberPointerType(Fn->getType(),
1342                       Self.Context.getTypeDeclType(M->getParent()).getTypePtr());
1343       WasOverloadedFunction = true;
1344     }
1345   }
1346
1347   const MemberPointerType *SrcMemPtr = SrcType->getAs<MemberPointerType>();
1348   if (!SrcMemPtr) {
1349     msg = diag::err_bad_static_cast_member_pointer_nonmp;
1350     return TC_NotApplicable;
1351   }
1352
1353   // T == T, modulo cv
1354   if (!Self.Context.hasSameUnqualifiedType(SrcMemPtr->getPointeeType(),
1355                                            DestMemPtr->getPointeeType()))
1356     return TC_NotApplicable;
1357
1358   // B base of D
1359   QualType SrcClass(SrcMemPtr->getClass(), 0);
1360   QualType DestClass(DestMemPtr->getClass(), 0);
1361   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1362                   /*DetectVirtual=*/true);
1363   if (Self.RequireCompleteType(OpRange.getBegin(), SrcClass, 0) ||
1364       !Self.IsDerivedFrom(SrcClass, DestClass, Paths)) {
1365     return TC_NotApplicable;
1366   }
1367
1368   // B is a base of D. But is it an allowed base? If not, it's a hard error.
1369   if (Paths.isAmbiguous(Self.Context.getCanonicalType(DestClass))) {
1370     Paths.clear();
1371     Paths.setRecordingPaths(true);
1372     bool StillOkay = Self.IsDerivedFrom(SrcClass, DestClass, Paths);
1373     assert(StillOkay);
1374     (void)StillOkay;
1375     std::string PathDisplayStr = Self.getAmbiguousPathsDisplayString(Paths);
1376     Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv)
1377       << 1 << SrcClass << DestClass << PathDisplayStr << OpRange;
1378     msg = 0;
1379     return TC_Failed;
1380   }
1381
1382   if (const RecordType *VBase = Paths.getDetectedVirtual()) {
1383     Self.Diag(OpRange.getBegin(), diag::err_memptr_conv_via_virtual)
1384       << SrcClass << DestClass << QualType(VBase, 0) << OpRange;
1385     msg = 0;
1386     return TC_Failed;
1387   }
1388
1389   if (!CStyle) {
1390     switch (Self.CheckBaseClassAccess(OpRange.getBegin(),
1391                                       DestClass, SrcClass,
1392                                       Paths.front(),
1393                                       diag::err_upcast_to_inaccessible_base)) {
1394     case Sema::AR_accessible:
1395     case Sema::AR_delayed:
1396     case Sema::AR_dependent:
1397       // Optimistically assume that the delayed and dependent cases
1398       // will work out.
1399       break;
1400
1401     case Sema::AR_inaccessible:
1402       msg = 0;
1403       return TC_Failed;
1404     }
1405   }
1406
1407   if (WasOverloadedFunction) {
1408     // Resolve the address of the overloaded function again, this time
1409     // allowing complaints if something goes wrong.
1410     FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(),
1411                                                                DestType,
1412                                                                true,
1413                                                                FoundOverload);
1414     if (!Fn) {
1415       msg = 0;
1416       return TC_Failed;
1417     }
1418
1419     SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr, FoundOverload, Fn);
1420     if (!SrcExpr.isUsable()) {
1421       msg = 0;
1422       return TC_Failed;
1423     }
1424   }
1425
1426   Self.BuildBasePathArray(Paths, BasePath);
1427   Kind = CK_DerivedToBaseMemberPointer;
1428   return TC_Success;
1429 }
1430
1431 /// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2
1432 /// is valid:
1433 ///
1434 ///   An expression e can be explicitly converted to a type T using a
1435 ///   @c static_cast if the declaration "T t(e);" is well-formed [...].
1436 TryCastResult
1437 TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
1438                       Sema::CheckedConversionKind CCK,
1439                       const SourceRange &OpRange, unsigned &msg,
1440                       CastKind &Kind, bool ListInitialization) {
1441   if (DestType->isRecordType()) {
1442     if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
1443                                  diag::err_bad_dynamic_cast_incomplete) ||
1444         Self.RequireNonAbstractType(OpRange.getBegin(), DestType,
1445                                     diag::err_allocation_of_abstract_type)) {
1446       msg = 0;
1447       return TC_Failed;
1448     }
1449   } else if (DestType->isMemberPointerType()) {
1450     if (Self.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1451       Self.RequireCompleteType(OpRange.getBegin(), DestType, 0);
1452     }
1453   }
1454
1455   InitializedEntity Entity = InitializedEntity::InitializeTemporary(DestType);
1456   InitializationKind InitKind
1457     = (CCK == Sema::CCK_CStyleCast)
1458         ? InitializationKind::CreateCStyleCast(OpRange.getBegin(), OpRange,
1459                                                ListInitialization)
1460     : (CCK == Sema::CCK_FunctionalCast)
1461         ? InitializationKind::CreateFunctionalCast(OpRange, ListInitialization)
1462     : InitializationKind::CreateCast(OpRange);
1463   Expr *SrcExprRaw = SrcExpr.get();
1464   InitializationSequence InitSeq(Self, Entity, InitKind, SrcExprRaw);
1465
1466   // At this point of CheckStaticCast, if the destination is a reference,
1467   // or the expression is an overload expression this has to work.
1468   // There is no other way that works.
1469   // On the other hand, if we're checking a C-style cast, we've still got
1470   // the reinterpret_cast way.
1471   bool CStyle
1472     = (CCK == Sema::CCK_CStyleCast || CCK == Sema::CCK_FunctionalCast);
1473   if (InitSeq.Failed() && (CStyle || !DestType->isReferenceType()))
1474     return TC_NotApplicable;
1475
1476   ExprResult Result = InitSeq.Perform(Self, Entity, InitKind, SrcExprRaw);
1477   if (Result.isInvalid()) {
1478     msg = 0;
1479     return TC_Failed;
1480   }
1481
1482   if (InitSeq.isConstructorInitialization())
1483     Kind = CK_ConstructorConversion;
1484   else
1485     Kind = CK_NoOp;
1486
1487   SrcExpr = Result;
1488   return TC_Success;
1489 }
1490
1491 /// TryConstCast - See if a const_cast from source to destination is allowed,
1492 /// and perform it if it is.
1493 static TryCastResult TryConstCast(Sema &Self, ExprResult &SrcExpr,
1494                                   QualType DestType, bool CStyle,
1495                                   unsigned &msg) {
1496   DestType = Self.Context.getCanonicalType(DestType);
1497   QualType SrcType = SrcExpr.get()->getType();
1498   bool NeedToMaterializeTemporary = false;
1499
1500   if (const ReferenceType *DestTypeTmp =DestType->getAs<ReferenceType>()) {
1501     // C++11 5.2.11p4:
1502     //   if a pointer to T1 can be explicitly converted to the type "pointer to
1503     //   T2" using a const_cast, then the following conversions can also be
1504     //   made:
1505     //    -- an lvalue of type T1 can be explicitly converted to an lvalue of
1506     //       type T2 using the cast const_cast<T2&>;
1507     //    -- a glvalue of type T1 can be explicitly converted to an xvalue of
1508     //       type T2 using the cast const_cast<T2&&>; and
1509     //    -- if T1 is a class type, a prvalue of type T1 can be explicitly
1510     //       converted to an xvalue of type T2 using the cast const_cast<T2&&>.
1511
1512     if (isa<LValueReferenceType>(DestTypeTmp) && !SrcExpr.get()->isLValue()) {
1513       // Cannot const_cast non-lvalue to lvalue reference type. But if this
1514       // is C-style, static_cast might find a way, so we simply suggest a
1515       // message and tell the parent to keep searching.
1516       msg = diag::err_bad_cxx_cast_rvalue;
1517       return TC_NotApplicable;
1518     }
1519
1520     if (isa<RValueReferenceType>(DestTypeTmp) && SrcExpr.get()->isRValue()) {
1521       if (!SrcType->isRecordType()) {
1522         // Cannot const_cast non-class prvalue to rvalue reference type. But if
1523         // this is C-style, static_cast can do this.
1524         msg = diag::err_bad_cxx_cast_rvalue;
1525         return TC_NotApplicable;
1526       }
1527
1528       // Materialize the class prvalue so that the const_cast can bind a
1529       // reference to it.
1530       NeedToMaterializeTemporary = true;
1531     }
1532
1533     // It's not completely clear under the standard whether we can
1534     // const_cast bit-field gl-values.  Doing so would not be
1535     // intrinsically complicated, but for now, we say no for
1536     // consistency with other compilers and await the word of the
1537     // committee.
1538     if (SrcExpr.get()->refersToBitField()) {
1539       msg = diag::err_bad_cxx_cast_bitfield;
1540       return TC_NotApplicable;
1541     }
1542
1543     DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType());
1544     SrcType = Self.Context.getPointerType(SrcType);
1545   }
1546
1547   // C++ 5.2.11p5: For a const_cast involving pointers to data members [...]
1548   //   the rules for const_cast are the same as those used for pointers.
1549
1550   if (!DestType->isPointerType() &&
1551       !DestType->isMemberPointerType() &&
1552       !DestType->isObjCObjectPointerType()) {
1553     // Cannot cast to non-pointer, non-reference type. Note that, if DestType
1554     // was a reference type, we converted it to a pointer above.
1555     // The status of rvalue references isn't entirely clear, but it looks like
1556     // conversion to them is simply invalid.
1557     // C++ 5.2.11p3: For two pointer types [...]
1558     if (!CStyle)
1559       msg = diag::err_bad_const_cast_dest;
1560     return TC_NotApplicable;
1561   }
1562   if (DestType->isFunctionPointerType() ||
1563       DestType->isMemberFunctionPointerType()) {
1564     // Cannot cast direct function pointers.
1565     // C++ 5.2.11p2: [...] where T is any object type or the void type [...]
1566     // T is the ultimate pointee of source and target type.
1567     if (!CStyle)
1568       msg = diag::err_bad_const_cast_dest;
1569     return TC_NotApplicable;
1570   }
1571   SrcType = Self.Context.getCanonicalType(SrcType);
1572
1573   // Unwrap the pointers. Ignore qualifiers. Terminate early if the types are
1574   // completely equal.
1575   // C++ 5.2.11p3 describes the core semantics of const_cast. All cv specifiers
1576   // in multi-level pointers may change, but the level count must be the same,
1577   // as must be the final pointee type.
1578   while (SrcType != DestType &&
1579          Self.Context.UnwrapSimilarPointerTypes(SrcType, DestType)) {
1580     Qualifiers SrcQuals, DestQuals;
1581     SrcType = Self.Context.getUnqualifiedArrayType(SrcType, SrcQuals);
1582     DestType = Self.Context.getUnqualifiedArrayType(DestType, DestQuals);
1583
1584     // const_cast is permitted to strip cvr-qualifiers, only. Make sure that
1585     // the other qualifiers (e.g., address spaces) are identical.
1586     SrcQuals.removeCVRQualifiers();
1587     DestQuals.removeCVRQualifiers();
1588     if (SrcQuals != DestQuals)
1589       return TC_NotApplicable;
1590   }
1591
1592   // Since we're dealing in canonical types, the remainder must be the same.
1593   if (SrcType != DestType)
1594     return TC_NotApplicable;
1595
1596   if (NeedToMaterializeTemporary)
1597     // This is a const_cast from a class prvalue to an rvalue reference type.
1598     // Materialize a temporary to store the result of the conversion.
1599     SrcExpr = new (Self.Context) MaterializeTemporaryExpr(
1600         SrcType, SrcExpr.get(), /*IsLValueReference*/ false);
1601
1602   return TC_Success;
1603 }
1604
1605 // Checks for undefined behavior in reinterpret_cast.
1606 // The cases that is checked for is:
1607 // *reinterpret_cast<T*>(&a)
1608 // reinterpret_cast<T&>(a)
1609 // where accessing 'a' as type 'T' will result in undefined behavior.
1610 void Sema::CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,
1611                                           bool IsDereference,
1612                                           SourceRange Range) {
1613   unsigned DiagID = IsDereference ?
1614                         diag::warn_pointer_indirection_from_incompatible_type :
1615                         diag::warn_undefined_reinterpret_cast;
1616
1617   if (Diags.isIgnored(DiagID, Range.getBegin()))
1618     return;
1619
1620   QualType SrcTy, DestTy;
1621   if (IsDereference) {
1622     if (!SrcType->getAs<PointerType>() || !DestType->getAs<PointerType>()) {
1623       return;
1624     }
1625     SrcTy = SrcType->getPointeeType();
1626     DestTy = DestType->getPointeeType();
1627   } else {
1628     if (!DestType->getAs<ReferenceType>()) {
1629       return;
1630     }
1631     SrcTy = SrcType;
1632     DestTy = DestType->getPointeeType();
1633   }
1634
1635   // Cast is compatible if the types are the same.
1636   if (Context.hasSameUnqualifiedType(DestTy, SrcTy)) {
1637     return;
1638   }
1639   // or one of the types is a char or void type
1640   if (DestTy->isAnyCharacterType() || DestTy->isVoidType() ||
1641       SrcTy->isAnyCharacterType() || SrcTy->isVoidType()) {
1642     return;
1643   }
1644   // or one of the types is a tag type.
1645   if (SrcTy->getAs<TagType>() || DestTy->getAs<TagType>()) {
1646     return;
1647   }
1648
1649   // FIXME: Scoped enums?
1650   if ((SrcTy->isUnsignedIntegerType() && DestTy->isSignedIntegerType()) ||
1651       (SrcTy->isSignedIntegerType() && DestTy->isUnsignedIntegerType())) {
1652     if (Context.getTypeSize(DestTy) == Context.getTypeSize(SrcTy)) {
1653       return;
1654     }
1655   }
1656
1657   Diag(Range.getBegin(), DiagID) << SrcType << DestType << Range;
1658 }
1659
1660 static void DiagnoseCastOfObjCSEL(Sema &Self, const ExprResult &SrcExpr,
1661                                   QualType DestType) {
1662   QualType SrcType = SrcExpr.get()->getType();
1663   if (Self.Context.hasSameType(SrcType, DestType))
1664     return;
1665   if (const PointerType *SrcPtrTy = SrcType->getAs<PointerType>())
1666     if (SrcPtrTy->isObjCSelType()) {
1667       QualType DT = DestType;
1668       if (isa<PointerType>(DestType))
1669         DT = DestType->getPointeeType();
1670       if (!DT.getUnqualifiedType()->isVoidType())
1671         Self.Diag(SrcExpr.get()->getExprLoc(),
1672                   diag::warn_cast_pointer_from_sel)
1673         << SrcType << DestType << SrcExpr.get()->getSourceRange();
1674     }
1675 }
1676
1677 static void checkIntToPointerCast(bool CStyle, SourceLocation Loc,
1678                                   const Expr *SrcExpr, QualType DestType,
1679                                   Sema &Self) {
1680   QualType SrcType = SrcExpr->getType();
1681
1682   // Not warning on reinterpret_cast, boolean, constant expressions, etc
1683   // are not explicit design choices, but consistent with GCC's behavior.
1684   // Feel free to modify them if you've reason/evidence for an alternative.
1685   if (CStyle && SrcType->isIntegralType(Self.Context)
1686       && !SrcType->isBooleanType()
1687       && !SrcType->isEnumeralType()
1688       && !SrcExpr->isIntegerConstantExpr(Self.Context)
1689       && Self.Context.getTypeSize(DestType) >
1690          Self.Context.getTypeSize(SrcType)) {
1691     // Separate between casts to void* and non-void* pointers.
1692     // Some APIs use (abuse) void* for something like a user context,
1693     // and often that value is an integer even if it isn't a pointer itself.
1694     // Having a separate warning flag allows users to control the warning
1695     // for their workflow.
1696     unsigned Diag = DestType->isVoidPointerType() ?
1697                       diag::warn_int_to_void_pointer_cast
1698                     : diag::warn_int_to_pointer_cast;
1699     Self.Diag(Loc, Diag) << SrcType << DestType;
1700   }
1701 }
1702
1703 static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
1704                                         QualType DestType, bool CStyle,
1705                                         const SourceRange &OpRange,
1706                                         unsigned &msg,
1707                                         CastKind &Kind) {
1708   bool IsLValueCast = false;
1709
1710   DestType = Self.Context.getCanonicalType(DestType);
1711   QualType SrcType = SrcExpr.get()->getType();
1712
1713   // Is the source an overloaded name? (i.e. &foo)
1714   // If so, reinterpret_cast can not help us here (13.4, p1, bullet 5) ...
1715   if (SrcType == Self.Context.OverloadTy) {
1716     // ... unless foo<int> resolves to an lvalue unambiguously.
1717     // TODO: what if this fails because of DiagnoseUseOfDecl or something
1718     // like it?
1719     ExprResult SingleFunctionExpr = SrcExpr;
1720     if (Self.ResolveAndFixSingleFunctionTemplateSpecialization(
1721           SingleFunctionExpr,
1722           Expr::getValueKindForType(DestType) == VK_RValue // Convert Fun to Ptr
1723         ) && SingleFunctionExpr.isUsable()) {
1724       SrcExpr = SingleFunctionExpr;
1725       SrcType = SrcExpr.get()->getType();
1726     } else {
1727       return TC_NotApplicable;
1728     }
1729   }
1730
1731   if (const ReferenceType *DestTypeTmp = DestType->getAs<ReferenceType>()) {
1732     if (!SrcExpr.get()->isGLValue()) {
1733       // Cannot cast non-glvalue to (lvalue or rvalue) reference type. See the
1734       // similar comment in const_cast.
1735       msg = diag::err_bad_cxx_cast_rvalue;
1736       return TC_NotApplicable;
1737     }
1738
1739     if (!CStyle) {
1740       Self.CheckCompatibleReinterpretCast(SrcType, DestType,
1741                                           /*isDereference=*/false, OpRange);
1742     }
1743
1744     // C++ 5.2.10p10: [...] a reference cast reinterpret_cast<T&>(x) has the
1745     //   same effect as the conversion *reinterpret_cast<T*>(&x) with the
1746     //   built-in & and * operators.
1747
1748     const char *inappropriate = nullptr;
1749     switch (SrcExpr.get()->getObjectKind()) {
1750     case OK_Ordinary:
1751       break;
1752     case OK_BitField:        inappropriate = "bit-field";           break;
1753     case OK_VectorComponent: inappropriate = "vector element";      break;
1754     case OK_ObjCProperty:    inappropriate = "property expression"; break;
1755     case OK_ObjCSubscript:   inappropriate = "container subscripting expression";
1756                              break;
1757     }
1758     if (inappropriate) {
1759       Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_reference)
1760           << inappropriate << DestType
1761           << OpRange << SrcExpr.get()->getSourceRange();
1762       msg = 0; SrcExpr = ExprError();
1763       return TC_NotApplicable;
1764     }
1765
1766     // This code does this transformation for the checked types.
1767     DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType());
1768     SrcType = Self.Context.getPointerType(SrcType);
1769
1770     IsLValueCast = true;
1771   }
1772
1773   // Canonicalize source for comparison.
1774   SrcType = Self.Context.getCanonicalType(SrcType);
1775
1776   const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>(),
1777                           *SrcMemPtr = SrcType->getAs<MemberPointerType>();
1778   if (DestMemPtr && SrcMemPtr) {
1779     // C++ 5.2.10p9: An rvalue of type "pointer to member of X of type T1"
1780     //   can be explicitly converted to an rvalue of type "pointer to member
1781     //   of Y of type T2" if T1 and T2 are both function types or both object
1782     //   types.
1783     if (DestMemPtr->getPointeeType()->isFunctionType() !=
1784         SrcMemPtr->getPointeeType()->isFunctionType())
1785       return TC_NotApplicable;
1786
1787     // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away
1788     //   constness.
1789     // A reinterpret_cast followed by a const_cast can, though, so in C-style,
1790     // we accept it.
1791     if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle,
1792                            /*CheckObjCLifetime=*/CStyle)) {
1793       msg = diag::err_bad_cxx_cast_qualifiers_away;
1794       return TC_Failed;
1795     }
1796
1797     if (Self.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1798       // We need to determine the inheritance model that the class will use if
1799       // haven't yet.
1800       Self.RequireCompleteType(OpRange.getBegin(), SrcType, 0);
1801       Self.RequireCompleteType(OpRange.getBegin(), DestType, 0);
1802     }
1803
1804     // Don't allow casting between member pointers of different sizes.
1805     if (Self.Context.getTypeSize(DestMemPtr) !=
1806         Self.Context.getTypeSize(SrcMemPtr)) {
1807       msg = diag::err_bad_cxx_cast_member_pointer_size;
1808       return TC_Failed;
1809     }
1810
1811     // A valid member pointer cast.
1812     assert(!IsLValueCast);
1813     Kind = CK_ReinterpretMemberPointer;
1814     return TC_Success;
1815   }
1816
1817   // See below for the enumeral issue.
1818   if (SrcType->isNullPtrType() && DestType->isIntegralType(Self.Context)) {
1819     // C++0x 5.2.10p4: A pointer can be explicitly converted to any integral
1820     //   type large enough to hold it. A value of std::nullptr_t can be
1821     //   converted to an integral type; the conversion has the same meaning
1822     //   and validity as a conversion of (void*)0 to the integral type.
1823     if (Self.Context.getTypeSize(SrcType) >
1824         Self.Context.getTypeSize(DestType)) {
1825       msg = diag::err_bad_reinterpret_cast_small_int;
1826       return TC_Failed;
1827     }
1828     Kind = CK_PointerToIntegral;
1829     return TC_Success;
1830   }
1831
1832   bool destIsVector = DestType->isVectorType();
1833   bool srcIsVector = SrcType->isVectorType();
1834   if (srcIsVector || destIsVector) {
1835     // FIXME: Should this also apply to floating point types?
1836     bool srcIsScalar = SrcType->isIntegralType(Self.Context);
1837     bool destIsScalar = DestType->isIntegralType(Self.Context);
1838
1839     // Check if this is a cast between a vector and something else.
1840     if (!(srcIsScalar && destIsVector) && !(srcIsVector && destIsScalar) &&
1841         !(srcIsVector && destIsVector))
1842       return TC_NotApplicable;
1843
1844     // If both types have the same size, we can successfully cast.
1845     if (Self.Context.getTypeSize(SrcType)
1846           == Self.Context.getTypeSize(DestType)) {
1847       Kind = CK_BitCast;
1848       return TC_Success;
1849     }
1850
1851     if (destIsScalar)
1852       msg = diag::err_bad_cxx_cast_vector_to_scalar_different_size;
1853     else if (srcIsScalar)
1854       msg = diag::err_bad_cxx_cast_scalar_to_vector_different_size;
1855     else
1856       msg = diag::err_bad_cxx_cast_vector_to_vector_different_size;
1857
1858     return TC_Failed;
1859   }
1860
1861   if (SrcType == DestType) {
1862     // C++ 5.2.10p2 has a note that mentions that, subject to all other
1863     // restrictions, a cast to the same type is allowed so long as it does not
1864     // cast away constness. In C++98, the intent was not entirely clear here,
1865     // since all other paragraphs explicitly forbid casts to the same type.
1866     // C++11 clarifies this case with p2.
1867     //
1868     // The only allowed types are: integral, enumeration, pointer, or
1869     // pointer-to-member types.  We also won't restrict Obj-C pointers either.
1870     Kind = CK_NoOp;
1871     TryCastResult Result = TC_NotApplicable;
1872     if (SrcType->isIntegralOrEnumerationType() ||
1873         SrcType->isAnyPointerType() ||
1874         SrcType->isMemberPointerType() ||
1875         SrcType->isBlockPointerType()) {
1876       Result = TC_Success;
1877     }
1878     return Result;
1879   }
1880
1881   bool destIsPtr = DestType->isAnyPointerType() ||
1882                    DestType->isBlockPointerType();
1883   bool srcIsPtr = SrcType->isAnyPointerType() ||
1884                   SrcType->isBlockPointerType();
1885   if (!destIsPtr && !srcIsPtr) {
1886     // Except for std::nullptr_t->integer and lvalue->reference, which are
1887     // handled above, at least one of the two arguments must be a pointer.
1888     return TC_NotApplicable;
1889   }
1890
1891   if (DestType->isIntegralType(Self.Context)) {
1892     assert(srcIsPtr && "One type must be a pointer");
1893     // C++ 5.2.10p4: A pointer can be explicitly converted to any integral
1894     //   type large enough to hold it; except in Microsoft mode, where the
1895     //   integral type size doesn't matter (except we don't allow bool).
1896     bool MicrosoftException = Self.getLangOpts().MicrosoftExt &&
1897                               !DestType->isBooleanType();
1898     if ((Self.Context.getTypeSize(SrcType) >
1899          Self.Context.getTypeSize(DestType)) &&
1900          !MicrosoftException) {
1901       msg = diag::err_bad_reinterpret_cast_small_int;
1902       return TC_Failed;
1903     }
1904     Kind = CK_PointerToIntegral;
1905     return TC_Success;
1906   }
1907
1908   if (SrcType->isIntegralOrEnumerationType()) {
1909     assert(destIsPtr && "One type must be a pointer");
1910     checkIntToPointerCast(CStyle, OpRange.getBegin(), SrcExpr.get(), DestType,
1911                           Self);
1912     // C++ 5.2.10p5: A value of integral or enumeration type can be explicitly
1913     //   converted to a pointer.
1914     // C++ 5.2.10p9: [Note: ...a null pointer constant of integral type is not
1915     //   necessarily converted to a null pointer value.]
1916     Kind = CK_IntegralToPointer;
1917     return TC_Success;
1918   }
1919
1920   if (!destIsPtr || !srcIsPtr) {
1921     // With the valid non-pointer conversions out of the way, we can be even
1922     // more stringent.
1923     return TC_NotApplicable;
1924   }
1925
1926   // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away constness.
1927   // The C-style cast operator can.
1928   if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle,
1929                          /*CheckObjCLifetime=*/CStyle)) {
1930     msg = diag::err_bad_cxx_cast_qualifiers_away;
1931     return TC_Failed;
1932   }
1933
1934   // Cannot convert between block pointers and Objective-C object pointers.
1935   if ((SrcType->isBlockPointerType() && DestType->isObjCObjectPointerType()) ||
1936       (DestType->isBlockPointerType() && SrcType->isObjCObjectPointerType()))
1937     return TC_NotApplicable;
1938
1939   if (IsLValueCast) {
1940     Kind = CK_LValueBitCast;
1941   } else if (DestType->isObjCObjectPointerType()) {
1942     Kind = Self.PrepareCastToObjCObjectPointer(SrcExpr);
1943   } else if (DestType->isBlockPointerType()) {
1944     if (!SrcType->isBlockPointerType()) {
1945       Kind = CK_AnyPointerToBlockPointerCast;
1946     } else {
1947       Kind = CK_BitCast;
1948     }
1949   } else {
1950     Kind = CK_BitCast;
1951   }
1952
1953   // Any pointer can be cast to an Objective-C pointer type with a C-style
1954   // cast.
1955   if (CStyle && DestType->isObjCObjectPointerType()) {
1956     return TC_Success;
1957   }
1958   if (CStyle)
1959     DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType);
1960
1961   // Not casting away constness, so the only remaining check is for compatible
1962   // pointer categories.
1963
1964   if (SrcType->isFunctionPointerType()) {
1965     if (DestType->isFunctionPointerType()) {
1966       // C++ 5.2.10p6: A pointer to a function can be explicitly converted to
1967       // a pointer to a function of a different type.
1968       return TC_Success;
1969     }
1970
1971     // C++0x 5.2.10p8: Converting a pointer to a function into a pointer to
1972     //   an object type or vice versa is conditionally-supported.
1973     // Compilers support it in C++03 too, though, because it's necessary for
1974     // casting the return value of dlsym() and GetProcAddress().
1975     // FIXME: Conditionally-supported behavior should be configurable in the
1976     // TargetInfo or similar.
1977     Self.Diag(OpRange.getBegin(),
1978               Self.getLangOpts().CPlusPlus11 ?
1979                 diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj)
1980       << OpRange;
1981     return TC_Success;
1982   }
1983
1984   if (DestType->isFunctionPointerType()) {
1985     // See above.
1986     Self.Diag(OpRange.getBegin(),
1987               Self.getLangOpts().CPlusPlus11 ?
1988                 diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj)
1989       << OpRange;
1990     return TC_Success;
1991   }
1992
1993   // C++ 5.2.10p7: A pointer to an object can be explicitly converted to
1994   //   a pointer to an object of different type.
1995   // Void pointers are not specified, but supported by every compiler out there.
1996   // So we finish by allowing everything that remains - it's got to be two
1997   // object pointers.
1998   return TC_Success;
1999 }
2000
2001 void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
2002                                        bool ListInitialization) {
2003   // Handle placeholders.
2004   if (isPlaceholder()) {
2005     // C-style casts can resolve __unknown_any types.
2006     if (claimPlaceholder(BuiltinType::UnknownAny)) {
2007       SrcExpr = Self.checkUnknownAnyCast(DestRange, DestType,
2008                                          SrcExpr.get(), Kind,
2009                                          ValueKind, BasePath);
2010       return;
2011     }
2012
2013     checkNonOverloadPlaceholders();
2014     if (SrcExpr.isInvalid())
2015       return;
2016   }
2017
2018   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
2019   // This test is outside everything else because it's the only case where
2020   // a non-lvalue-reference target type does not lead to decay.
2021   if (DestType->isVoidType()) {
2022     Kind = CK_ToVoid;
2023
2024     if (claimPlaceholder(BuiltinType::Overload)) {
2025       Self.ResolveAndFixSingleFunctionTemplateSpecialization(
2026                   SrcExpr, /* Decay Function to ptr */ false,
2027                   /* Complain */ true, DestRange, DestType,
2028                   diag::err_bad_cstyle_cast_overload);
2029       if (SrcExpr.isInvalid())
2030         return;
2031     }
2032
2033     SrcExpr = Self.IgnoredValueConversions(SrcExpr.get());
2034     return;
2035   }
2036
2037   // If the type is dependent, we won't do any other semantic analysis now.
2038   if (DestType->isDependentType() || SrcExpr.get()->isTypeDependent() ||
2039       SrcExpr.get()->isValueDependent()) {
2040     assert(Kind == CK_Dependent);
2041     return;
2042   }
2043
2044   if (ValueKind == VK_RValue && !DestType->isRecordType() &&
2045       !isPlaceholder(BuiltinType::Overload)) {
2046     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
2047     if (SrcExpr.isInvalid())
2048       return;
2049   }
2050
2051   // AltiVec vector initialization with a single literal.
2052   if (const VectorType *vecTy = DestType->getAs<VectorType>())
2053     if (vecTy->getVectorKind() == VectorType::AltiVecVector
2054         && (SrcExpr.get()->getType()->isIntegerType()
2055             || SrcExpr.get()->getType()->isFloatingType())) {
2056       Kind = CK_VectorSplat;
2057       return;
2058     }
2059
2060   // C++ [expr.cast]p5: The conversions performed by
2061   //   - a const_cast,
2062   //   - a static_cast,
2063   //   - a static_cast followed by a const_cast,
2064   //   - a reinterpret_cast, or
2065   //   - a reinterpret_cast followed by a const_cast,
2066   //   can be performed using the cast notation of explicit type conversion.
2067   //   [...] If a conversion can be interpreted in more than one of the ways
2068   //   listed above, the interpretation that appears first in the list is used,
2069   //   even if a cast resulting from that interpretation is ill-formed.
2070   // In plain language, this means trying a const_cast ...
2071   unsigned msg = diag::err_bad_cxx_cast_generic;
2072   TryCastResult tcr = TryConstCast(Self, SrcExpr, DestType,
2073                                    /*CStyle*/true, msg);
2074   if (SrcExpr.isInvalid())
2075     return;
2076   if (tcr == TC_Success)
2077     Kind = CK_NoOp;
2078
2079   Sema::CheckedConversionKind CCK
2080     = FunctionalStyle? Sema::CCK_FunctionalCast
2081                      : Sema::CCK_CStyleCast;
2082   if (tcr == TC_NotApplicable) {
2083     // ... or if that is not possible, a static_cast, ignoring const, ...
2084     tcr = TryStaticCast(Self, SrcExpr, DestType, CCK, OpRange,
2085                         msg, Kind, BasePath, ListInitialization);
2086     if (SrcExpr.isInvalid())
2087       return;
2088
2089     if (tcr == TC_NotApplicable) {
2090       // ... and finally a reinterpret_cast, ignoring const.
2091       tcr = TryReinterpretCast(Self, SrcExpr, DestType, /*CStyle*/true,
2092                                OpRange, msg, Kind);
2093       if (SrcExpr.isInvalid())
2094         return;
2095     }
2096   }
2097
2098   if (Self.getLangOpts().ObjCAutoRefCount && tcr == TC_Success)
2099     checkObjCARCConversion(CCK);
2100
2101   if (tcr != TC_Success && msg != 0) {
2102     if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
2103       DeclAccessPair Found;
2104       FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(),
2105                                 DestType,
2106                                 /*Complain*/ true,
2107                                 Found);
2108       if (Fn) {
2109         // If DestType is a function type (not to be confused with the function
2110         // pointer type), it will be possible to resolve the function address,
2111         // but the type cast should be considered as failure.
2112         OverloadExpr *OE = OverloadExpr::find(SrcExpr.get()).Expression;
2113         Self.Diag(OpRange.getBegin(), diag::err_bad_cstyle_cast_overload)
2114           << OE->getName() << DestType << OpRange
2115           << OE->getQualifierLoc().getSourceRange();
2116         Self.NoteAllOverloadCandidates(SrcExpr.get());
2117       }
2118     } else {
2119       diagnoseBadCast(Self, msg, (FunctionalStyle ? CT_Functional : CT_CStyle),
2120                       OpRange, SrcExpr.get(), DestType, ListInitialization);
2121     }
2122   } else if (Kind == CK_BitCast) {
2123     checkCastAlign();
2124   }
2125
2126   // Clear out SrcExpr if there was a fatal error.
2127   if (tcr != TC_Success)
2128     SrcExpr = ExprError();
2129 }
2130
2131 /// DiagnoseBadFunctionCast - Warn whenever a function call is cast to a
2132 ///  non-matching type. Such as enum function call to int, int call to
2133 /// pointer; etc. Cast to 'void' is an exception.
2134 static void DiagnoseBadFunctionCast(Sema &Self, const ExprResult &SrcExpr,
2135                                   QualType DestType) {
2136   if (Self.Diags.isIgnored(diag::warn_bad_function_cast,
2137                            SrcExpr.get()->getExprLoc()))
2138     return;
2139
2140   if (!isa<CallExpr>(SrcExpr.get()))
2141     return;
2142
2143   QualType SrcType = SrcExpr.get()->getType();
2144   if (DestType.getUnqualifiedType()->isVoidType())
2145     return;
2146   if ((SrcType->isAnyPointerType() || SrcType->isBlockPointerType())
2147       && (DestType->isAnyPointerType() || DestType->isBlockPointerType()))
2148     return;
2149   if (SrcType->isIntegerType() && DestType->isIntegerType() &&
2150       (SrcType->isBooleanType() == DestType->isBooleanType()) &&
2151       (SrcType->isEnumeralType() == DestType->isEnumeralType()))
2152     return;
2153   if (SrcType->isRealFloatingType() && DestType->isRealFloatingType())
2154     return;
2155   if (SrcType->isEnumeralType() && DestType->isEnumeralType())
2156     return;
2157   if (SrcType->isComplexType() && DestType->isComplexType())
2158     return;
2159   if (SrcType->isComplexIntegerType() && DestType->isComplexIntegerType())
2160     return;
2161
2162   Self.Diag(SrcExpr.get()->getExprLoc(),
2163             diag::warn_bad_function_cast)
2164             << SrcType << DestType << SrcExpr.get()->getSourceRange();
2165 }
2166
2167 /// Check the semantics of a C-style cast operation, in C.
2168 void CastOperation::CheckCStyleCast() {
2169   assert(!Self.getLangOpts().CPlusPlus);
2170
2171   // C-style casts can resolve __unknown_any types.
2172   if (claimPlaceholder(BuiltinType::UnknownAny)) {
2173     SrcExpr = Self.checkUnknownAnyCast(DestRange, DestType,
2174                                        SrcExpr.get(), Kind,
2175                                        ValueKind, BasePath);
2176     return;
2177   }
2178
2179   // C99 6.5.4p2: the cast type needs to be void or scalar and the expression
2180   // type needs to be scalar.
2181   if (DestType->isVoidType()) {
2182     // We don't necessarily do lvalue-to-rvalue conversions on this.
2183     SrcExpr = Self.IgnoredValueConversions(SrcExpr.get());
2184     if (SrcExpr.isInvalid())
2185       return;
2186
2187     // Cast to void allows any expr type.
2188     Kind = CK_ToVoid;
2189     return;
2190   }
2191
2192   SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
2193   if (SrcExpr.isInvalid())
2194     return;
2195   QualType SrcType = SrcExpr.get()->getType();
2196
2197   assert(!SrcType->isPlaceholderType());
2198
2199   // OpenCL v1 s6.5: Casting a pointer to address space A to a pointer to
2200   // address space B is illegal.
2201   if (Self.getLangOpts().OpenCL && DestType->isPointerType() &&
2202       SrcType->isPointerType()) {
2203     if (DestType->getPointeeType().getAddressSpace() !=
2204         SrcType->getPointeeType().getAddressSpace()) {
2205       Self.Diag(OpRange.getBegin(),
2206                 diag::err_typecheck_incompatible_address_space)
2207           << SrcType << DestType << Sema::AA_Casting
2208           << SrcExpr.get()->getSourceRange();
2209       SrcExpr = ExprError();
2210       return;
2211     }
2212   }
2213
2214   if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
2215                                diag::err_typecheck_cast_to_incomplete)) {
2216     SrcExpr = ExprError();
2217     return;
2218   }
2219
2220   if (!DestType->isScalarType() && !DestType->isVectorType()) {
2221     const RecordType *DestRecordTy = DestType->getAs<RecordType>();
2222
2223     if (DestRecordTy && Self.Context.hasSameUnqualifiedType(DestType, SrcType)){
2224       // GCC struct/union extension: allow cast to self.
2225       Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_nonscalar)
2226         << DestType << SrcExpr.get()->getSourceRange();
2227       Kind = CK_NoOp;
2228       return;
2229     }
2230
2231     // GCC's cast to union extension.
2232     if (DestRecordTy && DestRecordTy->getDecl()->isUnion()) {
2233       RecordDecl *RD = DestRecordTy->getDecl();
2234       RecordDecl::field_iterator Field, FieldEnd;
2235       for (Field = RD->field_begin(), FieldEnd = RD->field_end();
2236            Field != FieldEnd; ++Field) {
2237         if (Self.Context.hasSameUnqualifiedType(Field->getType(), SrcType) &&
2238             !Field->isUnnamedBitfield()) {
2239           Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_to_union)
2240             << SrcExpr.get()->getSourceRange();
2241           break;
2242         }
2243       }
2244       if (Field == FieldEnd) {
2245         Self.Diag(OpRange.getBegin(), diag::err_typecheck_cast_to_union_no_type)
2246           << SrcType << SrcExpr.get()->getSourceRange();
2247         SrcExpr = ExprError();
2248         return;
2249       }
2250       Kind = CK_ToUnion;
2251       return;
2252     }
2253
2254     // Reject any other conversions to non-scalar types.
2255     Self.Diag(OpRange.getBegin(), diag::err_typecheck_cond_expect_scalar)
2256       << DestType << SrcExpr.get()->getSourceRange();
2257     SrcExpr = ExprError();
2258     return;
2259   }
2260
2261   // The type we're casting to is known to be a scalar or vector.
2262
2263   // Require the operand to be a scalar or vector.
2264   if (!SrcType->isScalarType() && !SrcType->isVectorType()) {
2265     Self.Diag(SrcExpr.get()->getExprLoc(),
2266               diag::err_typecheck_expect_scalar_operand)
2267       << SrcType << SrcExpr.get()->getSourceRange();
2268     SrcExpr = ExprError();
2269     return;
2270   }
2271
2272   if (DestType->isExtVectorType()) {
2273     SrcExpr = Self.CheckExtVectorCast(OpRange, DestType, SrcExpr.get(), Kind);
2274     return;
2275   }
2276
2277   if (const VectorType *DestVecTy = DestType->getAs<VectorType>()) {
2278     if (DestVecTy->getVectorKind() == VectorType::AltiVecVector &&
2279           (SrcType->isIntegerType() || SrcType->isFloatingType())) {
2280       Kind = CK_VectorSplat;
2281     } else if (Self.CheckVectorCast(OpRange, DestType, SrcType, Kind)) {
2282       SrcExpr = ExprError();
2283     }
2284     return;
2285   }
2286
2287   if (SrcType->isVectorType()) {
2288     if (Self.CheckVectorCast(OpRange, SrcType, DestType, Kind))
2289       SrcExpr = ExprError();
2290     return;
2291   }
2292
2293   // The source and target types are both scalars, i.e.
2294   //   - arithmetic types (fundamental, enum, and complex)
2295   //   - all kinds of pointers
2296   // Note that member pointers were filtered out with C++, above.
2297
2298   if (isa<ObjCSelectorExpr>(SrcExpr.get())) {
2299     Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_selector_expr);
2300     SrcExpr = ExprError();
2301     return;
2302   }
2303
2304   // If either type is a pointer, the other type has to be either an
2305   // integer or a pointer.
2306   if (!DestType->isArithmeticType()) {
2307     if (!SrcType->isIntegralType(Self.Context) && SrcType->isArithmeticType()) {
2308       Self.Diag(SrcExpr.get()->getExprLoc(),
2309                 diag::err_cast_pointer_from_non_pointer_int)
2310         << SrcType << SrcExpr.get()->getSourceRange();
2311       SrcExpr = ExprError();
2312       return;
2313     }
2314     checkIntToPointerCast(/* CStyle */ true, OpRange.getBegin(), SrcExpr.get(),
2315                           DestType, Self);
2316   } else if (!SrcType->isArithmeticType()) {
2317     if (!DestType->isIntegralType(Self.Context) &&
2318         DestType->isArithmeticType()) {
2319       Self.Diag(SrcExpr.get()->getLocStart(),
2320            diag::err_cast_pointer_to_non_pointer_int)
2321         << DestType << SrcExpr.get()->getSourceRange();
2322       SrcExpr = ExprError();
2323       return;
2324     }
2325   }
2326
2327   if (Self.getLangOpts().OpenCL && !Self.getOpenCLOptions().cl_khr_fp16) {
2328     if (DestType->isHalfType()) {
2329       Self.Diag(SrcExpr.get()->getLocStart(), diag::err_opencl_cast_to_half)
2330         << DestType << SrcExpr.get()->getSourceRange();
2331       SrcExpr = ExprError();
2332       return;
2333     }
2334   }
2335
2336   // ARC imposes extra restrictions on casts.
2337   if (Self.getLangOpts().ObjCAutoRefCount) {
2338     checkObjCARCConversion(Sema::CCK_CStyleCast);
2339     if (SrcExpr.isInvalid())
2340       return;
2341
2342     if (const PointerType *CastPtr = DestType->getAs<PointerType>()) {
2343       if (const PointerType *ExprPtr = SrcType->getAs<PointerType>()) {
2344         Qualifiers CastQuals = CastPtr->getPointeeType().getQualifiers();
2345         Qualifiers ExprQuals = ExprPtr->getPointeeType().getQualifiers();
2346         if (CastPtr->getPointeeType()->isObjCLifetimeType() &&
2347             ExprPtr->getPointeeType()->isObjCLifetimeType() &&
2348             !CastQuals.compatiblyIncludesObjCLifetime(ExprQuals)) {
2349           Self.Diag(SrcExpr.get()->getLocStart(),
2350                     diag::err_typecheck_incompatible_ownership)
2351             << SrcType << DestType << Sema::AA_Casting
2352             << SrcExpr.get()->getSourceRange();
2353           return;
2354         }
2355       }
2356     }
2357     else if (!Self.CheckObjCARCUnavailableWeakConversion(DestType, SrcType)) {
2358       Self.Diag(SrcExpr.get()->getLocStart(),
2359                 diag::err_arc_convesion_of_weak_unavailable)
2360         << 1 << SrcType << DestType << SrcExpr.get()->getSourceRange();
2361       SrcExpr = ExprError();
2362       return;
2363     }
2364   }
2365
2366   DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType);
2367   DiagnoseBadFunctionCast(Self, SrcExpr, DestType);
2368   Kind = Self.PrepareScalarCast(SrcExpr, DestType);
2369   if (SrcExpr.isInvalid())
2370     return;
2371
2372   if (Kind == CK_BitCast)
2373     checkCastAlign();
2374 }
2375
2376 ExprResult Sema::BuildCStyleCastExpr(SourceLocation LPLoc,
2377                                      TypeSourceInfo *CastTypeInfo,
2378                                      SourceLocation RPLoc,
2379                                      Expr *CastExpr) {
2380   CastOperation Op(*this, CastTypeInfo->getType(), CastExpr);
2381   Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
2382   Op.OpRange = SourceRange(LPLoc, CastExpr->getLocEnd());
2383
2384   if (getLangOpts().CPlusPlus) {
2385     Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ false,
2386                           isa<InitListExpr>(CastExpr));
2387   } else {
2388     Op.CheckCStyleCast();
2389   }
2390
2391   if (Op.SrcExpr.isInvalid())
2392     return ExprError();
2393
2394   return Op.complete(CStyleCastExpr::Create(Context, Op.ResultType,
2395                               Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
2396                               &Op.BasePath, CastTypeInfo, LPLoc, RPLoc));
2397 }
2398
2399 ExprResult Sema::BuildCXXFunctionalCastExpr(TypeSourceInfo *CastTypeInfo,
2400                                             SourceLocation LPLoc,
2401                                             Expr *CastExpr,
2402                                             SourceLocation RPLoc) {
2403   assert(LPLoc.isValid() && "List-initialization shouldn't get here.");
2404   CastOperation Op(*this, CastTypeInfo->getType(), CastExpr);
2405   Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
2406   Op.OpRange = SourceRange(Op.DestRange.getBegin(), CastExpr->getLocEnd());
2407
2408   Op.CheckCXXCStyleCast(/*FunctionalStyle=*/true, /*ListInit=*/false);
2409   if (Op.SrcExpr.isInvalid())
2410     return ExprError();
2411
2412   if (CXXConstructExpr *ConstructExpr = dyn_cast<CXXConstructExpr>(Op.SrcExpr.get()))
2413     ConstructExpr->setParenOrBraceRange(SourceRange(LPLoc, RPLoc));
2414
2415   return Op.complete(CXXFunctionalCastExpr::Create(Context, Op.ResultType,
2416                          Op.ValueKind, CastTypeInfo, Op.Kind,
2417                          Op.SrcExpr.get(), &Op.BasePath, LPLoc, RPLoc));
2418 }