lib/Sema/SemaCXXCast.cpp

   1 //===--- SemaNamedCast.cpp - Semantic Analysis for Named Casts ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements semantic analysis for C++ named casts.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "Sema.h"
  15 #include "SemaInit.h"
  16 #include "clang/AST/ExprCXX.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/CXXInheritance.h"
  19 #include "clang/Basic/PartialDiagnostic.h"
  20 #include "llvm/ADT/SmallVector.h"
  21 #include <set>
  22 using namespace clang;
  23
  24 enum TryCastResult {
  25   TC_NotApplicable, ///< The cast method is not applicable.
  26   TC_Success,       ///< The cast method is appropriate and successful.
  27   TC_Failed         ///< The cast method is appropriate, but failed. A
  28                     ///< diagnostic has been emitted.
  29 };
  30
  31 enum CastType {
  32   CT_Const,       ///< const_cast
  33   CT_Static,      ///< static_cast
  34   CT_Reinterpret, ///< reinterpret_cast
  35   CT_Dynamic,     ///< dynamic_cast
  36   CT_CStyle,      ///< (Type)expr
  37   CT_Functional   ///< Type(expr)
  38 };
  39
  40 static void CheckConstCast(Sema &Self, Expr *&SrcExpr, QualType DestType,
  41                            const SourceRange &OpRange,
  42                            const SourceRange &DestRange);
  43 static void CheckReinterpretCast(Sema &Self, Expr *&SrcExpr, QualType DestType,
  44                                  const SourceRange &OpRange,
  45                                  const SourceRange &DestRange,
  46                                  CastExpr::CastKind &Kind);
  47 static void CheckStaticCast(Sema &Self, Expr *&SrcExpr, QualType DestType,
  48                             const SourceRange &OpRange,
  49                             CastExpr::CastKind &Kind,
  50                             CXXMethodDecl *&ConversionDecl);
  51 static void CheckDynamicCast(Sema &Self, Expr *&SrcExpr, QualType DestType,
  52                              const SourceRange &OpRange,
  53                              const SourceRange &DestRange,
  54                              CastExpr::CastKind &Kind);
  55
  56 static bool CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType);
  57
  58 // The Try functions attempt a specific way of casting. If they succeed, they
  59 // return TC_Success. If their way of casting is not appropriate for the given
  60 // arguments, they return TC_NotApplicable and *may* set diag to a diagnostic
  61 // to emit if no other way succeeds. If their way of casting is appropriate but
  62 // fails, they return TC_Failed and *must* set diag; they can set it to 0 if
  63 // they emit a specialized diagnostic.
  64 // All diagnostics returned by these functions must expect the same three
  65 // arguments:
  66 // %0: Cast Type (a value from the CastType enumeration)
  67 // %1: Source Type
  68 // %2: Destination Type
  69 static TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr,
  70                                            QualType DestType, unsigned &msg);
  71 static TryCastResult TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr,
  72                                                 QualType DestType, bool CStyle,
  73                                                 const SourceRange &OpRange,
  74                                                 unsigned &msg,
  75                                                 CastExpr::CastKind &Kind);
  76 static TryCastResult TryStaticPointerDowncast(Sema &Self, QualType SrcType,
  77                                               QualType DestType, bool CStyle,
  78                                               const SourceRange &OpRange,
  79                                               unsigned &msg,
  80                                               CastExpr::CastKind &Kind);
  81 static TryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType,
  82                                        CanQualType DestType, bool CStyle,
  83                                        const SourceRange &OpRange,
  84                                        QualType OrigSrcType,
  85                                        QualType OrigDestType, unsigned &msg,
  86                                        CastExpr::CastKind &Kind);
  87 static TryCastResult TryStaticMemberPointerUpcast(Sema &Self, QualType SrcType,
  88                                                   QualType DestType,bool CStyle,
  89                                                   const SourceRange &OpRange,
  90                                                   unsigned &msg,
  91                                                   CastExpr::CastKind &Kind);
  92 static TryCastResult TryStaticImplicitCast(Sema &Self, Expr *&SrcExpr,
  93                                            QualType DestType, bool CStyle,
  94                                            const SourceRange &OpRange,
  95                                            unsigned &msg,
  96                                            CastExpr::CastKind &Kind,
  97                                            CXXMethodDecl *&ConversionDecl);
  98 static TryCastResult TryStaticCast(Sema &Self, Expr *&SrcExpr,
  99                                    QualType DestType, bool CStyle,
 100                                    const SourceRange &OpRange,
 101                                    unsigned &msg,
 102                                    CastExpr::CastKind &Kind,
 103                                    CXXMethodDecl *&ConversionDecl);
 104 static TryCastResult TryConstCast(Sema &Self, Expr *SrcExpr, QualType DestType,
 105                                   bool CStyle, unsigned &msg);
 106 static TryCastResult TryReinterpretCast(Sema &Self, Expr *SrcExpr,
 107                                         QualType DestType, bool CStyle,
 108                                         const SourceRange &OpRange,
 109                                         unsigned &msg,
 110                                         CastExpr::CastKind &Kind);
 111
 112 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
 113 Action::OwningExprResult
 114 Sema::ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind,
 115                         SourceLocation LAngleBracketLoc, TypeTy *Ty,
 116                         SourceLocation RAngleBracketLoc,
 117                         SourceLocation LParenLoc, ExprArg E,
 118                         SourceLocation RParenLoc) {
 119
 120   TypeSourceInfo *DestTInfo;
 121   QualType DestType = GetTypeFromParser(Ty, &DestTInfo);
 122   if (!DestTInfo)
 123     DestTInfo = Context.getTrivialTypeSourceInfo(DestType, SourceLocation());
 124
 125   return BuildCXXNamedCast(OpLoc, Kind, DestTInfo, move(E),
 126                            SourceRange(LAngleBracketLoc, RAngleBracketLoc),
 127                            SourceRange(LParenLoc, RParenLoc));
 128 }
 129
 130 Action::OwningExprResult
 131 Sema::BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind,
 132                         TypeSourceInfo *DestTInfo, ExprArg E,
 133                         SourceRange AngleBrackets, SourceRange Parens) {
 134   Expr *Ex = E.takeAs<Expr>();
 135   QualType DestType = DestTInfo->getType();
 136
 137   SourceRange OpRange(OpLoc, Parens.getEnd());
 138   SourceRange DestRange = AngleBrackets;
 139
 140   // If the type is dependent, we won't do the semantic analysis now.
 141   // FIXME: should we check this in a more fine-grained manner?
 142   bool TypeDependent = DestType->isDependentType() || Ex->isTypeDependent();
 143
 144   switch (Kind) {
 145   default: assert(0 && "Unknown C++ cast!");
 146
 147   case tok::kw_const_cast:
 148     if (!TypeDependent)
 149       CheckConstCast(*this, Ex, DestType, OpRange, DestRange);
 150     return Owned(new (Context) CXXConstCastExpr(DestType.getNonReferenceType(),
 151                                                 Ex, DestTInfo, OpLoc));
 152
 153   case tok::kw_dynamic_cast: {
 154     CastExpr::CastKind Kind = CastExpr::CK_Unknown;
 155     if (!TypeDependent)
 156       CheckDynamicCast(*this, Ex, DestType, OpRange, DestRange, Kind);
 157     return Owned(new (Context)CXXDynamicCastExpr(DestType.getNonReferenceType(),
 158                                                  Kind, Ex, DestTInfo, OpLoc));
 159   }
 160   case tok::kw_reinterpret_cast: {
 161     CastExpr::CastKind Kind = CastExpr::CK_Unknown;
 162     if (!TypeDependent)
 163       CheckReinterpretCast(*this, Ex, DestType, OpRange, DestRange, Kind);
 164     return Owned(new (Context) CXXReinterpretCastExpr(
 165                                   DestType.getNonReferenceType(),
 166                                   Kind, Ex, DestTInfo, OpLoc));
 167   }
 168   case tok::kw_static_cast: {
 169     CastExpr::CastKind Kind = CastExpr::CK_Unknown;
 170     if (!TypeDependent) {
 171       CXXMethodDecl *Method = 0;
 172
 173       CheckStaticCast(*this, Ex, DestType, OpRange, Kind, Method);
 174
 175       if (Method) {
 176         OwningExprResult CastArg
 177           = BuildCXXCastArgument(OpLoc, DestType.getNonReferenceType(),
 178                                  Kind, Method, Owned(Ex));
 179           if (CastArg.isInvalid())
 180             return ExprError();
 181
 182           Ex = CastArg.takeAs<Expr>();
 183       }
 184     }
 185
 186     return Owned(new (Context) CXXStaticCastExpr(DestType.getNonReferenceType(),
 187                                                  Kind, Ex, DestTInfo, OpLoc));
 188   }
 189   }
 190
 191   return ExprError();
 192 }
 193
 194 /// UnwrapDissimilarPointerTypes - Like Sema::UnwrapSimilarPointerTypes,
 195 /// this removes one level of indirection from both types, provided that they're
 196 /// the same kind of pointer (plain or to-member). Unlike the Sema function,
 197 /// this one doesn't care if the two pointers-to-member don't point into the
 198 /// same class. This is because CastsAwayConstness doesn't care.
 199 bool UnwrapDissimilarPointerTypes(QualType& T1, QualType& T2) {
 200   const PointerType *T1PtrType = T1->getAs<PointerType>(),
 201                     *T2PtrType = T2->getAs<PointerType>();
 202   if (T1PtrType && T2PtrType) {
 203     T1 = T1PtrType->getPointeeType();
 204     T2 = T2PtrType->getPointeeType();
 205     return true;
 206   }
 207
 208   const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(),
 209                           *T2MPType = T2->getAs<MemberPointerType>();
 210   if (T1MPType && T2MPType) {
 211     T1 = T1MPType->getPointeeType();
 212     T2 = T2MPType->getPointeeType();
 213     return true;
 214   }
 215   return false;
 216 }
 217
 218 /// CastsAwayConstness - Check if the pointer conversion from SrcType to
 219 /// DestType casts away constness as defined in C++ 5.2.11p8ff. This is used by
 220 /// the cast checkers.  Both arguments must denote pointer (possibly to member)
 221 /// types.
 222 static bool
 223 CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType) {
 224   // Casting away constness is defined in C++ 5.2.11p8 with reference to
 225   // C++ 4.4. We piggyback on Sema::IsQualificationConversion for this, since
 226   // the rules are non-trivial. So first we construct Tcv *...cv* as described
 227   // in C++ 5.2.11p8.
 228   assert((SrcType->isPointerType() || SrcType->isMemberPointerType()) &&
 229          "Source type is not pointer or pointer to member.");
 230   assert((DestType->isPointerType() || DestType->isMemberPointerType()) &&
 231          "Destination type is not pointer or pointer to member.");
 232
 233   QualType UnwrappedSrcType = Self.Context.getCanonicalType(SrcType),
 234            UnwrappedDestType = Self.Context.getCanonicalType(DestType);
 235   llvm::SmallVector<Qualifiers, 8> cv1, cv2;
 236
 237   // Find the qualifications.
 238   while (UnwrapDissimilarPointerTypes(UnwrappedSrcType, UnwrappedDestType)) {
 239     cv1.push_back(UnwrappedSrcType.getQualifiers());
 240     cv2.push_back(UnwrappedDestType.getQualifiers());
 241   }
 242   assert(cv1.size() > 0 && "Must have at least one pointer level.");
 243
 244   // Construct void pointers with those qualifiers (in reverse order of
 245   // unwrapping, of course).
 246   QualType SrcConstruct = Self.Context.VoidTy;
 247   QualType DestConstruct = Self.Context.VoidTy;
 248   ASTContext &Context = Self.Context;
 249   for (llvm::SmallVector<Qualifiers, 8>::reverse_iterator i1 = cv1.rbegin(),
 250                                                           i2 = cv2.rbegin();
 251        i1 != cv1.rend(); ++i1, ++i2) {
 252     SrcConstruct
 253       = Context.getPointerType(Context.getQualifiedType(SrcConstruct, *i1));
 254     DestConstruct
 255       = Context.getPointerType(Context.getQualifiedType(DestConstruct, *i2));
 256   }
 257
 258   // Test if they're compatible.
 259   return SrcConstruct != DestConstruct &&
 260     !Self.IsQualificationConversion(SrcConstruct, DestConstruct);
 261 }
 262
 263 /// CheckDynamicCast - Check that a dynamic_cast\<DestType\>(SrcExpr) is valid.
 264 /// Refer to C++ 5.2.7 for details. Dynamic casts are used mostly for runtime-
 265 /// checked downcasts in class hierarchies.
 266 static void
 267 CheckDynamicCast(Sema &Self, Expr *&SrcExpr, QualType DestType,
 268                  const SourceRange &OpRange,
 269                  const SourceRange &DestRange, CastExpr::CastKind &Kind) {
 270   QualType OrigDestType = DestType, OrigSrcType = SrcExpr->getType();
 271   DestType = Self.Context.getCanonicalType(DestType);
 272
 273   // C++ 5.2.7p1: T shall be a pointer or reference to a complete class type,
 274   //   or "pointer to cv void".
 275
 276   QualType DestPointee;
 277   const PointerType *DestPointer = DestType->getAs<PointerType>();
 278   const ReferenceType *DestReference = DestType->getAs<ReferenceType>();
 279   if (DestPointer) {
 280     DestPointee = DestPointer->getPointeeType();
 281   } else if (DestReference) {
 282     DestPointee = DestReference->getPointeeType();
 283   } else {
 284     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ref_or_ptr)
 285       << OrigDestType << DestRange;
 286     return;
 287   }
 288
 289   const RecordType *DestRecord = DestPointee->getAs<RecordType>();
 290   if (DestPointee->isVoidType()) {
 291     assert(DestPointer && "Reference to void is not possible");
 292   } else if (DestRecord) {
 293     if (Self.RequireCompleteType(OpRange.getBegin(), DestPointee,
 294                                  PDiag(diag::err_bad_dynamic_cast_incomplete)
 295                                    << DestRange))
 296       return;
 297   } else {
 298     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)
 299       << DestPointee.getUnqualifiedType() << DestRange;
 300     return;
 301   }
 302
 303   // C++0x 5.2.7p2: If T is a pointer type, v shall be an rvalue of a pointer to
 304   //   complete class type, [...]. If T is an lvalue reference type, v shall be
 305   //   an lvalue of a complete class type, [...]. If T is an rvalue reference
 306   //   type, v shall be an expression having a complete effective class type,
 307   //   [...]
 308
 309   QualType SrcType = Self.Context.getCanonicalType(OrigSrcType);
 310   QualType SrcPointee;
 311   if (DestPointer) {
 312     if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) {
 313       SrcPointee = SrcPointer->getPointeeType();
 314     } else {
 315       Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ptr)
 316         << OrigSrcType << SrcExpr->getSourceRange();
 317       return;
 318     }
 319   } else if (DestReference->isLValueReferenceType()) {
 320     if (SrcExpr->isLvalue(Self.Context) != Expr::LV_Valid) {
 321       Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_rvalue)
 322         << CT_Dynamic << OrigSrcType << OrigDestType << OpRange;
 323     }
 324     SrcPointee = SrcType;
 325   } else {
 326     SrcPointee = SrcType;
 327   }
 328
 329   const RecordType *SrcRecord = SrcPointee->getAs<RecordType>();
 330   if (SrcRecord) {
 331     if (Self.RequireCompleteType(OpRange.getBegin(), SrcPointee,
 332                                  PDiag(diag::err_bad_dynamic_cast_incomplete)
 333                                    << SrcExpr->getSourceRange()))
 334       return;
 335   } else {
 336     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)
 337       << SrcPointee.getUnqualifiedType() << SrcExpr->getSourceRange();
 338     return;
 339   }
 340
 341   assert((DestPointer || DestReference) &&
 342     "Bad destination non-ptr/ref slipped through.");
 343   assert((DestRecord || DestPointee->isVoidType()) &&
 344     "Bad destination pointee slipped through.");
 345   assert(SrcRecord && "Bad source pointee slipped through.");
 346
 347   // C++ 5.2.7p1: The dynamic_cast operator shall not cast away constness.
 348   if (!DestPointee.isAtLeastAsQualifiedAs(SrcPointee)) {
 349     Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_const_away)
 350       << CT_Dynamic << OrigSrcType << OrigDestType << OpRange;
 351     return;
 352   }
 353
 354   // C++ 5.2.7p3: If the type of v is the same as the required result type,
 355   //   [except for cv].
 356   if (DestRecord == SrcRecord) {
 357     return;
 358   }
 359
 360   // C++ 5.2.7p5
 361   // Upcasts are resolved statically.
 362   if (DestRecord && Self.IsDerivedFrom(SrcPointee, DestPointee)) {
 363     Self.CheckDerivedToBaseConversion(SrcPointee, DestPointee,
 364                                       OpRange.getBegin(), OpRange);
 365     Kind = CastExpr::CK_DerivedToBase;
 366     // Diagnostic already emitted on error.
 367     return;
 368   }
 369
 370   // C++ 5.2.7p6: Otherwise, v shall be [polymorphic].
 371   const RecordDecl *SrcDecl = SrcRecord->getDecl()->getDefinition(Self.Context);
 372   assert(SrcDecl && "Definition missing");
 373   if (!cast<CXXRecordDecl>(SrcDecl)->isPolymorphic()) {
 374     Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_polymorphic)
 375       << SrcPointee.getUnqualifiedType() << SrcExpr->getSourceRange();
 376   }
 377
 378   // Done. Everything else is run-time checks.
 379   Kind = CastExpr::CK_Dynamic;
 380 }
 381
 382 /// CheckConstCast - Check that a const_cast\<DestType\>(SrcExpr) is valid.
 383 /// Refer to C++ 5.2.11 for details. const_cast is typically used in code
 384 /// like this:
 385 /// const char *str = "literal";
 386 /// legacy_function(const_cast\<char*\>(str));
 387 void
 388 CheckConstCast(Sema &Self, Expr *&SrcExpr, QualType DestType,
 389                const SourceRange &OpRange, const SourceRange &DestRange) {
 390   if (!DestType->isLValueReferenceType())
 391     Self.DefaultFunctionArrayConversion(SrcExpr);
 392
 393   unsigned msg = diag::err_bad_cxx_cast_generic;
 394   if (TryConstCast(Self, SrcExpr, DestType, /*CStyle*/false, msg) != TC_Success
 395       && msg != 0)
 396     Self.Diag(OpRange.getBegin(), msg) << CT_Const
 397       << SrcExpr->getType() << DestType << OpRange;
 398 }
 399
 400 /// CheckReinterpretCast - Check that a reinterpret_cast\<DestType\>(SrcExpr) is
 401 /// valid.
 402 /// Refer to C++ 5.2.10 for details. reinterpret_cast is typically used in code
 403 /// like this:
 404 /// char *bytes = reinterpret_cast\<char*\>(int_ptr);
 405 void
 406 CheckReinterpretCast(Sema &Self, Expr *&SrcExpr, QualType DestType,
 407                      const SourceRange &OpRange, const SourceRange &DestRange,
 408                      CastExpr::CastKind &Kind) {
 409   if (!DestType->isLValueReferenceType())
 410     Self.DefaultFunctionArrayConversion(SrcExpr);
 411
 412   unsigned msg = diag::err_bad_cxx_cast_generic;
 413   if (TryReinterpretCast(Self, SrcExpr, DestType, /*CStyle*/false, OpRange,
 414                          msg, Kind)
 415       != TC_Success && msg != 0)
 416     Self.Diag(OpRange.getBegin(), msg) << CT_Reinterpret
 417       << SrcExpr->getType() << DestType << OpRange;
 418 }
 419
 420
 421 /// CheckStaticCast - Check that a static_cast\<DestType\>(SrcExpr) is valid.
 422 /// Refer to C++ 5.2.9 for details. Static casts are mostly used for making
 423 /// implicit conversions explicit and getting rid of data loss warnings.
 424 void
 425 CheckStaticCast(Sema &Self, Expr *&SrcExpr, QualType DestType,
 426                 const SourceRange &OpRange, CastExpr::CastKind &Kind,
 427                 CXXMethodDecl *&ConversionDecl) {
 428   // This test is outside everything else because it's the only case where
 429   // a non-lvalue-reference target type does not lead to decay.
 430   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
 431   if (DestType->isVoidType()) {
 432     Kind = CastExpr::CK_ToVoid;
 433     return;
 434   }
 435
 436   if (!DestType->isLValueReferenceType() && !DestType->isRecordType())
 437     Self.DefaultFunctionArrayConversion(SrcExpr);
 438
 439   unsigned msg = diag::err_bad_cxx_cast_generic;
 440   if (TryStaticCast(Self, SrcExpr, DestType, /*CStyle*/false, OpRange, msg,
 441                     Kind, ConversionDecl)
 442       != TC_Success && msg != 0)
 443     Self.Diag(OpRange.getBegin(), msg) << CT_Static
 444       << SrcExpr->getType() << DestType << OpRange;
 445 }
 446
 447 /// TryStaticCast - Check if a static cast can be performed, and do so if
 448 /// possible. If @p CStyle, ignore access restrictions on hierarchy casting
 449 /// and casting away constness.
 450 static TryCastResult TryStaticCast(Sema &Self, Expr *&SrcExpr,
 451                                    QualType DestType, bool CStyle,
 452                                    const SourceRange &OpRange, unsigned &msg,
 453                                    CastExpr::CastKind &Kind,
 454                                    CXXMethodDecl *&ConversionDecl) {
 455   // The order the tests is not entirely arbitrary. There is one conversion
 456   // that can be handled in two different ways. Given:
 457   // struct A {};
 458   // struct B : public A {
 459   //   B(); B(const A&);
 460   // };
 461   // const A &a = B();
 462   // the cast static_cast<const B&>(a) could be seen as either a static
 463   // reference downcast, or an explicit invocation of the user-defined
 464   // conversion using B's conversion constructor.
 465   // DR 427 specifies that the downcast is to be applied here.
 466
 467   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
 468   // Done outside this function.
 469
 470   TryCastResult tcr;
 471
 472   // C++ 5.2.9p5, reference downcast.
 473   // See the function for details.
 474   // DR 427 specifies that this is to be applied before paragraph 2.
 475   tcr = TryStaticReferenceDowncast(Self, SrcExpr, DestType, CStyle, OpRange,
 476                                    msg, Kind);
 477   if (tcr != TC_NotApplicable)
 478     return tcr;
 479
 480   // N2844 5.2.9p3: An lvalue of type "cv1 T1" can be cast to type "rvalue
 481   //   reference to cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1".
 482   tcr = TryLValueToRValueCast(Self, SrcExpr, DestType, msg);
 483   if (tcr != TC_NotApplicable) {
 484     Kind = CastExpr::CK_NoOp;
 485     return tcr;
 486   }
 487
 488   // C++ 5.2.9p2: An expression e can be explicitly converted to a type T
 489   //   [...] if the declaration "T t(e);" is well-formed, [...].
 490   tcr = TryStaticImplicitCast(Self, SrcExpr, DestType, CStyle, OpRange, msg,
 491                               Kind, ConversionDecl);
 492   if (tcr != TC_NotApplicable)
 493     return tcr;
 494
 495   // C++ 5.2.9p6: May apply the reverse of any standard conversion, except
 496   // lvalue-to-rvalue, array-to-pointer, function-to-pointer, and boolean
 497   // conversions, subject to further restrictions.
 498   // Also, C++ 5.2.9p1 forbids casting away constness, which makes reversal
 499   // of qualification conversions impossible.
 500   // In the CStyle case, the earlier attempt to const_cast should have taken
 501   // care of reverse qualification conversions.
 502
 503   QualType OrigSrcType = SrcExpr->getType();
 504
 505   QualType SrcType = Self.Context.getCanonicalType(SrcExpr->getType());
 506
 507   // Reverse integral promotion/conversion. All such conversions are themselves
 508   // again integral promotions or conversions and are thus already handled by
 509   // p2 (TryDirectInitialization above).
 510   // (Note: any data loss warnings should be suppressed.)
 511   // The exception is the reverse of enum->integer, i.e. integer->enum (and
 512   // enum->enum). See also C++ 5.2.9p7.
 513   // The same goes for reverse floating point promotion/conversion and
 514   // floating-integral conversions. Again, only floating->enum is relevant.
 515   if (DestType->isEnumeralType()) {
 516     if (SrcType->isComplexType() || SrcType->isVectorType()) {
 517       // Fall through - these cannot be converted.
 518     } else if (SrcType->isArithmeticType() || SrcType->isEnumeralType()) {
 519       Kind = CastExpr::CK_IntegralCast;
 520       return TC_Success;
 521     }
 522   }
 523
 524   // Reverse pointer upcast. C++ 4.10p3 specifies pointer upcast.
 525   // C++ 5.2.9p8 additionally disallows a cast path through virtual inheritance.
 526   tcr = TryStaticPointerDowncast(Self, SrcType, DestType, CStyle, OpRange, msg,
 527                                  Kind);
 528   if (tcr != TC_NotApplicable)
 529     return tcr;
 530
 531   // Reverse member pointer conversion. C++ 4.11 specifies member pointer
 532   // conversion. C++ 5.2.9p9 has additional information.
 533   // DR54's access restrictions apply here also.
 534   tcr = TryStaticMemberPointerUpcast(Self, SrcType, DestType, CStyle,
 535                                      OpRange, msg, Kind);
 536   if (tcr != TC_NotApplicable)
 537     return tcr;
 538
 539   // Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to
 540   // void*. C++ 5.2.9p10 specifies additional restrictions, which really is
 541   // just the usual constness stuff.
 542   if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) {
 543     QualType SrcPointee = SrcPointer->getPointeeType();
 544     if (SrcPointee->isVoidType()) {
 545       if (const PointerType *DestPointer = DestType->getAs<PointerType>()) {
 546         QualType DestPointee = DestPointer->getPointeeType();
 547         if (DestPointee->isIncompleteOrObjectType()) {
 548           // This is definitely the intended conversion, but it might fail due
 549           // to a const violation.
 550           if (!CStyle && !DestPointee.isAtLeastAsQualifiedAs(SrcPointee)) {
 551             msg = diag::err_bad_cxx_cast_const_away;
 552             return TC_Failed;
 553           }
 554           Kind = CastExpr::CK_BitCast;
 555           return TC_Success;
 556         }
 557       }
 558       else if (CStyle && DestType->isObjCObjectPointerType()) {
 559         // allow c-style cast of objective-c pointers as they are pervasive.
 560         Kind = CastExpr::CK_AnyPointerToObjCPointerCast;
 561         return TC_Success;
 562       }
 563       else if (CStyle && DestType->isBlockPointerType()) {
 564         // allow c-style cast of void * to block pointers.
 565         Kind = CastExpr::CK_AnyPointerToBlockPointerCast;
 566         return TC_Success;
 567       }
 568     }
 569   }
 570
 571   // We tried everything. Everything! Nothing works! :-(
 572   return TC_NotApplicable;
 573 }
 574
 575 /// Tests whether a conversion according to N2844 is valid.
 576 TryCastResult
 577 TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, QualType DestType,
 578                       unsigned &msg) {
 579   // N2844 5.2.9p3: An lvalue of type "cv1 T1" can be cast to type "rvalue
 580   //   reference to cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1".
 581   const RValueReferenceType *R = DestType->getAs<RValueReferenceType>();
 582   if (!R)
 583     return TC_NotApplicable;
 584
 585   if (SrcExpr->isLvalue(Self.Context) != Expr::LV_Valid)
 586     return TC_NotApplicable;
 587
 588   // Because we try the reference downcast before this function, from now on
 589   // this is the only cast possibility, so we issue an error if we fail now.
 590   // FIXME: Should allow casting away constness if CStyle.
 591   bool DerivedToBase;
 592   if (Self.CompareReferenceRelationship(SrcExpr->getLocStart(),
 593                                         SrcExpr->getType(), R->getPointeeType(),
 594                                         DerivedToBase) <
 595         Sema::Ref_Compatible_With_Added_Qualification) {
 596     msg = diag::err_bad_lvalue_to_rvalue_cast;
 597     return TC_Failed;
 598   }
 599
 600   // FIXME: Similar to CheckReferenceInit, we actually need more AST annotation
 601   // than nothing.
 602   return TC_Success;
 603 }
 604
 605 /// Tests whether a conversion according to C++ 5.2.9p5 is valid.
 606 TryCastResult
 607 TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType,
 608                            bool CStyle, const SourceRange &OpRange,
 609                            unsigned &msg, CastExpr::CastKind &Kind) {
 610   // C++ 5.2.9p5: An lvalue of type "cv1 B", where B is a class type, can be
 611   //   cast to type "reference to cv2 D", where D is a class derived from B,
 612   //   if a valid standard conversion from "pointer to D" to "pointer to B"
 613   //   exists, cv2 >= cv1, and B is not a virtual base class of D.
 614   // In addition, DR54 clarifies that the base must be accessible in the
 615   // current context. Although the wording of DR54 only applies to the pointer
 616   // variant of this rule, the intent is clearly for it to apply to the this
 617   // conversion as well.
 618
 619   const ReferenceType *DestReference = DestType->getAs<ReferenceType>();
 620   if (!DestReference) {
 621     return TC_NotApplicable;
 622   }
 623   bool RValueRef = DestReference->isRValueReferenceType();
 624   if (!RValueRef && SrcExpr->isLvalue(Self.Context) != Expr::LV_Valid) {
 625     // We know the left side is an lvalue reference, so we can suggest a reason.
 626     msg = diag::err_bad_cxx_cast_rvalue;
 627     return TC_NotApplicable;
 628   }
 629
 630   QualType DestPointee = DestReference->getPointeeType();
 631
 632   return TryStaticDowncast(Self,
 633                            Self.Context.getCanonicalType(SrcExpr->getType()),
 634                            Self.Context.getCanonicalType(DestPointee), CStyle,
 635                            OpRange, SrcExpr->getType(), DestType, msg, Kind);
 636 }
 637
 638 /// Tests whether a conversion according to C++ 5.2.9p8 is valid.
 639 TryCastResult
 640 TryStaticPointerDowncast(Sema &Self, QualType SrcType, QualType DestType,
 641                          bool CStyle, const SourceRange &OpRange,
 642                          unsigned &msg, CastExpr::CastKind &Kind) {
 643   // C++ 5.2.9p8: An rvalue of type "pointer to cv1 B", where B is a class
 644   //   type, can be converted to an rvalue of type "pointer to cv2 D", where D
 645   //   is a class derived from B, if a valid standard conversion from "pointer
 646   //   to D" to "pointer to B" exists, cv2 >= cv1, and B is not a virtual base
 647   //   class of D.
 648   // In addition, DR54 clarifies that the base must be accessible in the
 649   // current context.
 650
 651   const PointerType *DestPointer = DestType->getAs<PointerType>();
 652   if (!DestPointer) {
 653     return TC_NotApplicable;
 654   }
 655
 656   const PointerType *SrcPointer = SrcType->getAs<PointerType>();
 657   if (!SrcPointer) {
 658     msg = diag::err_bad_static_cast_pointer_nonpointer;
 659     return TC_NotApplicable;
 660   }
 661
 662   return TryStaticDowncast(Self,
 663                    Self.Context.getCanonicalType(SrcPointer->getPointeeType()),
 664                   Self.Context.getCanonicalType(DestPointer->getPointeeType()),
 665                            CStyle, OpRange, SrcType, DestType, msg, Kind);
 666 }
 667
 668 /// TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and
 669 /// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to
 670 /// DestType is possible and allowed.
 671 TryCastResult
 672 TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType,
 673                   bool CStyle, const SourceRange &OpRange, QualType OrigSrcType,
 674                   QualType OrigDestType, unsigned &msg,
 675                   CastExpr::CastKind &Kind) {
 676   // We can only work with complete types. But don't complain if it doesn't work
 677   if (Self.RequireCompleteType(OpRange.getBegin(), SrcType, PDiag(0)) ||
 678       Self.RequireCompleteType(OpRange.getBegin(), DestType, PDiag(0)))
 679     return TC_NotApplicable;
 680
 681   // Downcast can only happen in class hierarchies, so we need classes.
 682   if (!DestType->getAs<RecordType>() || !SrcType->getAs<RecordType>()) {
 683     return TC_NotApplicable;
 684   }
 685
 686   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/!CStyle,
 687                      /*DetectVirtual=*/true);
 688   if (!Self.IsDerivedFrom(DestType, SrcType, Paths)) {
 689     return TC_NotApplicable;
 690   }
 691
 692   // Target type does derive from source type. Now we're serious. If an error
 693   // appears now, it's not ignored.
 694   // This may not be entirely in line with the standard. Take for example:
 695   // struct A {};
 696   // struct B : virtual A {
 697   //   B(A&);
 698   // };
 699   //
 700   // void f()
 701   // {
 702   //   (void)static_cast<const B&>(*((A*)0));
 703   // }
 704   // As far as the standard is concerned, p5 does not apply (A is virtual), so
 705   // p2 should be used instead - "const B& t(*((A*)0));" is perfectly valid.
 706   // However, both GCC and Comeau reject this example, and accepting it would
 707   // mean more complex code if we're to preserve the nice error message.
 708   // FIXME: Being 100% compliant here would be nice to have.
 709
 710   // Must preserve cv, as always, unless we're in C-style mode.
 711   if (!CStyle && !DestType.isAtLeastAsQualifiedAs(SrcType)) {
 712     msg = diag::err_bad_cxx_cast_const_away;
 713     return TC_Failed;
 714   }
 715
 716   if (Paths.isAmbiguous(SrcType.getUnqualifiedType())) {
 717     // This code is analoguous to that in CheckDerivedToBaseConversion, except
 718     // that it builds the paths in reverse order.
 719     // To sum up: record all paths to the base and build a nice string from
 720     // them. Use it to spice up the error message.
 721     if (!Paths.isRecordingPaths()) {
 722       Paths.clear();
 723       Paths.setRecordingPaths(true);
 724       Self.IsDerivedFrom(DestType, SrcType, Paths);
 725     }
 726     std::string PathDisplayStr;
 727     std::set<unsigned> DisplayedPaths;
 728     for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end();
 729          PI != PE; ++PI) {
 730       if (DisplayedPaths.insert(PI->back().SubobjectNumber).second) {
 731         // We haven't displayed a path to this particular base
 732         // class subobject yet.
 733         PathDisplayStr += "\n    ";
 734         for (CXXBasePath::const_reverse_iterator EI = PI->rbegin(),
 735                                                  EE = PI->rend();
 736              EI != EE; ++EI)
 737           PathDisplayStr += EI->Base->getType().getAsString() + " -> ";
 738         PathDisplayStr += QualType(DestType).getAsString();
 739       }
 740     }
 741
 742     Self.Diag(OpRange.getBegin(), diag::err_ambiguous_base_to_derived_cast)
 743       << QualType(SrcType).getUnqualifiedType()
 744       << QualType(DestType).getUnqualifiedType()
 745       << PathDisplayStr << OpRange;
 746     msg = 0;
 747     return TC_Failed;
 748   }
 749
 750   if (Paths.getDetectedVirtual() != 0) {
 751     QualType VirtualBase(Paths.getDetectedVirtual(), 0);
 752     Self.Diag(OpRange.getBegin(), diag::err_static_downcast_via_virtual)
 753       << OrigSrcType << OrigDestType << VirtualBase << OpRange;
 754     msg = 0;
 755     return TC_Failed;
 756   }
 757
 758   if (!CStyle && Self.CheckBaseClassAccess(DestType, SrcType,
 759                           diag::err_downcast_from_inaccessible_base, Paths,
 760                           OpRange.getBegin(), DeclarationName())) {
 761     msg = 0;
 762     return TC_Failed;
 763   }
 764
 765   Kind = CastExpr::CK_BaseToDerived;
 766   return TC_Success;
 767 }
 768
 769 /// TryStaticMemberPointerUpcast - Tests whether a conversion according to
 770 /// C++ 5.2.9p9 is valid:
 771 ///
 772 ///   An rvalue of type "pointer to member of D of type cv1 T" can be
 773 ///   converted to an rvalue of type "pointer to member of B of type cv2 T",
 774 ///   where B is a base class of D [...].
 775 ///
 776 TryCastResult
 777 TryStaticMemberPointerUpcast(Sema &Self, QualType SrcType, QualType DestType,
 778                              bool CStyle, const SourceRange &OpRange,
 779                              unsigned &msg, CastExpr::CastKind &Kind) {
 780   const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>();
 781   if (!DestMemPtr)
 782     return TC_NotApplicable;
 783   const MemberPointerType *SrcMemPtr = SrcType->getAs<MemberPointerType>();
 784   if (!SrcMemPtr) {
 785     msg = diag::err_bad_static_cast_member_pointer_nonmp;
 786     return TC_NotApplicable;
 787   }
 788
 789   // T == T, modulo cv
 790   if (!Self.Context.hasSameUnqualifiedType(SrcMemPtr->getPointeeType(),
 791                                            DestMemPtr->getPointeeType()))
 792     return TC_NotApplicable;
 793
 794   // B base of D
 795   QualType SrcClass(SrcMemPtr->getClass(), 0);
 796   QualType DestClass(DestMemPtr->getClass(), 0);
 797   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/!CStyle,
 798                   /*DetectVirtual=*/true);
 799   if (!Self.IsDerivedFrom(SrcClass, DestClass, Paths)) {
 800     return TC_NotApplicable;
 801   }
 802
 803   // B is a base of D. But is it an allowed base? If not, it's a hard error.
 804   if (Paths.isAmbiguous(DestClass)) {
 805     Paths.clear();
 806     Paths.setRecordingPaths(true);
 807     bool StillOkay = Self.IsDerivedFrom(SrcClass, DestClass, Paths);
 808     assert(StillOkay);
 809     StillOkay = StillOkay;
 810     std::string PathDisplayStr = Self.getAmbiguousPathsDisplayString(Paths);
 811     Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv)
 812       << 1 << SrcClass << DestClass << PathDisplayStr << OpRange;
 813     msg = 0;
 814     return TC_Failed;
 815   }
 816
 817   if (const RecordType *VBase = Paths.getDetectedVirtual()) {
 818     Self.Diag(OpRange.getBegin(), diag::err_memptr_conv_via_virtual)
 819       << SrcClass << DestClass << QualType(VBase, 0) << OpRange;
 820     msg = 0;
 821     return TC_Failed;
 822   }
 823
 824   if (!CStyle && Self.CheckBaseClassAccess(DestType, SrcType,
 825                           diag::err_downcast_from_inaccessible_base, Paths,
 826                           OpRange.getBegin(), DeclarationName())) {
 827     msg = 0;
 828     return TC_Failed;
 829   }
 830
 831   Kind = CastExpr::CK_DerivedToBaseMemberPointer;
 832   return TC_Success;
 833 }
 834
 835 /// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2
 836 /// is valid:
 837 ///
 838 ///   An expression e can be explicitly converted to a type T using a
 839 ///   @c static_cast if the declaration "T t(e);" is well-formed [...].
 840 TryCastResult
 841 TryStaticImplicitCast(Sema &Self, Expr *&SrcExpr, QualType DestType,
 842                       bool CStyle, const SourceRange &OpRange, unsigned &msg,
 843                       CastExpr::CastKind &Kind,
 844                       CXXMethodDecl *&ConversionDecl) {
 845   if (DestType->isRecordType()) {
 846     if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
 847                                  diag::err_bad_dynamic_cast_incomplete)) {
 848       msg = 0;
 849       return TC_Failed;
 850     }
 851   }
 852
 853   if (DestType->isReferenceType()) {
 854     // All reference bindings insert implicit casts above that do the actual
 855     // casting.
 856     Kind = CastExpr::CK_NoOp;
 857
 858     // At this point of CheckStaticCast, if the destination is a reference,
 859     // this has to work. There is no other way that works.
 860     // On the other hand, if we're checking a C-style cast, we've still got
 861     // the reinterpret_cast way. So in C-style mode, we first try the call
 862     // with an ICS to suppress errors.
 863     if (CStyle) {
 864       ImplicitConversionSequence ICS;
 865       if(Self.CheckReferenceInit(SrcExpr, DestType, OpRange.getBegin(),
 866                                  /*SuppressUserConversions=*/false,
 867                                  /*AllowExplicit=*/false, /*ForceRValue=*/false,
 868                                  &ICS))
 869         return TC_NotApplicable;
 870     }
 871     // Now we're committed either way.
 872     if(!Self.CheckReferenceInit(SrcExpr, DestType, OpRange.getBegin(),
 873                                 /*SuppressUserConversions=*/false,
 874                                 /*AllowExplicit=*/false,
 875                                 /*ForceRValue=*/false, 0,
 876                                 /*IgnoreBaseAccess=*/CStyle))
 877       return TC_Success;
 878
 879     // We already got an error message.
 880     msg = 0;
 881     return TC_Failed;
 882   }
 883
 884   if (DestType->isRecordType()) {
 885     if (CXXConstructorDecl *Constructor
 886           = Self.TryInitializationByConstructor(DestType, &SrcExpr, 1,
 887                                                 OpRange.getBegin(),
 888               InitializationKind::CreateDirect(OpRange.getBegin(),
 889                                                OpRange.getBegin(),
 890                                                OpRange.getEnd()))) {
 891       ConversionDecl = Constructor;
 892       Kind = CastExpr::CK_ConstructorConversion;
 893       return TC_Success;
 894     }
 895
 896     return TC_NotApplicable;
 897   }
 898
 899   // FIXME: To get a proper error from invalid conversions here, we need to
 900   // reimplement more of this.
 901   // FIXME: This does not actually perform the conversion, and thus does not
 902   // check for ambiguity or access.
 903   ImplicitConversionSequence ICS =
 904     Self.TryImplicitConversion(SrcExpr, DestType,
 905                                /*SuppressUserConversions=*/false,
 906                                /*AllowExplicit=*/true,
 907                                /*ForceRValue=*/false,
 908                                /*InOverloadResolution=*/false,
 909                                /*one of user provided casts*/true);
 910
 911   if (ICS.isBad())
 912     return TC_NotApplicable;
 913
 914   // The conversion is possible, so commit to it.
 915   Kind = CastExpr::CK_NoOp;
 916   msg = 0;
 917   return Self.PerformImplicitConversion(SrcExpr, DestType, ICS, Sema::AA_Casting,
 918                                         /*IgnoreBaseAccess*/CStyle) ?
 919       TC_Failed : TC_Success;
 920 }
 921
 922 /// TryConstCast - See if a const_cast from source to destination is allowed,
 923 /// and perform it if it is.
 924 static TryCastResult TryConstCast(Sema &Self, Expr *SrcExpr, QualType DestType,
 925                                   bool CStyle, unsigned &msg) {
 926   DestType = Self.Context.getCanonicalType(DestType);
 927   QualType SrcType = SrcExpr->getType();
 928   if (const LValueReferenceType *DestTypeTmp =
 929         DestType->getAs<LValueReferenceType>()) {
 930     if (SrcExpr->isLvalue(Self.Context) != Expr::LV_Valid) {
 931       // Cannot const_cast non-lvalue to lvalue reference type. But if this
 932       // is C-style, static_cast might find a way, so we simply suggest a
 933       // message and tell the parent to keep searching.
 934       msg = diag::err_bad_cxx_cast_rvalue;
 935       return TC_NotApplicable;
 936     }
 937
 938     // C++ 5.2.11p4: An lvalue of type T1 can be [cast] to an lvalue of type T2
 939     //   [...] if a pointer to T1 can be [cast] to the type pointer to T2.
 940     DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType());
 941     SrcType = Self.Context.getPointerType(SrcType);
 942   }
 943
 944   // C++ 5.2.11p5: For a const_cast involving pointers to data members [...]
 945   //   the rules for const_cast are the same as those used for pointers.
 946
 947   if (!DestType->isPointerType() && !DestType->isMemberPointerType()) {
 948     // Cannot cast to non-pointer, non-reference type. Note that, if DestType
 949     // was a reference type, we converted it to a pointer above.
 950     // The status of rvalue references isn't entirely clear, but it looks like
 951     // conversion to them is simply invalid.
 952     // C++ 5.2.11p3: For two pointer types [...]
 953     if (!CStyle)
 954       msg = diag::err_bad_const_cast_dest;
 955     return TC_NotApplicable;
 956   }
 957   if (DestType->isFunctionPointerType() ||
 958       DestType->isMemberFunctionPointerType()) {
 959     // Cannot cast direct function pointers.
 960     // C++ 5.2.11p2: [...] where T is any object type or the void type [...]
 961     // T is the ultimate pointee of source and target type.
 962     if (!CStyle)
 963       msg = diag::err_bad_const_cast_dest;
 964     return TC_NotApplicable;
 965   }
 966   SrcType = Self.Context.getCanonicalType(SrcType);
 967
 968   // Unwrap the pointers. Ignore qualifiers. Terminate early if the types are
 969   // completely equal.
 970   // FIXME: const_cast should probably not be able to convert between pointers
 971   // to different address spaces.
 972   // C++ 5.2.11p3 describes the core semantics of const_cast. All cv specifiers
 973   // in multi-level pointers may change, but the level count must be the same,
 974   // as must be the final pointee type.
 975   while (SrcType != DestType &&
 976          Self.UnwrapSimilarPointerTypes(SrcType, DestType)) {
 977     Qualifiers Quals;
 978     SrcType = Self.Context.getUnqualifiedArrayType(SrcType, Quals);
 979     DestType = Self.Context.getUnqualifiedArrayType(DestType, Quals);
 980   }
 981
 982   // Since we're dealing in canonical types, the remainder must be the same.
 983   if (SrcType != DestType)
 984     return TC_NotApplicable;
 985
 986   return TC_Success;
 987 }
 988
 989 static TryCastResult TryReinterpretCast(Sema &Self, Expr *SrcExpr,
 990                                         QualType DestType, bool CStyle,
 991                                         const SourceRange &OpRange,
 992                                         unsigned &msg,
 993                                         CastExpr::CastKind &Kind) {
 994   DestType = Self.Context.getCanonicalType(DestType);
 995   QualType SrcType = SrcExpr->getType();
 996   if (const ReferenceType *DestTypeTmp = DestType->getAs<ReferenceType>()) {
 997     bool LValue = DestTypeTmp->isLValueReferenceType();
 998     if (LValue && SrcExpr->isLvalue(Self.Context) != Expr::LV_Valid) {
 999       // Cannot cast non-lvalue to reference type. See the similar comment in
1000       // const_cast.
1001       msg = diag::err_bad_cxx_cast_rvalue;
1002       return TC_NotApplicable;
1003     }
1004
1005     // C++ 5.2.10p10: [...] a reference cast reinterpret_cast<T&>(x) has the
1006     //   same effect as the conversion *reinterpret_cast<T*>(&x) with the
1007     //   built-in & and * operators.
1008     // This code does this transformation for the checked types.
1009     DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType());
1010     SrcType = Self.Context.getPointerType(SrcType);
1011   }
1012
1013   // Canonicalize source for comparison.
1014   SrcType = Self.Context.getCanonicalType(SrcType);
1015
1016   const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>(),
1017                           *SrcMemPtr = SrcType->getAs<MemberPointerType>();
1018   if (DestMemPtr && SrcMemPtr) {
1019     // C++ 5.2.10p9: An rvalue of type "pointer to member of X of type T1"
1020     //   can be explicitly converted to an rvalue of type "pointer to member
1021     //   of Y of type T2" if T1 and T2 are both function types or both object
1022     //   types.
1023     if (DestMemPtr->getPointeeType()->isFunctionType() !=
1024         SrcMemPtr->getPointeeType()->isFunctionType())
1025       return TC_NotApplicable;
1026
1027     // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away
1028     //   constness.
1029     // A reinterpret_cast followed by a const_cast can, though, so in C-style,
1030     // we accept it.
1031     if (!CStyle && CastsAwayConstness(Self, SrcType, DestType)) {
1032       msg = diag::err_bad_cxx_cast_const_away;
1033       return TC_Failed;
1034     }
1035
1036     // A valid member pointer cast.
1037     Kind = CastExpr::CK_BitCast;
1038     return TC_Success;
1039   }
1040
1041   // See below for the enumeral issue.
1042   if (SrcType->isNullPtrType() && DestType->isIntegralType() &&
1043       !DestType->isEnumeralType()) {
1044     // C++0x 5.2.10p4: A pointer can be explicitly converted to any integral
1045     //   type large enough to hold it. A value of std::nullptr_t can be
1046     //   converted to an integral type; the conversion has the same meaning
1047     //   and validity as a conversion of (void*)0 to the integral type.
1048     if (Self.Context.getTypeSize(SrcType) >
1049         Self.Context.getTypeSize(DestType)) {
1050       msg = diag::err_bad_reinterpret_cast_small_int;
1051       return TC_Failed;
1052     }
1053     Kind = CastExpr::CK_PointerToIntegral;
1054     return TC_Success;
1055   }
1056
1057   bool destIsVector = DestType->isVectorType();
1058   bool srcIsVector = SrcType->isVectorType();
1059   if (srcIsVector || destIsVector) {
1060     bool srcIsScalar = SrcType->isIntegralType() && !SrcType->isEnumeralType();
1061     bool destIsScalar =
1062       DestType->isIntegralType() && !DestType->isEnumeralType();
1063
1064     // Check if this is a cast between a vector and something else.
1065     if (!(srcIsScalar && destIsVector) && !(srcIsVector && destIsScalar) &&
1066         !(srcIsVector && destIsVector))
1067       return TC_NotApplicable;
1068
1069     // If both types have the same size, we can successfully cast.
1070     if (Self.Context.getTypeSize(SrcType)
1071           == Self.Context.getTypeSize(DestType)) {
1072       Kind = CastExpr::CK_BitCast;
1073       return TC_Success;
1074     }
1075
1076     if (destIsScalar)
1077       msg = diag::err_bad_cxx_cast_vector_to_scalar_different_size;
1078     else if (srcIsScalar)
1079       msg = diag::err_bad_cxx_cast_scalar_to_vector_different_size;
1080     else
1081       msg = diag::err_bad_cxx_cast_vector_to_vector_different_size;
1082
1083     return TC_Failed;
1084   }
1085
1086   bool destIsPtr =
1087     CStyle? DestType->isAnyPointerType() : DestType->isPointerType();
1088   bool srcIsPtr =
1089     CStyle ? SrcType->isAnyPointerType() : SrcType->isPointerType();
1090   if (!destIsPtr && !srcIsPtr) {
1091     // Except for std::nullptr_t->integer and lvalue->reference, which are
1092     // handled above, at least one of the two arguments must be a pointer.
1093     return TC_NotApplicable;
1094   }
1095
1096   if (SrcType == DestType) {
1097     // C++ 5.2.10p2 has a note that mentions that, subject to all other
1098     // restrictions, a cast to the same type is allowed. The intent is not
1099     // entirely clear here, since all other paragraphs explicitly forbid casts
1100     // to the same type. However, the behavior of compilers is pretty consistent
1101     // on this point: allow same-type conversion if the involved types are
1102     // pointers, disallow otherwise.
1103     Kind = CastExpr::CK_NoOp;
1104     return TC_Success;
1105   }
1106
1107   // Note: Clang treats enumeration types as integral types. If this is ever
1108   // changed for C++, the additional check here will be redundant.
1109   if (DestType->isIntegralType() && !DestType->isEnumeralType()) {
1110     assert(srcIsPtr && "One type must be a pointer");
1111     // C++ 5.2.10p4: A pointer can be explicitly converted to any integral
1112     //   type large enough to hold it.
1113     if (Self.Context.getTypeSize(SrcType) >
1114         Self.Context.getTypeSize(DestType)) {
1115       msg = diag::err_bad_reinterpret_cast_small_int;
1116       return TC_Failed;
1117     }
1118     Kind = CastExpr::CK_PointerToIntegral;
1119     return TC_Success;
1120   }
1121
1122   if (SrcType->isIntegralType() || SrcType->isEnumeralType()) {
1123     assert(destIsPtr && "One type must be a pointer");
1124     // C++ 5.2.10p5: A value of integral or enumeration type can be explicitly
1125     //   converted to a pointer.
1126     Kind = CastExpr::CK_IntegralToPointer;
1127     return TC_Success;
1128   }
1129
1130   if (!destIsPtr || !srcIsPtr) {
1131     // With the valid non-pointer conversions out of the way, we can be even
1132     // more stringent.
1133     return TC_NotApplicable;
1134   }
1135
1136   // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away constness.
1137   // The C-style cast operator can.
1138   if (!CStyle && CastsAwayConstness(Self, SrcType, DestType)) {
1139     msg = diag::err_bad_cxx_cast_const_away;
1140     return TC_Failed;
1141   }
1142   if (CStyle && DestType->isObjCObjectPointerType()) {
1143     Kind = CastExpr::CK_AnyPointerToObjCPointerCast;
1144     return TC_Success;
1145   }
1146
1147   // Not casting away constness, so the only remaining check is for compatible
1148   // pointer categories.
1149   Kind = CastExpr::CK_BitCast;
1150
1151   if (SrcType->isFunctionPointerType()) {
1152     if (DestType->isFunctionPointerType()) {
1153       // C++ 5.2.10p6: A pointer to a function can be explicitly converted to
1154       // a pointer to a function of a different type.
1155       return TC_Success;
1156     }
1157
1158     // C++0x 5.2.10p8: Converting a pointer to a function into a pointer to
1159     //   an object type or vice versa is conditionally-supported.
1160     // Compilers support it in C++03 too, though, because it's necessary for
1161     // casting the return value of dlsym() and GetProcAddress().
1162     // FIXME: Conditionally-supported behavior should be configurable in the
1163     // TargetInfo or similar.
1164     if (!Self.getLangOptions().CPlusPlus0x)
1165       Self.Diag(OpRange.getBegin(), diag::ext_cast_fn_obj) << OpRange;
1166     return TC_Success;
1167   }
1168
1169   if (DestType->isFunctionPointerType()) {
1170     // See above.
1171     if (!Self.getLangOptions().CPlusPlus0x)
1172       Self.Diag(OpRange.getBegin(), diag::ext_cast_fn_obj) << OpRange;
1173     return TC_Success;
1174   }
1175
1176   // C++ 5.2.10p7: A pointer to an object can be explicitly converted to
1177   //   a pointer to an object of different type.
1178   // Void pointers are not specified, but supported by every compiler out there.
1179   // So we finish by allowing everything that remains - it's got to be two
1180   // object pointers.
1181   return TC_Success;
1182 }
1183
1184 bool Sema::CXXCheckCStyleCast(SourceRange R, QualType CastTy, Expr *&CastExpr,
1185                               CastExpr::CastKind &Kind, bool FunctionalStyle,
1186                               CXXMethodDecl *&ConversionDecl) {
1187   // This test is outside everything else because it's the only case where
1188   // a non-lvalue-reference target type does not lead to decay.
1189   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
1190   if (CastTy->isVoidType()) {
1191     Kind = CastExpr::CK_ToVoid;
1192     return false;
1193   }
1194
1195   // If the type is dependent, we won't do any other semantic analysis now.
1196   if (CastTy->isDependentType() || CastExpr->isTypeDependent())
1197     return false;
1198
1199   if (!CastTy->isLValueReferenceType() && !CastTy->isRecordType())
1200     DefaultFunctionArrayConversion(CastExpr);
1201
1202   // C++ [expr.cast]p5: The conversions performed by
1203   //   - a const_cast,
1204   //   - a static_cast,
1205   //   - a static_cast followed by a const_cast,
1206   //   - a reinterpret_cast, or
1207   //   - a reinterpret_cast followed by a const_cast,
1208   //   can be performed using the cast notation of explicit type conversion.
1209   //   [...] If a conversion can be interpreted in more than one of the ways
1210   //   listed above, the interpretation that appears first in the list is used,
1211   //   even if a cast resulting from that interpretation is ill-formed.
1212   // In plain language, this means trying a const_cast ...
1213   unsigned msg = diag::err_bad_cxx_cast_generic;
1214   TryCastResult tcr = TryConstCast(*this, CastExpr, CastTy, /*CStyle*/true,
1215                                    msg);
1216   if (tcr == TC_Success)
1217     Kind = CastExpr::CK_NoOp;
1218
1219   if (tcr == TC_NotApplicable) {
1220     // ... or if that is not possible, a static_cast, ignoring const, ...
1221     tcr = TryStaticCast(*this, CastExpr, CastTy, /*CStyle*/true, R, msg,
1222                         Kind, ConversionDecl);
1223     if (tcr == TC_NotApplicable) {
1224       // ... and finally a reinterpret_cast, ignoring const.
1225       tcr = TryReinterpretCast(*this, CastExpr, CastTy, /*CStyle*/true, R, msg,
1226                                Kind);
1227     }
1228   }
1229
1230   if (tcr != TC_Success && msg != 0)
1231     Diag(R.getBegin(), msg) << (FunctionalStyle ? CT_Functional : CT_CStyle)
1232       << CastExpr->getType() << CastTy << R;
1233
1234   return tcr != TC_Success;
1235 }