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