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

   1 //===--- SemaNamedCast.cpp - Semantic Analysis for Named 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 C++ named casts.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Sema/SemaInternal.h"
  15 #include "clang/Sema/Initialization.h"
  16 #include "clang/AST/ExprCXX.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/CXXInheritance.h"
  19 #include "clang/Basic/PartialDiagnostic.h"
  20 #include "llvm/ADT/SmallVector.h"
  21 #include <set>
  22 using namespace clang;
  23
  24
  25
  26 enum TryCastResult {
  27   TC_NotApplicable, ///< The cast method is not applicable.
  28   TC_Success,       ///< The cast method is appropriate and successful.
  29   TC_Failed         ///< The cast method is appropriate, but failed. A
  30                     ///< diagnostic has been emitted.
  31 };
  32
  33 enum CastType {
  34   CT_Const,       ///< const_cast
  35   CT_Static,      ///< static_cast
  36   CT_Reinterpret, ///< reinterpret_cast
  37   CT_Dynamic,     ///< dynamic_cast
  38   CT_CStyle,      ///< (Type)expr
  39   CT_Functional   ///< Type(expr)
  40 };
  41
  42
  43
  44
  45 static void CheckConstCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
  46                            ExprValueKind &VK,
  47                            const SourceRange &OpRange,
  48                            const SourceRange &DestRange);
  49 static void CheckReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
  50                                  ExprValueKind &VK,
  51                                  const SourceRange &OpRange,
  52                                  const SourceRange &DestRange,
  53                                  CastKind &Kind);
  54 static void CheckStaticCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
  55                             ExprValueKind &VK,
  56                             const SourceRange &OpRange,
  57                             CastKind &Kind,
  58                             CXXCastPath &BasePath);
  59 static void CheckDynamicCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
  60                              ExprValueKind &VK,
  61                              const SourceRange &OpRange,
  62                              const SourceRange &DestRange,
  63                              CastKind &Kind,
  64                              CXXCastPath &BasePath);
  65
  66 static bool CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType,
  67                                bool CheckCVR, bool CheckObjCLifetime);
  68
  69 // The Try functions attempt a specific way of casting. If they succeed, they
  70 // return TC_Success. If their way of casting is not appropriate for the given
  71 // arguments, they return TC_NotApplicable and *may* set diag to a diagnostic
  72 // to emit if no other way succeeds. If their way of casting is appropriate but
  73 // fails, they return TC_Failed and *must* set diag; they can set it to 0 if
  74 // they emit a specialized diagnostic.
  75 // All diagnostics returned by these functions must expect the same three
  76 // arguments:
  77 // %0: Cast Type (a value from the CastType enumeration)
  78 // %1: Source Type
  79 // %2: Destination Type
  80 static TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr,
  81                                            QualType DestType, bool CStyle,
  82                                            CastKind &Kind,
  83                                            CXXCastPath &BasePath,
  84                                            unsigned &msg);
  85 static TryCastResult TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr,
  86                                                QualType DestType, bool CStyle,
  87                                                const SourceRange &OpRange,
  88                                                unsigned &msg,
  89                                                CastKind &Kind,
  90                                                CXXCastPath &BasePath);
  91 static TryCastResult TryStaticPointerDowncast(Sema &Self, QualType SrcType,
  92                                               QualType DestType, bool CStyle,
  93                                               const SourceRange &OpRange,
  94                                               unsigned &msg,
  95                                               CastKind &Kind,
  96                                               CXXCastPath &BasePath);
  97 static TryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType,
  98                                        CanQualType DestType, bool CStyle,
  99                                        const SourceRange &OpRange,
 100                                        QualType OrigSrcType,
 101                                        QualType OrigDestType, unsigned &msg,
 102                                        CastKind &Kind,
 103                                        CXXCastPath &BasePath);
 104 static TryCastResult TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr,
 105                                                QualType SrcType,
 106                                                QualType DestType,bool CStyle,
 107                                                const SourceRange &OpRange,
 108                                                unsigned &msg,
 109                                                CastKind &Kind,
 110                                                CXXCastPath &BasePath);
 111
 112 static TryCastResult TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr,
 113                                            QualType DestType,
 114                                            Sema::CheckedConversionKind CCK,
 115                                            const SourceRange &OpRange,
 116                                            unsigned &msg,
 117                                            CastKind &Kind);
 118 static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr,
 119                                    QualType DestType,
 120                                    Sema::CheckedConversionKind CCK,
 121                                    const SourceRange &OpRange,
 122                                    unsigned &msg,
 123                                    CastKind &Kind,
 124                                    CXXCastPath &BasePath);
 125 static TryCastResult TryConstCast(Sema &Self, Expr *SrcExpr, QualType DestType,
 126                                   bool CStyle, unsigned &msg);
 127 static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
 128                                         QualType DestType, bool CStyle,
 129                                         const SourceRange &OpRange,
 130                                         unsigned &msg,
 131                                         CastKind &Kind);
 132
 133
 134 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
 135 ExprResult
 136 Sema::ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind,
 137                         SourceLocation LAngleBracketLoc, Declarator &D,
 138                         SourceLocation RAngleBracketLoc,
 139                         SourceLocation LParenLoc, Expr *E,
 140                         SourceLocation RParenLoc) {
 141
 142   assert(!D.isInvalidType());
 143
 144   TypeSourceInfo *TInfo = GetTypeForDeclaratorCast(D, E->getType());
 145   if (D.isInvalidType())
 146     return ExprError();
 147
 148   if (getLangOptions().CPlusPlus) {
 149     // Check that there are no default arguments (C++ only).
 150     CheckExtraCXXDefaultArguments(D);
 151   }
 152
 153   return BuildCXXNamedCast(OpLoc, Kind, TInfo, move(E),
 154                            SourceRange(LAngleBracketLoc, RAngleBracketLoc),
 155                            SourceRange(LParenLoc, RParenLoc));
 156 }
 157
 158 ExprResult
 159 Sema::BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind,
 160                         TypeSourceInfo *DestTInfo, Expr *E,
 161                         SourceRange AngleBrackets, SourceRange Parens) {
 162   ExprResult Ex = Owned(E);
 163   QualType DestType = DestTInfo->getType();
 164
 165   SourceRange OpRange(OpLoc, Parens.getEnd());
 166   SourceRange DestRange = AngleBrackets;
 167
 168   // If the type is dependent, we won't do the semantic analysis now.
 169   // FIXME: should we check this in a more fine-grained manner?
 170   bool TypeDependent = DestType->isDependentType() || Ex.get()->isTypeDependent();
 171
 172   ExprValueKind VK = VK_RValue;
 173   if (TypeDependent)
 174     VK = Expr::getValueKindForType(DestType);
 175
 176   switch (Kind) {
 177   default: llvm_unreachable("Unknown C++ cast!");
 178
 179   case tok::kw_const_cast:
 180     if (!TypeDependent) {
 181       CheckConstCast(*this, Ex, DestType, VK, OpRange, DestRange);
 182       if (Ex.isInvalid())
 183         return ExprError();
 184     }
 185     return Owned(CXXConstCastExpr::Create(Context,
 186                                         DestType.getNonLValueExprType(Context),
 187                                           VK, Ex.take(), DestTInfo, OpLoc,
 188                                           Parens.getEnd()));
 189
 190   case tok::kw_dynamic_cast: {
 191     CastKind Kind = CK_Dependent;
 192     CXXCastPath BasePath;
 193     if (!TypeDependent) {
 194       CheckDynamicCast(*this, Ex, DestType, VK, OpRange, DestRange,
 195                        Kind, BasePath);
 196       if (Ex.isInvalid())
 197         return ExprError();
 198     }
 199     return Owned(CXXDynamicCastExpr::Create(Context,
 200                                           DestType.getNonLValueExprType(Context),
 201                                             VK, Kind, Ex.take(), &BasePath, DestTInfo,
 202                                             OpLoc, Parens.getEnd()));
 203   }
 204   case tok::kw_reinterpret_cast: {
 205     CastKind Kind = CK_Dependent;
 206     if (!TypeDependent) {
 207       CheckReinterpretCast(*this, Ex, DestType, VK, OpRange, DestRange, Kind);
 208       if (Ex.isInvalid())
 209         return ExprError();
 210     }
 211     return Owned(CXXReinterpretCastExpr::Create(Context,
 212                                   DestType.getNonLValueExprType(Context),
 213                                   VK, Kind, Ex.take(), 0,
 214                                   DestTInfo, OpLoc, Parens.getEnd()));
 215   }
 216   case tok::kw_static_cast: {
 217     CastKind Kind = CK_Dependent;
 218     CXXCastPath BasePath;
 219     if (!TypeDependent) {
 220       CheckStaticCast(*this, Ex, DestType, VK, OpRange, Kind, BasePath);
 221       if (Ex.isInvalid())
 222         return ExprError();
 223     }
 224
 225     return Owned(CXXStaticCastExpr::Create(Context,
 226                                          DestType.getNonLValueExprType(Context),
 227                                            VK, Kind, Ex.take(), &BasePath,
 228                                            DestTInfo, OpLoc, Parens.getEnd()));
 229   }
 230   }
 231
 232   return ExprError();
 233 }
 234
 235 /// Try to diagnose a failed overloaded cast.  Returns true if
 236 /// diagnostics were emitted.
 237 static bool tryDiagnoseOverloadedCast(Sema &S, CastType CT,
 238                                       SourceRange range, Expr *src,
 239                                       QualType destType) {
 240   switch (CT) {
 241   // These cast kinds don't consider user-defined conversions.
 242   case CT_Const:
 243   case CT_Reinterpret:
 244   case CT_Dynamic:
 245     return false;
 246
 247   // These do.
 248   case CT_Static:
 249   case CT_CStyle:
 250   case CT_Functional:
 251     break;
 252   }
 253
 254   QualType srcType = src->getType();
 255   if (!destType->isRecordType() && !srcType->isRecordType())
 256     return false;
 257
 258   InitializedEntity entity = InitializedEntity::InitializeTemporary(destType);
 259   InitializationKind initKind
 260     = (CT == CT_CStyle)? InitializationKind::CreateCStyleCast(range.getBegin(),
 261                                                               range)
 262     : (CT == CT_Functional)? InitializationKind::CreateFunctionalCast(range)
 263     : InitializationKind::CreateCast(/*type range?*/ range);
 264   InitializationSequence sequence(S, entity, initKind, &src, 1);
 265
 266   assert(sequence.Failed() && "initialization succeeded on second try?");
 267   switch (sequence.getFailureKind()) {
 268   default: return false;
 269
 270   case InitializationSequence::FK_ConstructorOverloadFailed:
 271   case InitializationSequence::FK_UserConversionOverloadFailed:
 272     break;
 273   }
 274
 275   OverloadCandidateSet &candidates = sequence.getFailedCandidateSet();
 276
 277   unsigned msg = 0;
 278   OverloadCandidateDisplayKind howManyCandidates = OCD_AllCandidates;
 279
 280   switch (sequence.getFailedOverloadResult()) {
 281   case OR_Success: llvm_unreachable("successful failed overload");
 282     return false;
 283   case OR_No_Viable_Function:
 284     if (candidates.empty())
 285       msg = diag::err_ovl_no_conversion_in_cast;
 286     else
 287       msg = diag::err_ovl_no_viable_conversion_in_cast;
 288     howManyCandidates = OCD_AllCandidates;
 289     break;
 290
 291   case OR_Ambiguous:
 292     msg = diag::err_ovl_ambiguous_conversion_in_cast;
 293     howManyCandidates = OCD_ViableCandidates;
 294     break;
 295
 296   case OR_Deleted:
 297     msg = diag::err_ovl_deleted_conversion_in_cast;
 298     howManyCandidates = OCD_ViableCandidates;
 299     break;
 300   }
 301
 302   S.Diag(range.getBegin(), msg)
 303     << CT << srcType << destType
 304     << range << src->getSourceRange();
 305
 306   candidates.NoteCandidates(S, howManyCandidates, &src, 1);
 307
 308   return true;
 309 }
 310
 311 /// Diagnose a failed cast.
 312 static void diagnoseBadCast(Sema &S, unsigned msg, CastType castType,
 313                             SourceRange opRange, Expr *src, QualType destType) {
 314   if (src->getType() == S.Context.BoundMemberTy) {
 315     (void) S.CheckPlaceholderExpr(src); // will always fail
 316     return;
 317   }
 318
 319   if (msg == diag::err_bad_cxx_cast_generic &&
 320       tryDiagnoseOverloadedCast(S, castType, opRange, src, destType))
 321     return;
 322
 323   S.Diag(opRange.getBegin(), msg) << castType
 324     << src->getType() << destType << opRange << src->getSourceRange();
 325 }
 326
 327 /// UnwrapDissimilarPointerTypes - Like Sema::UnwrapSimilarPointerTypes,
 328 /// this removes one level of indirection from both types, provided that they're
 329 /// the same kind of pointer (plain or to-member). Unlike the Sema function,
 330 /// this one doesn't care if the two pointers-to-member don't point into the
 331 /// same class. This is because CastsAwayConstness doesn't care.
 332 static bool UnwrapDissimilarPointerTypes(QualType& T1, QualType& T2) {
 333   const PointerType *T1PtrType = T1->getAs<PointerType>(),
 334                     *T2PtrType = T2->getAs<PointerType>();
 335   if (T1PtrType && T2PtrType) {
 336     T1 = T1PtrType->getPointeeType();
 337     T2 = T2PtrType->getPointeeType();
 338     return true;
 339   }
 340   const ObjCObjectPointerType *T1ObjCPtrType =
 341                                             T1->getAs<ObjCObjectPointerType>(),
 342                               *T2ObjCPtrType =
 343                                             T2->getAs<ObjCObjectPointerType>();
 344   if (T1ObjCPtrType) {
 345     if (T2ObjCPtrType) {
 346       T1 = T1ObjCPtrType->getPointeeType();
 347       T2 = T2ObjCPtrType->getPointeeType();
 348       return true;
 349     }
 350     else if (T2PtrType) {
 351       T1 = T1ObjCPtrType->getPointeeType();
 352       T2 = T2PtrType->getPointeeType();
 353       return true;
 354     }
 355   }
 356   else if (T2ObjCPtrType) {
 357     if (T1PtrType) {
 358       T2 = T2ObjCPtrType->getPointeeType();
 359       T1 = T1PtrType->getPointeeType();
 360       return true;
 361     }
 362   }
 363
 364   const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(),
 365                           *T2MPType = T2->getAs<MemberPointerType>();
 366   if (T1MPType && T2MPType) {
 367     T1 = T1MPType->getPointeeType();
 368     T2 = T2MPType->getPointeeType();
 369     return true;
 370   }
 371
 372   const BlockPointerType *T1BPType = T1->getAs<BlockPointerType>(),
 373                          *T2BPType = T2->getAs<BlockPointerType>();
 374   if (T1BPType && T2BPType) {
 375     T1 = T1BPType->getPointeeType();
 376     T2 = T2BPType->getPointeeType();
 377     return true;
 378   }
 379
 380   return false;
 381 }
 382
 383 /// CastsAwayConstness - Check if the pointer conversion from SrcType to
 384 /// DestType casts away constness as defined in C++ 5.2.11p8ff. This is used by
 385 /// the cast checkers.  Both arguments must denote pointer (possibly to member)
 386 /// types.
 387 ///
 388 /// \param CheckCVR Whether to check for const/volatile/restrict qualifiers.
 389 ///
 390 /// \param CheckObjCLifetime Whether to check Objective-C lifetime qualifiers.
 391 static bool
 392 CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType,
 393                    bool CheckCVR, bool CheckObjCLifetime) {
 394   // If the only checking we care about is for Objective-C lifetime qualifiers,
 395   // and we're not in ARC mode, there's nothing to check.
 396   if (!CheckCVR && CheckObjCLifetime &&
 397       !Self.Context.getLangOptions().ObjCAutoRefCount)
 398     return false;
 399
 400   // Casting away constness is defined in C++ 5.2.11p8 with reference to
 401   // C++ 4.4. We piggyback on Sema::IsQualificationConversion for this, since
 402   // the rules are non-trivial. So first we construct Tcv *...cv* as described
 403   // in C++ 5.2.11p8.
 404   assert((SrcType->isAnyPointerType() || SrcType->isMemberPointerType() ||
 405           SrcType->isBlockPointerType()) &&
 406          "Source type is not pointer or pointer to member.");
 407   assert((DestType->isAnyPointerType() || DestType->isMemberPointerType() ||
 408           DestType->isBlockPointerType()) &&
 409          "Destination type is not pointer or pointer to member.");
 410
 411   QualType UnwrappedSrcType = Self.Context.getCanonicalType(SrcType),
 412            UnwrappedDestType = Self.Context.getCanonicalType(DestType);
 413   llvm::SmallVector<Qualifiers, 8> cv1, cv2;
 414
 415   // Find the qualifiers. We only care about cvr-qualifiers for the
 416   // purpose of this check, because other qualifiers (address spaces,
 417   // Objective-C GC, etc.) are part of the type's identity.
 418   while (UnwrapDissimilarPointerTypes(UnwrappedSrcType, UnwrappedDestType)) {
 419     // Determine the relevant qualifiers at this level.
 420     Qualifiers SrcQuals, DestQuals;
 421     Self.Context.getUnqualifiedArrayType(UnwrappedSrcType, SrcQuals);
 422     Self.Context.getUnqualifiedArrayType(UnwrappedDestType, DestQuals);
 423
 424     Qualifiers RetainedSrcQuals, RetainedDestQuals;
 425     if (CheckCVR) {
 426       RetainedSrcQuals.setCVRQualifiers(SrcQuals.getCVRQualifiers());
 427       RetainedDestQuals.setCVRQualifiers(DestQuals.getCVRQualifiers());
 428     }
 429
 430     if (CheckObjCLifetime &&
 431         !DestQuals.compatiblyIncludesObjCLifetime(SrcQuals))
 432       return true;
 433
 434     cv1.push_back(RetainedSrcQuals);
 435     cv2.push_back(RetainedDestQuals);
 436   }
 437   if (cv1.empty())
 438     return false;
 439
 440   // Construct void pointers with those qualifiers (in reverse order of
 441   // unwrapping, of course).
 442   QualType SrcConstruct = Self.Context.VoidTy;
 443   QualType DestConstruct = Self.Context.VoidTy;
 444   ASTContext &Context = Self.Context;
 445   for (llvm::SmallVector<Qualifiers, 8>::reverse_iterator i1 = cv1.rbegin(),
 446                                                           i2 = cv2.rbegin();
 447        i1 != cv1.rend(); ++i1, ++i2) {
 448     SrcConstruct
 449       = Context.getPointerType(Context.getQualifiedType(SrcConstruct, *i1));
 450     DestConstruct
 451       = Context.getPointerType(Context.getQualifiedType(DestConstruct, *i2));
 452   }
 453
 454   // Test if they're compatible.
 455   bool ObjCLifetimeConversion;
 456   return SrcConstruct != DestConstruct &&
 457     !Self.IsQualificationConversion(SrcConstruct, DestConstruct, false,
 458                                     ObjCLifetimeConversion);
 459 }
 460
 461 /// CheckDynamicCast - Check that a dynamic_cast\<DestType\>(SrcExpr) is valid.
 462 /// Refer to C++ 5.2.7 for details. Dynamic casts are used mostly for runtime-
 463 /// checked downcasts in class hierarchies.
 464 static void
 465 CheckDynamicCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
 466                  ExprValueKind &VK, const SourceRange &OpRange,
 467                  const SourceRange &DestRange, CastKind &Kind,
 468                  CXXCastPath &BasePath) {
 469   QualType OrigDestType = DestType, OrigSrcType = SrcExpr.get()->getType();
 470   DestType = Self.Context.getCanonicalType(DestType);
 471
 472   // C++ 5.2.7p1: T shall be a pointer or reference to a complete class type,
 473   //   or "pointer to cv void".
 474
 475   QualType DestPointee;
 476   const PointerType *DestPointer = DestType->getAs<PointerType>();
 477   const ReferenceType *DestReference = 0;
 478   if (DestPointer) {
 479     DestPointee = DestPointer->getPointeeType();
 480   } else if ((DestReference = DestType->getAs<ReferenceType>())) {
 481     DestPointee = DestReference->getPointeeType();
 482     VK = isa<LValueReferenceType>(DestReference) ? VK_LValue
 483        : isa<RValueReferenceType>(DestReference) ? VK_XValue
 484        : VK_RValue;
 485   } else {
 486     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ref_or_ptr)
 487       << OrigDestType << DestRange;
 488     return;
 489   }
 490
 491   const RecordType *DestRecord = DestPointee->getAs<RecordType>();
 492   if (DestPointee->isVoidType()) {
 493     assert(DestPointer && "Reference to void is not possible");
 494   } else if (DestRecord) {
 495     if (Self.RequireCompleteType(OpRange.getBegin(), DestPointee,
 496                                Self.PDiag(diag::err_bad_dynamic_cast_incomplete)
 497                                    << DestRange))
 498       return;
 499   } else {
 500     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)
 501       << DestPointee.getUnqualifiedType() << DestRange;
 502     return;
 503   }
 504
 505   // C++0x 5.2.7p2: If T is a pointer type, v shall be an rvalue of a pointer to
 506   //   complete class type, [...]. If T is an lvalue reference type, v shall be
 507   //   an lvalue of a complete class type, [...]. If T is an rvalue reference
 508   //   type, v shall be an expression having a complete class type, [...]
 509   QualType SrcType = Self.Context.getCanonicalType(OrigSrcType);
 510   QualType SrcPointee;
 511   if (DestPointer) {
 512     if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) {
 513       SrcPointee = SrcPointer->getPointeeType();
 514     } else {
 515       Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ptr)
 516         << OrigSrcType << SrcExpr.get()->getSourceRange();
 517       return;
 518     }
 519   } else if (DestReference->isLValueReferenceType()) {
 520     if (!SrcExpr.get()->isLValue()) {
 521       Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_rvalue)
 522         << CT_Dynamic << OrigSrcType << OrigDestType << OpRange;
 523     }
 524     SrcPointee = SrcType;
 525   } else {
 526     SrcPointee = SrcType;
 527   }
 528
 529   const RecordType *SrcRecord = SrcPointee->getAs<RecordType>();
 530   if (SrcRecord) {
 531     if (Self.RequireCompleteType(OpRange.getBegin(), SrcPointee,
 532                              Self.PDiag(diag::err_bad_dynamic_cast_incomplete)
 533                                    << SrcExpr.get()->getSourceRange()))
 534       return;
 535   } else {
 536     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)
 537       << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange();
 538     return;
 539   }
 540
 541   assert((DestPointer || DestReference) &&
 542     "Bad destination non-ptr/ref slipped through.");
 543   assert((DestRecord || DestPointee->isVoidType()) &&
 544     "Bad destination pointee slipped through.");
 545   assert(SrcRecord && "Bad source pointee slipped through.");
 546
 547   // C++ 5.2.7p1: The dynamic_cast operator shall not cast away constness.
 548   if (!DestPointee.isAtLeastAsQualifiedAs(SrcPointee)) {
 549     Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_qualifiers_away)
 550       << CT_Dynamic << OrigSrcType << OrigDestType << OpRange;
 551     return;
 552   }
 553
 554   // C++ 5.2.7p3: If the type of v is the same as the required result type,
 555   //   [except for cv].
 556   if (DestRecord == SrcRecord) {
 557     Kind = CK_NoOp;
 558     return;
 559   }
 560
 561   // C++ 5.2.7p5
 562   // Upcasts are resolved statically.
 563   if (DestRecord && Self.IsDerivedFrom(SrcPointee, DestPointee)) {
 564     if (Self.CheckDerivedToBaseConversion(SrcPointee, DestPointee,
 565                                            OpRange.getBegin(), OpRange,
 566                                            &BasePath))
 567         return;
 568
 569     Kind = CK_DerivedToBase;
 570
 571     // If we are casting to or through a virtual base class, we need a
 572     // vtable.
 573     if (Self.BasePathInvolvesVirtualBase(BasePath))
 574       Self.MarkVTableUsed(OpRange.getBegin(),
 575                           cast<CXXRecordDecl>(SrcRecord->getDecl()));
 576     return;
 577   }
 578
 579   // C++ 5.2.7p6: Otherwise, v shall be [polymorphic].
 580   const RecordDecl *SrcDecl = SrcRecord->getDecl()->getDefinition();
 581   assert(SrcDecl && "Definition missing");
 582   if (!cast<CXXRecordDecl>(SrcDecl)->isPolymorphic()) {
 583     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_polymorphic)
 584       << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange();
 585   }
 586   Self.MarkVTableUsed(OpRange.getBegin(),
 587                       cast<CXXRecordDecl>(SrcRecord->getDecl()));
 588
 589   // Done. Everything else is run-time checks.
 590   Kind = CK_Dynamic;
 591 }
 592
 593 /// CheckConstCast - Check that a const_cast\<DestType\>(SrcExpr) is valid.
 594 /// Refer to C++ 5.2.11 for details. const_cast is typically used in code
 595 /// like this:
 596 /// const char *str = "literal";
 597 /// legacy_function(const_cast\<char*\>(str));
 598 void
 599 CheckConstCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, ExprValueKind &VK,
 600                const SourceRange &OpRange, const SourceRange &DestRange) {
 601   VK = Expr::getValueKindForType(DestType);
 602   if (VK == VK_RValue) {
 603     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take());
 604     if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 605       return;
 606   }
 607
 608   unsigned msg = diag::err_bad_cxx_cast_generic;
 609   if (TryConstCast(Self, SrcExpr.get(), DestType, /*CStyle*/false, msg) != TC_Success
 610       && msg != 0)
 611     Self.Diag(OpRange.getBegin(), msg) << CT_Const
 612       << SrcExpr.get()->getType() << DestType << OpRange;
 613 }
 614
 615 /// CheckReinterpretCast - Check that a reinterpret_cast\<DestType\>(SrcExpr) is
 616 /// valid.
 617 /// Refer to C++ 5.2.10 for details. reinterpret_cast is typically used in code
 618 /// like this:
 619 /// char *bytes = reinterpret_cast\<char*\>(int_ptr);
 620 void
 621 CheckReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
 622                      ExprValueKind &VK, const SourceRange &OpRange,
 623                      const SourceRange &DestRange, CastKind &Kind) {
 624   VK = Expr::getValueKindForType(DestType);
 625   if (VK == VK_RValue) {
 626     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take());
 627     if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 628       return;
 629   }
 630
 631   unsigned msg = diag::err_bad_cxx_cast_generic;
 632   TryCastResult tcr =
 633     TryReinterpretCast(Self, SrcExpr, DestType,
 634                        /*CStyle*/false, OpRange, msg, Kind);
 635   if (tcr != TC_Success && msg != 0)
 636   {
 637     if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 638       return;
 639     if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
 640       //FIXME: &f<int>; is overloaded and resolvable
 641       Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_overload)
 642         << OverloadExpr::find(SrcExpr.get()).Expression->getName()
 643         << DestType << OpRange;
 644       Self.NoteAllOverloadCandidates(SrcExpr.get());
 645
 646     } else {
 647       diagnoseBadCast(Self, msg, CT_Reinterpret, OpRange, SrcExpr.get(), DestType);
 648     }
 649   } else if (tcr == TC_Success && Self.getLangOptions().ObjCAutoRefCount) {
 650     Expr *Exp = SrcExpr.get();
 651     // Note that Exp does not change with CCK_OtherCast cast type
 652     Self.CheckObjCARCConversion(OpRange, DestType,
 653                                 Exp, Sema::CCK_OtherCast);
 654   }
 655 }
 656
 657
 658 /// CheckStaticCast - Check that a static_cast\<DestType\>(SrcExpr) is valid.
 659 /// Refer to C++ 5.2.9 for details. Static casts are mostly used for making
 660 /// implicit conversions explicit and getting rid of data loss warnings.
 661 void
 662 CheckStaticCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
 663                 ExprValueKind &VK, const SourceRange &OpRange,
 664                 CastKind &Kind, CXXCastPath &BasePath) {
 665   // This test is outside everything else because it's the only case where
 666   // a non-lvalue-reference target type does not lead to decay.
 667   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
 668   if (DestType->isVoidType()) {
 669     SrcExpr = Self.IgnoredValueConversions(SrcExpr.take());
 670     if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 671       return;
 672     if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
 673       ExprResult SingleFunctionExpression =
 674          Self.ResolveAndFixSingleFunctionTemplateSpecialization(SrcExpr.get(),
 675                 false, // Decay Function to ptr
 676                 true, // Complain
 677                 OpRange, DestType, diag::err_bad_static_cast_overload);
 678         if (SingleFunctionExpression.isUsable())
 679         {
 680           SrcExpr = SingleFunctionExpression;
 681           Kind = CK_ToVoid;
 682         }
 683     }
 684     else
 685       Kind = CK_ToVoid;
 686     return;
 687   }
 688
 689   VK = Expr::getValueKindForType(DestType);
 690   if (VK == VK_RValue && !DestType->isRecordType()) {
 691     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take());
 692     if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
 693       return;
 694   }
 695
 696   unsigned msg = diag::err_bad_cxx_cast_generic;
 697   TryCastResult tcr
 698     = TryStaticCast(Self, SrcExpr, DestType, Sema::CCK_OtherCast, OpRange, msg,
 699                     Kind, BasePath);
 700   if (tcr != TC_Success && msg != 0) {
 701     if (SrcExpr.isInvalid())
 702       return;
 703     if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
 704       OverloadExpr* oe = OverloadExpr::find(SrcExpr.get()).Expression;
 705       Self.Diag(OpRange.getBegin(), diag::err_bad_static_cast_overload)
 706         << oe->getName() << DestType << OpRange
 707         << oe->getQualifierLoc().getSourceRange();
 708       Self.NoteAllOverloadCandidates(SrcExpr.get());
 709     } else {
 710       diagnoseBadCast(Self, msg, CT_Static, OpRange, SrcExpr.get(), DestType);
 711     }
 712   } else if (tcr == TC_Success) {
 713     if (Kind == CK_BitCast)
 714       Self.CheckCastAlign(SrcExpr.get(), DestType, OpRange);
 715     if (Self.getLangOptions().ObjCAutoRefCount) {
 716       Expr *Exp = SrcExpr.get();
 717       // Note that Exp does not change with CCK_OtherCast cast type
 718       Self.CheckObjCARCConversion(OpRange, DestType,
 719                                   Exp, Sema::CCK_OtherCast);
 720     }
 721   }
 722   else if (Kind == CK_BitCast)
 723     Self.CheckCastAlign(SrcExpr.get(), DestType, OpRange);
 724 }
 725
 726 /// TryStaticCast - Check if a static cast can be performed, and do so if
 727 /// possible. If @p CStyle, ignore access restrictions on hierarchy casting
 728 /// and casting away constness.
 729 static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr,
 730                                    QualType DestType,
 731                                    Sema::CheckedConversionKind CCK,
 732                                    const SourceRange &OpRange, unsigned &msg,
 733                                    CastKind &Kind,
 734                                    CXXCastPath &BasePath) {
 735   // Determine whether we have the semantics of a C-style cast.
 736   bool CStyle
 737     = (CCK == Sema::CCK_CStyleCast || CCK == Sema::CCK_FunctionalCast);
 738
 739   // The order the tests is not entirely arbitrary. There is one conversion
 740   // that can be handled in two different ways. Given:
 741   // struct A {};
 742   // struct B : public A {
 743   //   B(); B(const A&);
 744   // };
 745   // const A &a = B();
 746   // the cast static_cast<const B&>(a) could be seen as either a static
 747   // reference downcast, or an explicit invocation of the user-defined
 748   // conversion using B's conversion constructor.
 749   // DR 427 specifies that the downcast is to be applied here.
 750
 751   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
 752   // Done outside this function.
 753
 754   TryCastResult tcr;
 755
 756   // C++ 5.2.9p5, reference downcast.
 757   // See the function for details.
 758   // DR 427 specifies that this is to be applied before paragraph 2.
 759   tcr = TryStaticReferenceDowncast(Self, SrcExpr.get(), DestType, CStyle, OpRange,
 760                                    msg, Kind, BasePath);
 761   if (tcr != TC_NotApplicable)
 762     return tcr;
 763
 764   // C++0x [expr.static.cast]p3:
 765   //   A glvalue of type "cv1 T1" can be cast to type "rvalue reference to cv2
 766   //   T2" if "cv2 T2" is reference-compatible with "cv1 T1".
 767   tcr = TryLValueToRValueCast(Self, SrcExpr.get(), DestType, CStyle, Kind, BasePath,
 768                               msg);
 769   if (tcr != TC_NotApplicable)
 770     return tcr;
 771
 772   // C++ 5.2.9p2: An expression e can be explicitly converted to a type T
 773   //   [...] if the declaration "T t(e);" is well-formed, [...].
 774   tcr = TryStaticImplicitCast(Self, SrcExpr, DestType, CCK, OpRange, msg,
 775                               Kind);
 776   if (SrcExpr.isInvalid())
 777     return TC_Failed;
 778   if (tcr != TC_NotApplicable)
 779     return tcr;
 780
 781   // C++ 5.2.9p6: May apply the reverse of any standard conversion, except
 782   // lvalue-to-rvalue, array-to-pointer, function-to-pointer, and boolean
 783   // conversions, subject to further restrictions.
 784   // Also, C++ 5.2.9p1 forbids casting away constness, which makes reversal
 785   // of qualification conversions impossible.
 786   // In the CStyle case, the earlier attempt to const_cast should have taken
 787   // care of reverse qualification conversions.
 788
 789   QualType SrcType = Self.Context.getCanonicalType(SrcExpr.get()->getType());
 790
 791   // C++0x 5.2.9p9: A value of a scoped enumeration type can be explicitly
 792   // converted to an integral type. [...] A value of a scoped enumeration type
 793   // can also be explicitly converted to a floating-point type [...].
 794   if (const EnumType *Enum = SrcType->getAs<EnumType>()) {
 795     if (Enum->getDecl()->isScoped()) {
 796       if (DestType->isBooleanType()) {
 797         Kind = CK_IntegralToBoolean;
 798         return TC_Success;
 799       } else if (DestType->isIntegralType(Self.Context)) {
 800         Kind = CK_IntegralCast;
 801         return TC_Success;
 802       } else if (DestType->isRealFloatingType()) {
 803         Kind = CK_IntegralToFloating;
 804         return TC_Success;
 805       }
 806     }
 807   }
 808
 809   // Reverse integral promotion/conversion. All such conversions are themselves
 810   // again integral promotions or conversions and are thus already handled by
 811   // p2 (TryDirectInitialization above).
 812   // (Note: any data loss warnings should be suppressed.)
 813   // The exception is the reverse of enum->integer, i.e. integer->enum (and
 814   // enum->enum). See also C++ 5.2.9p7.
 815   // The same goes for reverse floating point promotion/conversion and
 816   // floating-integral conversions. Again, only floating->enum is relevant.
 817   if (DestType->isEnumeralType()) {
 818     if (SrcType->isComplexType() || SrcType->isVectorType()) {
 819       // Fall through - these cannot be converted.
 820     } else if (SrcType->isArithmeticType() || SrcType->isEnumeralType()) {
 821       Kind = CK_IntegralCast;
 822       return TC_Success;
 823     }
 824   }
 825
 826   // Reverse pointer upcast. C++ 4.10p3 specifies pointer upcast.
 827   // C++ 5.2.9p8 additionally disallows a cast path through virtual inheritance.
 828   tcr = TryStaticPointerDowncast(Self, SrcType, DestType, CStyle, OpRange, msg,
 829                                  Kind, BasePath);
 830   if (tcr != TC_NotApplicable)
 831     return tcr;
 832
 833   // Reverse member pointer conversion. C++ 4.11 specifies member pointer
 834   // conversion. C++ 5.2.9p9 has additional information.
 835   // DR54's access restrictions apply here also.
 836   tcr = TryStaticMemberPointerUpcast(Self, SrcExpr, SrcType, DestType, CStyle,
 837                                      OpRange, msg, Kind, BasePath);
 838   if (tcr != TC_NotApplicable)
 839     return tcr;
 840
 841   // Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to
 842   // void*. C++ 5.2.9p10 specifies additional restrictions, which really is
 843   // just the usual constness stuff.
 844   if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) {
 845     QualType SrcPointee = SrcPointer->getPointeeType();
 846     if (SrcPointee->isVoidType()) {
 847       if (const PointerType *DestPointer = DestType->getAs<PointerType>()) {
 848         QualType DestPointee = DestPointer->getPointeeType();
 849         if (DestPointee->isIncompleteOrObjectType()) {
 850           // This is definitely the intended conversion, but it might fail due
 851           // to a qualifier violation. Note that we permit Objective-C lifetime
 852           // and GC qualifier mismatches here.
 853           if (!CStyle) {
 854             Qualifiers DestPointeeQuals = DestPointee.getQualifiers();
 855             Qualifiers SrcPointeeQuals = SrcPointee.getQualifiers();
 856             DestPointeeQuals.removeObjCGCAttr();
 857             DestPointeeQuals.removeObjCLifetime();
 858             SrcPointeeQuals.removeObjCGCAttr();
 859             SrcPointeeQuals.removeObjCLifetime();
 860             if (DestPointeeQuals != SrcPointeeQuals &&
 861                 !DestPointeeQuals.compatiblyIncludes(SrcPointeeQuals)) {
 862               msg = diag::err_bad_cxx_cast_qualifiers_away;
 863               return TC_Failed;
 864             }
 865           }
 866           Kind = CK_BitCast;
 867           return TC_Success;
 868         }
 869       }
 870       else if (DestType->isObjCObjectPointerType()) {
 871         // allow both c-style cast and static_cast of objective-c pointers as
 872         // they are pervasive.
 873         Kind = CK_AnyPointerToObjCPointerCast;
 874         return TC_Success;
 875       }
 876       else if (CStyle && DestType->isBlockPointerType()) {
 877         // allow c-style cast of void * to block pointers.
 878         Kind = CK_AnyPointerToBlockPointerCast;
 879         return TC_Success;
 880       }
 881     }
 882   }
 883   // Allow arbitray objective-c pointer conversion with static casts.
 884   if (SrcType->isObjCObjectPointerType() &&
 885       DestType->isObjCObjectPointerType()) {
 886     Kind = CK_BitCast;
 887     return TC_Success;
 888   }
 889
 890   // We tried everything. Everything! Nothing works! :-(
 891   return TC_NotApplicable;
 892 }
 893
 894 /// Tests whether a conversion according to N2844 is valid.
 895 TryCastResult
 896 TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, QualType DestType,
 897                       bool CStyle, CastKind &Kind, CXXCastPath &BasePath,
 898                       unsigned &msg) {
 899   // C++0x [expr.static.cast]p3:
 900   //   A glvalue of type "cv1 T1" can be cast to type "rvalue reference to
 901   //   cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1".
 902   const RValueReferenceType *R = DestType->getAs<RValueReferenceType>();
 903   if (!R)
 904     return TC_NotApplicable;
 905
 906   if (!SrcExpr->isGLValue())
 907     return TC_NotApplicable;
 908
 909   // Because we try the reference downcast before this function, from now on
 910   // this is the only cast possibility, so we issue an error if we fail now.
 911   // FIXME: Should allow casting away constness if CStyle.
 912   bool DerivedToBase;
 913   bool ObjCConversion;
 914   bool ObjCLifetimeConversion;
 915   QualType FromType = SrcExpr->getType();
 916   QualType ToType = R->getPointeeType();
 917   if (CStyle) {
 918     FromType = FromType.getUnqualifiedType();
 919     ToType = ToType.getUnqualifiedType();
 920   }
 921
 922   if (Self.CompareReferenceRelationship(SrcExpr->getLocStart(),
 923                                         ToType, FromType,
 924                                         DerivedToBase, ObjCConversion,
 925                                         ObjCLifetimeConversion)
 926         < Sema::Ref_Compatible_With_Added_Qualification) {
 927     msg = diag::err_bad_lvalue_to_rvalue_cast;
 928     return TC_Failed;
 929   }
 930
 931   if (DerivedToBase) {
 932     Kind = CK_DerivedToBase;
 933     CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
 934                        /*DetectVirtual=*/true);
 935     if (!Self.IsDerivedFrom(SrcExpr->getType(), R->getPointeeType(), Paths))
 936       return TC_NotApplicable;
 937
 938     Self.BuildBasePathArray(Paths, BasePath);
 939   } else
 940     Kind = CK_NoOp;
 941
 942   return TC_Success;
 943 }
 944
 945 /// Tests whether a conversion according to C++ 5.2.9p5 is valid.
 946 TryCastResult
 947 TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType,
 948                            bool CStyle, const SourceRange &OpRange,
 949                            unsigned &msg, CastKind &Kind,
 950                            CXXCastPath &BasePath) {
 951   // C++ 5.2.9p5: An lvalue of type "cv1 B", where B is a class type, can be
 952   //   cast to type "reference to cv2 D", where D is a class derived from B,
 953   //   if a valid standard conversion from "pointer to D" to "pointer to B"
 954   //   exists, cv2 >= cv1, and B is not a virtual base class of D.
 955   // In addition, DR54 clarifies that the base must be accessible in the
 956   // current context. Although the wording of DR54 only applies to the pointer
 957   // variant of this rule, the intent is clearly for it to apply to the this
 958   // conversion as well.
 959
 960   const ReferenceType *DestReference = DestType->getAs<ReferenceType>();
 961   if (!DestReference) {
 962     return TC_NotApplicable;
 963   }
 964   bool RValueRef = DestReference->isRValueReferenceType();
 965   if (!RValueRef && !SrcExpr->isLValue()) {
 966     // We know the left side is an lvalue reference, so we can suggest a reason.
 967     msg = diag::err_bad_cxx_cast_rvalue;
 968     return TC_NotApplicable;
 969   }
 970
 971   QualType DestPointee = DestReference->getPointeeType();
 972
 973   return TryStaticDowncast(Self,
 974                            Self.Context.getCanonicalType(SrcExpr->getType()),
 975                            Self.Context.getCanonicalType(DestPointee), CStyle,
 976                            OpRange, SrcExpr->getType(), DestType, msg, Kind,
 977                            BasePath);
 978 }
 979
 980 /// Tests whether a conversion according to C++ 5.2.9p8 is valid.
 981 TryCastResult
 982 TryStaticPointerDowncast(Sema &Self, QualType SrcType, QualType DestType,
 983                          bool CStyle, const SourceRange &OpRange,
 984                          unsigned &msg, CastKind &Kind,
 985                          CXXCastPath &BasePath) {
 986   // C++ 5.2.9p8: An rvalue of type "pointer to cv1 B", where B is a class
 987   //   type, can be converted to an rvalue of type "pointer to cv2 D", where D
 988   //   is a class derived from B, if a valid standard conversion from "pointer
 989   //   to D" to "pointer to B" exists, cv2 >= cv1, and B is not a virtual base
 990   //   class of D.
 991   // In addition, DR54 clarifies that the base must be accessible in the
 992   // current context.
 993
 994   const PointerType *DestPointer = DestType->getAs<PointerType>();
 995   if (!DestPointer) {
 996     return TC_NotApplicable;
 997   }
 998
 999   const PointerType *SrcPointer = SrcType->getAs<PointerType>();
1000   if (!SrcPointer) {
1001     msg = diag::err_bad_static_cast_pointer_nonpointer;
1002     return TC_NotApplicable;
1003   }
1004
1005   return TryStaticDowncast(Self,
1006                    Self.Context.getCanonicalType(SrcPointer->getPointeeType()),
1007                   Self.Context.getCanonicalType(DestPointer->getPointeeType()),
1008                            CStyle, OpRange, SrcType, DestType, msg, Kind,
1009                            BasePath);
1010 }
1011
1012 /// TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and
1013 /// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to
1014 /// DestType is possible and allowed.
1015 TryCastResult
1016 TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType,
1017                   bool CStyle, const SourceRange &OpRange, QualType OrigSrcType,
1018                   QualType OrigDestType, unsigned &msg,
1019                   CastKind &Kind, CXXCastPath &BasePath) {
1020   // We can only work with complete types. But don't complain if it doesn't work
1021   if (Self.RequireCompleteType(OpRange.getBegin(), SrcType, Self.PDiag(0)) ||
1022       Self.RequireCompleteType(OpRange.getBegin(), DestType, Self.PDiag(0)))
1023     return TC_NotApplicable;
1024
1025   // Downcast can only happen in class hierarchies, so we need classes.
1026   if (!DestType->getAs<RecordType>() || !SrcType->getAs<RecordType>()) {
1027     return TC_NotApplicable;
1028   }
1029
1030   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1031                      /*DetectVirtual=*/true);
1032   if (!Self.IsDerivedFrom(DestType, SrcType, Paths)) {
1033     return TC_NotApplicable;
1034   }
1035
1036   // Target type does derive from source type. Now we're serious. If an error
1037   // appears now, it's not ignored.
1038   // This may not be entirely in line with the standard. Take for example:
1039   // struct A {};
1040   // struct B : virtual A {
1041   //   B(A&);
1042   // };
1043   //
1044   // void f()
1045   // {
1046   //   (void)static_cast<const B&>(*((A*)0));
1047   // }
1048   // As far as the standard is concerned, p5 does not apply (A is virtual), so
1049   // p2 should be used instead - "const B& t(*((A*)0));" is perfectly valid.
1050   // However, both GCC and Comeau reject this example, and accepting it would
1051   // mean more complex code if we're to preserve the nice error message.
1052   // FIXME: Being 100% compliant here would be nice to have.
1053
1054   // Must preserve cv, as always, unless we're in C-style mode.
1055   if (!CStyle && !DestType.isAtLeastAsQualifiedAs(SrcType)) {
1056     msg = diag::err_bad_cxx_cast_qualifiers_away;
1057     return TC_Failed;
1058   }
1059
1060   if (Paths.isAmbiguous(SrcType.getUnqualifiedType())) {
1061     // This code is analoguous to that in CheckDerivedToBaseConversion, except
1062     // that it builds the paths in reverse order.
1063     // To sum up: record all paths to the base and build a nice string from
1064     // them. Use it to spice up the error message.
1065     if (!Paths.isRecordingPaths()) {
1066       Paths.clear();
1067       Paths.setRecordingPaths(true);
1068       Self.IsDerivedFrom(DestType, SrcType, Paths);
1069     }
1070     std::string PathDisplayStr;
1071     std::set<unsigned> DisplayedPaths;
1072     for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end();
1073          PI != PE; ++PI) {
1074       if (DisplayedPaths.insert(PI->back().SubobjectNumber).second) {
1075         // We haven't displayed a path to this particular base
1076         // class subobject yet.
1077         PathDisplayStr += "\n    ";
1078         for (CXXBasePath::const_reverse_iterator EI = PI->rbegin(),
1079                                                  EE = PI->rend();
1080              EI != EE; ++EI)
1081           PathDisplayStr += EI->Base->getType().getAsString() + " -> ";
1082         PathDisplayStr += QualType(DestType).getAsString();
1083       }
1084     }
1085
1086     Self.Diag(OpRange.getBegin(), diag::err_ambiguous_base_to_derived_cast)
1087       << QualType(SrcType).getUnqualifiedType()
1088       << QualType(DestType).getUnqualifiedType()
1089       << PathDisplayStr << OpRange;
1090     msg = 0;
1091     return TC_Failed;
1092   }
1093
1094   if (Paths.getDetectedVirtual() != 0) {
1095     QualType VirtualBase(Paths.getDetectedVirtual(), 0);
1096     Self.Diag(OpRange.getBegin(), diag::err_static_downcast_via_virtual)
1097       << OrigSrcType << OrigDestType << VirtualBase << OpRange;
1098     msg = 0;
1099     return TC_Failed;
1100   }
1101
1102   if (!CStyle) {
1103     switch (Self.CheckBaseClassAccess(OpRange.getBegin(),
1104                                       SrcType, DestType,
1105                                       Paths.front(),
1106                                 diag::err_downcast_from_inaccessible_base)) {
1107     case Sema::AR_accessible:
1108     case Sema::AR_delayed:     // be optimistic
1109     case Sema::AR_dependent:   // be optimistic
1110       break;
1111
1112     case Sema::AR_inaccessible:
1113       msg = 0;
1114       return TC_Failed;
1115     }
1116   }
1117
1118   Self.BuildBasePathArray(Paths, BasePath);
1119   Kind = CK_BaseToDerived;
1120   return TC_Success;
1121 }
1122
1123 /// TryStaticMemberPointerUpcast - Tests whether a conversion according to
1124 /// C++ 5.2.9p9 is valid:
1125 ///
1126 ///   An rvalue of type "pointer to member of D of type cv1 T" can be
1127 ///   converted to an rvalue of type "pointer to member of B of type cv2 T",
1128 ///   where B is a base class of D [...].
1129 ///
1130 TryCastResult
1131 TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType,
1132                              QualType DestType, bool CStyle,
1133                              const SourceRange &OpRange,
1134                              unsigned &msg, CastKind &Kind,
1135                              CXXCastPath &BasePath) {
1136   const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>();
1137   if (!DestMemPtr)
1138     return TC_NotApplicable;
1139
1140   bool WasOverloadedFunction = false;
1141   DeclAccessPair FoundOverload;
1142   if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
1143     if (FunctionDecl *Fn
1144           = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(), DestType, false,
1145                                                     FoundOverload)) {
1146       CXXMethodDecl *M = cast<CXXMethodDecl>(Fn);
1147       SrcType = Self.Context.getMemberPointerType(Fn->getType(),
1148                       Self.Context.getTypeDeclType(M->getParent()).getTypePtr());
1149       WasOverloadedFunction = true;
1150     }
1151   }
1152
1153   const MemberPointerType *SrcMemPtr = SrcType->getAs<MemberPointerType>();
1154   if (!SrcMemPtr) {
1155     msg = diag::err_bad_static_cast_member_pointer_nonmp;
1156     return TC_NotApplicable;
1157   }
1158
1159   // T == T, modulo cv
1160   if (!Self.Context.hasSameUnqualifiedType(SrcMemPtr->getPointeeType(),
1161                                            DestMemPtr->getPointeeType()))
1162     return TC_NotApplicable;
1163
1164   // B base of D
1165   QualType SrcClass(SrcMemPtr->getClass(), 0);
1166   QualType DestClass(DestMemPtr->getClass(), 0);
1167   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1168                   /*DetectVirtual=*/true);
1169   if (!Self.IsDerivedFrom(SrcClass, DestClass, Paths)) {
1170     return TC_NotApplicable;
1171   }
1172
1173   // B is a base of D. But is it an allowed base? If not, it's a hard error.
1174   if (Paths.isAmbiguous(Self.Context.getCanonicalType(DestClass))) {
1175     Paths.clear();
1176     Paths.setRecordingPaths(true);
1177     bool StillOkay = Self.IsDerivedFrom(SrcClass, DestClass, Paths);
1178     assert(StillOkay);
1179     (void)StillOkay;
1180     std::string PathDisplayStr = Self.getAmbiguousPathsDisplayString(Paths);
1181     Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv)
1182       << 1 << SrcClass << DestClass << PathDisplayStr << OpRange;
1183     msg = 0;
1184     return TC_Failed;
1185   }
1186
1187   if (const RecordType *VBase = Paths.getDetectedVirtual()) {
1188     Self.Diag(OpRange.getBegin(), diag::err_memptr_conv_via_virtual)
1189       << SrcClass << DestClass << QualType(VBase, 0) << OpRange;
1190     msg = 0;
1191     return TC_Failed;
1192   }
1193
1194   if (!CStyle) {
1195     switch (Self.CheckBaseClassAccess(OpRange.getBegin(),
1196                                       DestClass, SrcClass,
1197                                       Paths.front(),
1198                                       diag::err_upcast_to_inaccessible_base)) {
1199     case Sema::AR_accessible:
1200     case Sema::AR_delayed:
1201     case Sema::AR_dependent:
1202       // Optimistically assume that the delayed and dependent cases
1203       // will work out.
1204       break;
1205
1206     case Sema::AR_inaccessible:
1207       msg = 0;
1208       return TC_Failed;
1209     }
1210   }
1211
1212   if (WasOverloadedFunction) {
1213     // Resolve the address of the overloaded function again, this time
1214     // allowing complaints if something goes wrong.
1215     FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(),
1216                                                                DestType,
1217                                                                true,
1218                                                                FoundOverload);
1219     if (!Fn) {
1220       msg = 0;
1221       return TC_Failed;
1222     }
1223
1224     SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr, FoundOverload, Fn);
1225     if (!SrcExpr.isUsable()) {
1226       msg = 0;
1227       return TC_Failed;
1228     }
1229   }
1230
1231   Self.BuildBasePathArray(Paths, BasePath);
1232   Kind = CK_DerivedToBaseMemberPointer;
1233   return TC_Success;
1234 }
1235
1236 /// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2
1237 /// is valid:
1238 ///
1239 ///   An expression e can be explicitly converted to a type T using a
1240 ///   @c static_cast if the declaration "T t(e);" is well-formed [...].
1241 TryCastResult
1242 TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
1243                       Sema::CheckedConversionKind CCK,
1244                       const SourceRange &OpRange, unsigned &msg,
1245                       CastKind &Kind) {
1246   if (DestType->isRecordType()) {
1247     if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
1248                                  diag::err_bad_dynamic_cast_incomplete)) {
1249       msg = 0;
1250       return TC_Failed;
1251     }
1252   }
1253
1254   InitializedEntity Entity = InitializedEntity::InitializeTemporary(DestType);
1255   InitializationKind InitKind
1256     = (CCK == Sema::CCK_CStyleCast)
1257         ? InitializationKind::CreateCStyleCast(OpRange.getBegin(), OpRange)
1258     : (CCK == Sema::CCK_FunctionalCast)
1259         ? InitializationKind::CreateFunctionalCast(OpRange)
1260     : InitializationKind::CreateCast(OpRange);
1261   Expr *SrcExprRaw = SrcExpr.get();
1262   InitializationSequence InitSeq(Self, Entity, InitKind, &SrcExprRaw, 1);
1263
1264   // At this point of CheckStaticCast, if the destination is a reference,
1265   // or the expression is an overload expression this has to work.
1266   // There is no other way that works.
1267   // On the other hand, if we're checking a C-style cast, we've still got
1268   // the reinterpret_cast way.
1269   bool CStyle
1270     = (CCK == Sema::CCK_CStyleCast || CCK == Sema::CCK_FunctionalCast);
1271   if (InitSeq.Failed() && (CStyle || !DestType->isReferenceType()))
1272     return TC_NotApplicable;
1273
1274   ExprResult Result
1275     = InitSeq.Perform(Self, Entity, InitKind, MultiExprArg(Self, &SrcExprRaw, 1));
1276   if (Result.isInvalid()) {
1277     msg = 0;
1278     return TC_Failed;
1279   }
1280
1281   if (InitSeq.isConstructorInitialization())
1282     Kind = CK_ConstructorConversion;
1283   else
1284     Kind = CK_NoOp;
1285
1286   SrcExpr = move(Result);
1287   return TC_Success;
1288 }
1289
1290 /// TryConstCast - See if a const_cast from source to destination is allowed,
1291 /// and perform it if it is.
1292 static TryCastResult TryConstCast(Sema &Self, Expr *SrcExpr, QualType DestType,
1293                                   bool CStyle, unsigned &msg) {
1294   DestType = Self.Context.getCanonicalType(DestType);
1295   QualType SrcType = SrcExpr->getType();
1296   if (const ReferenceType *DestTypeTmp =DestType->getAs<ReferenceType>()) {
1297     if (DestTypeTmp->isLValueReferenceType() && !SrcExpr->isLValue()) {
1298       // Cannot const_cast non-lvalue to lvalue reference type. But if this
1299       // is C-style, static_cast might find a way, so we simply suggest a
1300       // message and tell the parent to keep searching.
1301       msg = diag::err_bad_cxx_cast_rvalue;
1302       return TC_NotApplicable;
1303     }
1304
1305     // C++ 5.2.11p4: An lvalue of type T1 can be [cast] to an lvalue of type T2
1306     //   [...] if a pointer to T1 can be [cast] to the type pointer to T2.
1307     DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType());
1308     SrcType = Self.Context.getPointerType(SrcType);
1309   }
1310
1311   // C++ 5.2.11p5: For a const_cast involving pointers to data members [...]
1312   //   the rules for const_cast are the same as those used for pointers.
1313
1314   if (!DestType->isPointerType() &&
1315       !DestType->isMemberPointerType() &&
1316       !DestType->isObjCObjectPointerType()) {
1317     // Cannot cast to non-pointer, non-reference type. Note that, if DestType
1318     // was a reference type, we converted it to a pointer above.
1319     // The status of rvalue references isn't entirely clear, but it looks like
1320     // conversion to them is simply invalid.
1321     // C++ 5.2.11p3: For two pointer types [...]
1322     if (!CStyle)
1323       msg = diag::err_bad_const_cast_dest;
1324     return TC_NotApplicable;
1325   }
1326   if (DestType->isFunctionPointerType() ||
1327       DestType->isMemberFunctionPointerType()) {
1328     // Cannot cast direct function pointers.
1329     // C++ 5.2.11p2: [...] where T is any object type or the void type [...]
1330     // T is the ultimate pointee of source and target type.
1331     if (!CStyle)
1332       msg = diag::err_bad_const_cast_dest;
1333     return TC_NotApplicable;
1334   }
1335   SrcType = Self.Context.getCanonicalType(SrcType);
1336
1337   // Unwrap the pointers. Ignore qualifiers. Terminate early if the types are
1338   // completely equal.
1339   // C++ 5.2.11p3 describes the core semantics of const_cast. All cv specifiers
1340   // in multi-level pointers may change, but the level count must be the same,
1341   // as must be the final pointee type.
1342   while (SrcType != DestType &&
1343          Self.Context.UnwrapSimilarPointerTypes(SrcType, DestType)) {
1344     Qualifiers SrcQuals, DestQuals;
1345     SrcType = Self.Context.getUnqualifiedArrayType(SrcType, SrcQuals);
1346     DestType = Self.Context.getUnqualifiedArrayType(DestType, DestQuals);
1347
1348     // const_cast is permitted to strip cvr-qualifiers, only. Make sure that
1349     // the other qualifiers (e.g., address spaces) are identical.
1350     SrcQuals.removeCVRQualifiers();
1351     DestQuals.removeCVRQualifiers();
1352     if (SrcQuals != DestQuals)
1353       return TC_NotApplicable;
1354   }
1355
1356   // Since we're dealing in canonical types, the remainder must be the same.
1357   if (SrcType != DestType)
1358     return TC_NotApplicable;
1359
1360   return TC_Success;
1361 }
1362
1363 // Checks for undefined behavior in reinterpret_cast.
1364 // The cases that is checked for is:
1365 // *reinterpret_cast<T*>(&a)
1366 // reinterpret_cast<T&>(a)
1367 // where accessing 'a' as type 'T' will result in undefined behavior.
1368 void Sema::CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,
1369                                           bool IsDereference,
1370                                           SourceRange Range) {
1371   unsigned DiagID = IsDereference ?
1372                         diag::warn_pointer_indirection_from_incompatible_type :
1373                         diag::warn_undefined_reinterpret_cast;
1374
1375   if (Diags.getDiagnosticLevel(DiagID, Range.getBegin()) ==
1376           Diagnostic::Ignored) {
1377     return;
1378   }
1379
1380   QualType SrcTy, DestTy;
1381   if (IsDereference) {
1382     if (!SrcType->getAs<PointerType>() || !DestType->getAs<PointerType>()) {
1383       return;
1384     }
1385     SrcTy = SrcType->getPointeeType();
1386     DestTy = DestType->getPointeeType();
1387   } else {
1388     if (!DestType->getAs<ReferenceType>()) {
1389       return;
1390     }
1391     SrcTy = SrcType;
1392     DestTy = DestType->getPointeeType();
1393   }
1394
1395   // Cast is compatible if the types are the same.
1396   if (Context.hasSameUnqualifiedType(DestTy, SrcTy)) {
1397     return;
1398   }
1399   // or one of the types is a char or void type
1400   if (DestTy->isAnyCharacterType() || DestTy->isVoidType() ||
1401       SrcTy->isAnyCharacterType() || SrcTy->isVoidType()) {
1402     return;
1403   }
1404   // or one of the types is a tag type.
1405   if (SrcTy->getAs<TagType>() || DestTy->getAs<TagType>()) {
1406     return;
1407   }
1408
1409   // FIXME: Scoped enums?
1410   if ((SrcTy->isUnsignedIntegerType() && DestTy->isSignedIntegerType()) ||
1411       (SrcTy->isSignedIntegerType() && DestTy->isUnsignedIntegerType())) {
1412     if (Context.getTypeSize(DestTy) == Context.getTypeSize(SrcTy)) {
1413       return;
1414     }
1415   }
1416
1417   Diag(Range.getBegin(), DiagID) << SrcType << DestType << Range;
1418 }
1419
1420 static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
1421                                         QualType DestType, bool CStyle,
1422                                         const SourceRange &OpRange,
1423                                         unsigned &msg,
1424                                         CastKind &Kind) {
1425   bool IsLValueCast = false;
1426
1427   DestType = Self.Context.getCanonicalType(DestType);
1428   QualType SrcType = SrcExpr.get()->getType();
1429
1430   // Is the source an overloaded name? (i.e. &foo)
1431   // If so, reinterpret_cast can not help us here (13.4, p1, bullet 5) ...
1432   if (SrcType == Self.Context.OverloadTy) {
1433     // ... unless foo<int> resolves to an lvalue unambiguously
1434     ExprResult SingleFunctionExpr =
1435         Self.ResolveAndFixSingleFunctionTemplateSpecialization(SrcExpr.get(),
1436           Expr::getValueKindForType(DestType) == VK_RValue // Convert Fun to Ptr
1437         );
1438     if (SingleFunctionExpr.isUsable()) {
1439       SrcExpr = move(SingleFunctionExpr);
1440       SrcType = SrcExpr.get()->getType();
1441     }
1442     else
1443       return TC_NotApplicable;
1444   }
1445
1446   if (const ReferenceType *DestTypeTmp = DestType->getAs<ReferenceType>()) {
1447     bool LValue = DestTypeTmp->isLValueReferenceType();
1448     if (LValue && !SrcExpr.get()->isLValue()) {
1449       // Cannot cast non-lvalue to lvalue reference type. See the similar
1450       // comment in const_cast.
1451       msg = diag::err_bad_cxx_cast_rvalue;
1452       return TC_NotApplicable;
1453     }
1454
1455     if (!CStyle) {
1456       Self.CheckCompatibleReinterpretCast(SrcType, DestType,
1457                                           /*isDereference=*/false, OpRange);
1458     }
1459
1460     // C++ 5.2.10p10: [...] a reference cast reinterpret_cast<T&>(x) has the
1461     //   same effect as the conversion *reinterpret_cast<T*>(&x) with the
1462     //   built-in & and * operators.
1463
1464     const char *inappropriate = 0;
1465     switch (SrcExpr.get()->getObjectKind()) {
1466     case OK_Ordinary:
1467       break;
1468     case OK_BitField:        inappropriate = "bit-field";           break;
1469     case OK_VectorComponent: inappropriate = "vector element";      break;
1470     case OK_ObjCProperty:    inappropriate = "property expression"; break;
1471     }
1472     if (inappropriate) {
1473       Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_reference)
1474           << inappropriate << DestType
1475           << OpRange << SrcExpr.get()->getSourceRange();
1476       msg = 0; SrcExpr = ExprError();
1477       return TC_NotApplicable;
1478     }
1479
1480     // This code does this transformation for the checked types.
1481     DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType());
1482     SrcType = Self.Context.getPointerType(SrcType);
1483
1484     IsLValueCast = true;
1485   }
1486
1487   // Canonicalize source for comparison.
1488   SrcType = Self.Context.getCanonicalType(SrcType);
1489
1490   const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>(),
1491                           *SrcMemPtr = SrcType->getAs<MemberPointerType>();
1492   if (DestMemPtr && SrcMemPtr) {
1493     // C++ 5.2.10p9: An rvalue of type "pointer to member of X of type T1"
1494     //   can be explicitly converted to an rvalue of type "pointer to member
1495     //   of Y of type T2" if T1 and T2 are both function types or both object
1496     //   types.
1497     if (DestMemPtr->getPointeeType()->isFunctionType() !=
1498         SrcMemPtr->getPointeeType()->isFunctionType())
1499       return TC_NotApplicable;
1500
1501     // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away
1502     //   constness.
1503     // A reinterpret_cast followed by a const_cast can, though, so in C-style,
1504     // we accept it.
1505     if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle,
1506                            /*CheckObjCLifetime=*/CStyle)) {
1507       msg = diag::err_bad_cxx_cast_qualifiers_away;
1508       return TC_Failed;
1509     }
1510
1511     // Don't allow casting between member pointers of different sizes.
1512     if (Self.Context.getTypeSize(DestMemPtr) !=
1513         Self.Context.getTypeSize(SrcMemPtr)) {
1514       msg = diag::err_bad_cxx_cast_member_pointer_size;
1515       return TC_Failed;
1516     }
1517
1518     // A valid member pointer cast.
1519     Kind = IsLValueCast? CK_LValueBitCast : CK_BitCast;
1520     return TC_Success;
1521   }
1522
1523   // See below for the enumeral issue.
1524   if (SrcType->isNullPtrType() && DestType->isIntegralType(Self.Context)) {
1525     // C++0x 5.2.10p4: A pointer can be explicitly converted to any integral
1526     //   type large enough to hold it. A value of std::nullptr_t can be
1527     //   converted to an integral type; the conversion has the same meaning
1528     //   and validity as a conversion of (void*)0 to the integral type.
1529     if (Self.Context.getTypeSize(SrcType) >
1530         Self.Context.getTypeSize(DestType)) {
1531       msg = diag::err_bad_reinterpret_cast_small_int;
1532       return TC_Failed;
1533     }
1534     Kind = CK_PointerToIntegral;
1535     return TC_Success;
1536   }
1537
1538   bool destIsVector = DestType->isVectorType();
1539   bool srcIsVector = SrcType->isVectorType();
1540   if (srcIsVector || destIsVector) {
1541     // FIXME: Should this also apply to floating point types?
1542     bool srcIsScalar = SrcType->isIntegralType(Self.Context);
1543     bool destIsScalar = DestType->isIntegralType(Self.Context);
1544
1545     // Check if this is a cast between a vector and something else.
1546     if (!(srcIsScalar && destIsVector) && !(srcIsVector && destIsScalar) &&
1547         !(srcIsVector && destIsVector))
1548       return TC_NotApplicable;
1549
1550     // If both types have the same size, we can successfully cast.
1551     if (Self.Context.getTypeSize(SrcType)
1552           == Self.Context.getTypeSize(DestType)) {
1553       Kind = CK_BitCast;
1554       return TC_Success;
1555     }
1556
1557     if (destIsScalar)
1558       msg = diag::err_bad_cxx_cast_vector_to_scalar_different_size;
1559     else if (srcIsScalar)
1560       msg = diag::err_bad_cxx_cast_scalar_to_vector_different_size;
1561     else
1562       msg = diag::err_bad_cxx_cast_vector_to_vector_different_size;
1563
1564     return TC_Failed;
1565   }
1566
1567   bool destIsPtr = DestType->isAnyPointerType() ||
1568                    DestType->isBlockPointerType();
1569   bool srcIsPtr = SrcType->isAnyPointerType() ||
1570                   SrcType->isBlockPointerType();
1571   if (!destIsPtr && !srcIsPtr) {
1572     // Except for std::nullptr_t->integer and lvalue->reference, which are
1573     // handled above, at least one of the two arguments must be a pointer.
1574     return TC_NotApplicable;
1575   }
1576
1577   if (SrcType == DestType) {
1578     // C++ 5.2.10p2 has a note that mentions that, subject to all other
1579     // restrictions, a cast to the same type is allowed. The intent is not
1580     // entirely clear here, since all other paragraphs explicitly forbid casts
1581     // to the same type. However, the behavior of compilers is pretty consistent
1582     // on this point: allow same-type conversion if the involved types are
1583     // pointers, disallow otherwise.
1584     Kind = CK_NoOp;
1585     return TC_Success;
1586   }
1587
1588   if (DestType->isIntegralType(Self.Context)) {
1589     assert(srcIsPtr && "One type must be a pointer");
1590     // C++ 5.2.10p4: A pointer can be explicitly converted to any integral
1591     //   type large enough to hold it; except in Microsoft mode, where the
1592     //   integral type size doesn't matter.
1593     if ((Self.Context.getTypeSize(SrcType) >
1594          Self.Context.getTypeSize(DestType)) &&
1595          !Self.getLangOptions().Microsoft) {
1596       msg = diag::err_bad_reinterpret_cast_small_int;
1597       return TC_Failed;
1598     }
1599     Kind = CK_PointerToIntegral;
1600     return TC_Success;
1601   }
1602
1603   if (SrcType->isIntegralOrEnumerationType()) {
1604     assert(destIsPtr && "One type must be a pointer");
1605     // C++ 5.2.10p5: A value of integral or enumeration type can be explicitly
1606     //   converted to a pointer.
1607     // C++ 5.2.10p9: [Note: ...a null pointer constant of integral type is not
1608     //   necessarily converted to a null pointer value.]
1609     Kind = CK_IntegralToPointer;
1610     return TC_Success;
1611   }
1612
1613   if (!destIsPtr || !srcIsPtr) {
1614     // With the valid non-pointer conversions out of the way, we can be even
1615     // more stringent.
1616     return TC_NotApplicable;
1617   }
1618
1619   // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away constness.
1620   // The C-style cast operator can.
1621   if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle,
1622                          /*CheckObjCLifetime=*/CStyle)) {
1623     msg = diag::err_bad_cxx_cast_qualifiers_away;
1624     return TC_Failed;
1625   }
1626
1627   // Cannot convert between block pointers and Objective-C object pointers.
1628   if ((SrcType->isBlockPointerType() && DestType->isObjCObjectPointerType()) ||
1629       (DestType->isBlockPointerType() && SrcType->isObjCObjectPointerType()))
1630     return TC_NotApplicable;
1631
1632   // Any pointer can be cast to an Objective-C pointer type with a C-style
1633   // cast.
1634   if (CStyle && DestType->isObjCObjectPointerType()) {
1635     Kind = CK_AnyPointerToObjCPointerCast;
1636     return TC_Success;
1637   }
1638
1639   // Not casting away constness, so the only remaining check is for compatible
1640   // pointer categories.
1641   Kind = IsLValueCast? CK_LValueBitCast : CK_BitCast;
1642
1643   if (SrcType->isFunctionPointerType()) {
1644     if (DestType->isFunctionPointerType()) {
1645       // C++ 5.2.10p6: A pointer to a function can be explicitly converted to
1646       // a pointer to a function of a different type.
1647       return TC_Success;
1648     }
1649
1650     // C++0x 5.2.10p8: Converting a pointer to a function into a pointer to
1651     //   an object type or vice versa is conditionally-supported.
1652     // Compilers support it in C++03 too, though, because it's necessary for
1653     // casting the return value of dlsym() and GetProcAddress().
1654     // FIXME: Conditionally-supported behavior should be configurable in the
1655     // TargetInfo or similar.
1656     if (!Self.getLangOptions().CPlusPlus0x)
1657       Self.Diag(OpRange.getBegin(), diag::ext_cast_fn_obj) << OpRange;
1658     return TC_Success;
1659   }
1660
1661   if (DestType->isFunctionPointerType()) {
1662     // See above.
1663     if (!Self.getLangOptions().CPlusPlus0x)
1664       Self.Diag(OpRange.getBegin(), diag::ext_cast_fn_obj) << OpRange;
1665     return TC_Success;
1666   }
1667
1668   // C++ 5.2.10p7: A pointer to an object can be explicitly converted to
1669   //   a pointer to an object of different type.
1670   // Void pointers are not specified, but supported by every compiler out there.
1671   // So we finish by allowing everything that remains - it's got to be two
1672   // object pointers.
1673   return TC_Success;
1674 }
1675
1676 ExprResult
1677 Sema::CXXCheckCStyleCast(SourceRange R, QualType CastTy, ExprValueKind &VK,
1678                          Expr *CastExpr, CastKind &Kind,
1679                          CXXCastPath &BasePath,
1680                          bool FunctionalStyle) {
1681   // This test is outside everything else because it's the only case where
1682   // a non-lvalue-reference target type does not lead to decay.
1683   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
1684   if (CastTy->isVoidType()) {
1685     Kind = CK_ToVoid;
1686
1687     ExprResult CastExprRes = IgnoredValueConversions(CastExpr);
1688     if (CastExprRes.isInvalid())
1689       return ExprError();
1690     CastExpr = CastExprRes.take();
1691
1692     if (CastExpr->getType() == Context.BoundMemberTy)
1693       return CheckPlaceholderExpr(CastExpr); // will always fail
1694
1695     if (CastExpr->getType() == Context.OverloadTy) {
1696       ExprResult SingleFunctionExpr =
1697         ResolveAndFixSingleFunctionTemplateSpecialization(
1698                   CastExpr, /* Decay Function to ptr */ false,
1699                   /* Complain */ true, R, CastTy,
1700                   diag::err_bad_cstyle_cast_overload);
1701       if (SingleFunctionExpr.isInvalid())
1702         return ExprError();
1703       CastExpr = SingleFunctionExpr.take();
1704     }
1705
1706     assert(!CastExpr->getType()->isPlaceholderType());
1707
1708     return Owned(CastExpr);
1709   }
1710
1711   // Make sure we determine the value kind before we bail out for
1712   // dependent types.
1713   VK = Expr::getValueKindForType(CastTy);
1714
1715   // If the type is dependent, we won't do any other semantic analysis now.
1716   if (CastTy->isDependentType() || CastExpr->isTypeDependent()) {
1717     Kind = CK_Dependent;
1718     return Owned(CastExpr);
1719   }
1720
1721   if (VK == VK_RValue && !CastTy->isRecordType()) {
1722     ExprResult CastExprRes = DefaultFunctionArrayLvalueConversion(CastExpr);
1723     if (CastExprRes.isInvalid())
1724       return ExprError();
1725     CastExpr = CastExprRes.take();
1726   }
1727
1728   // AltiVec vector initialization with a single literal.
1729   if (const VectorType *vecTy = CastTy->getAs<VectorType>())
1730     if (vecTy->getVectorKind() == VectorType::AltiVecVector
1731         && (CastExpr->getType()->isIntegerType()
1732             || CastExpr->getType()->isFloatingType())) {
1733       Kind = CK_VectorSplat;
1734       return Owned(CastExpr);
1735     }
1736
1737   // C++ [expr.cast]p5: The conversions performed by
1738   //   - a const_cast,
1739   //   - a static_cast,
1740   //   - a static_cast followed by a const_cast,
1741   //   - a reinterpret_cast, or
1742   //   - a reinterpret_cast followed by a const_cast,
1743   //   can be performed using the cast notation of explicit type conversion.
1744   //   [...] If a conversion can be interpreted in more than one of the ways
1745   //   listed above, the interpretation that appears first in the list is used,
1746   //   even if a cast resulting from that interpretation is ill-formed.
1747   // In plain language, this means trying a const_cast ...
1748   unsigned msg = diag::err_bad_cxx_cast_generic;
1749   TryCastResult tcr = TryConstCast(*this, CastExpr, CastTy, /*CStyle*/true,
1750                                    msg);
1751   if (tcr == TC_Success)
1752     Kind = CK_NoOp;
1753
1754   Sema::CheckedConversionKind CCK
1755     = FunctionalStyle? Sema::CCK_FunctionalCast
1756                      : Sema::CCK_CStyleCast;
1757   if (tcr == TC_NotApplicable) {
1758     // ... or if that is not possible, a static_cast, ignoring const, ...
1759     ExprResult CastExprRes = Owned(CastExpr);
1760     tcr = TryStaticCast(*this, CastExprRes, CastTy, CCK, R, msg, Kind,
1761                         BasePath);
1762     if (CastExprRes.isInvalid())
1763       return ExprError();
1764     CastExpr = CastExprRes.take();
1765     if (tcr == TC_NotApplicable) {
1766       // ... and finally a reinterpret_cast, ignoring const.
1767       CastExprRes = Owned(CastExpr);
1768       tcr = TryReinterpretCast(*this, CastExprRes, CastTy, /*CStyle*/true, R,
1769                                msg, Kind);
1770       if (CastExprRes.isInvalid())
1771         return ExprError();
1772       CastExpr = CastExprRes.take();
1773     }
1774   }
1775
1776   if (getLangOptions().ObjCAutoRefCount && tcr == TC_Success)
1777     CheckObjCARCConversion(R, CastTy, CastExpr, CCK);
1778
1779   if (tcr != TC_Success && msg != 0) {
1780     if (CastExpr->getType() == Context.OverloadTy) {
1781       DeclAccessPair Found;
1782       FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(CastExpr,
1783                                 CastTy,
1784                                 /* Complain */ true,
1785                                 Found);
1786
1787       assert(!Fn && "cast failed but able to resolve overload expression!!");
1788       (void)Fn;
1789
1790     } else {
1791       diagnoseBadCast(*this, msg, (FunctionalStyle ? CT_Functional : CT_CStyle),
1792                       R, CastExpr, CastTy);
1793     }
1794   }
1795   else if (Kind == CK_BitCast)
1796     CheckCastAlign(CastExpr, CastTy, R);
1797
1798   if (tcr != TC_Success)
1799     return ExprError();
1800
1801   return Owned(CastExpr);
1802 }