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