clang  3.8.0
SemaCast.cpp
Go to the documentation of this file.
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 
18 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/ExprCXX.h"
21 #include "clang/AST/ExprObjC.h"
22 #include "clang/AST/RecordLayout.h"
24 #include "clang/Basic/TargetInfo.h"
26 #include "llvm/ADT/SmallVector.h"
27 #include <set>
28 using namespace clang;
29 
30 
31 
33  TC_NotApplicable, ///< The cast method is not applicable.
34  TC_Success, ///< The cast method is appropriate and successful.
35  TC_Failed ///< The cast method is appropriate, but failed. A
36  ///< diagnostic has been emitted.
37 };
38 
39 enum CastType {
40  CT_Const, ///< const_cast
41  CT_Static, ///< static_cast
42  CT_Reinterpret, ///< reinterpret_cast
43  CT_Dynamic, ///< dynamic_cast
44  CT_CStyle, ///< (Type)expr
45  CT_Functional ///< Type(expr)
46 };
47 
48 namespace {
49  struct CastOperation {
50  CastOperation(Sema &S, QualType destType, ExprResult src)
51  : Self(S), SrcExpr(src), DestType(destType),
52  ResultType(destType.getNonLValueExprType(S.Context)),
53  ValueKind(Expr::getValueKindForType(destType)),
54  Kind(CK_Dependent), IsARCUnbridgedCast(false) {
55 
56  if (const BuiltinType *placeholder =
57  src.get()->getType()->getAsPlaceholderType()) {
58  PlaceholderKind = placeholder->getKind();
59  } else {
60  PlaceholderKind = (BuiltinType::Kind) 0;
61  }
62  }
63 
64  Sema &Self;
65  ExprResult SrcExpr;
66  QualType DestType;
67  QualType ResultType;
68  ExprValueKind ValueKind;
69  CastKind Kind;
70  BuiltinType::Kind PlaceholderKind;
71  CXXCastPath BasePath;
72  bool IsARCUnbridgedCast;
73 
74  SourceRange OpRange;
75  SourceRange DestRange;
76 
77  // Top-level semantics-checking routines.
78  void CheckConstCast();
79  void CheckReinterpretCast();
80  void CheckStaticCast();
81  void CheckDynamicCast();
82  void CheckCXXCStyleCast(bool FunctionalCast, bool ListInitialization);
83  void CheckCStyleCast();
84 
85  /// Complete an apparently-successful cast operation that yields
86  /// the given expression.
87  ExprResult complete(CastExpr *castExpr) {
88  // If this is an unbridged cast, wrap the result in an implicit
89  // cast that yields the unbridged-cast placeholder type.
90  if (IsARCUnbridgedCast) {
91  castExpr = ImplicitCastExpr::Create(Self.Context,
92  Self.Context.ARCUnbridgedCastTy,
93  CK_Dependent, castExpr, nullptr,
94  castExpr->getValueKind());
95  }
96  return castExpr;
97  }
98 
99  // Internal convenience methods.
100 
101  /// Try to handle the given placeholder expression kind. Return
102  /// true if the source expression has the appropriate placeholder
103  /// kind. A placeholder can only be claimed once.
104  bool claimPlaceholder(BuiltinType::Kind K) {
105  if (PlaceholderKind != K) return false;
106 
107  PlaceholderKind = (BuiltinType::Kind) 0;
108  return true;
109  }
110 
111  bool isPlaceholder() const {
112  return PlaceholderKind != 0;
113  }
114  bool isPlaceholder(BuiltinType::Kind K) const {
115  return PlaceholderKind == K;
116  }
117 
118  void checkCastAlign() {
119  Self.CheckCastAlign(SrcExpr.get(), DestType, OpRange);
120  }
121 
122  void checkObjCARCConversion(Sema::CheckedConversionKind CCK) {
123  assert(Self.getLangOpts().ObjCAutoRefCount);
124 
125  Expr *src = SrcExpr.get();
126  if (Self.CheckObjCARCConversion(OpRange, DestType, src, CCK) ==
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
156 static TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr,
157  QualType DestType, bool CStyle,
158  CastKind &Kind,
159  CXXCastPath &BasePath,
160  unsigned &msg);
161 static TryCastResult TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr,
162  QualType DestType, bool CStyle,
163  SourceRange OpRange,
164  unsigned &msg,
165  CastKind &Kind,
166  CXXCastPath &BasePath);
168  QualType DestType, bool CStyle,
169  SourceRange OpRange,
170  unsigned &msg,
171  CastKind &Kind,
172  CXXCastPath &BasePath);
173 static TryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType,
174  CanQualType DestType, bool CStyle,
175  SourceRange OpRange,
176  QualType OrigSrcType,
177  QualType OrigDestType, unsigned &msg,
178  CastKind &Kind,
179  CXXCastPath &BasePath);
181  QualType SrcType,
182  QualType DestType,bool CStyle,
183  SourceRange OpRange,
184  unsigned &msg,
185  CastKind &Kind,
186  CXXCastPath &BasePath);
187 
188 static TryCastResult TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr,
189  QualType DestType,
191  SourceRange OpRange,
192  unsigned &msg, CastKind &Kind,
193  bool ListInitialization);
194 static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr,
195  QualType DestType,
197  SourceRange OpRange,
198  unsigned &msg, CastKind &Kind,
199  CXXCastPath &BasePath,
200  bool ListInitialization);
201 static TryCastResult TryConstCast(Sema &Self, ExprResult &SrcExpr,
202  QualType DestType, bool CStyle,
203  unsigned &msg);
204 static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
205  QualType DestType, bool CStyle,
206  SourceRange OpRange,
207  unsigned &msg,
208  CastKind &Kind);
209 
210 
211 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
214  SourceLocation LAngleBracketLoc, Declarator &D,
215  SourceLocation RAngleBracketLoc,
216  SourceLocation LParenLoc, Expr *E,
217  SourceLocation RParenLoc) {
218 
219  assert(!D.isInvalidType());
220 
222  if (D.isInvalidType())
223  return ExprError();
224 
225  if (getLangOpts().CPlusPlus) {
226  // Check that there are no default arguments (C++ only).
228  }
229 
230  return BuildCXXNamedCast(OpLoc, Kind, TInfo, E,
231  SourceRange(LAngleBracketLoc, RAngleBracketLoc),
232  SourceRange(LParenLoc, RParenLoc));
233 }
234 
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.
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 
329  InitializationKind initKind
331  range, listInitialization)
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 
343  break;
344  }
345 
346  OverloadCandidateSet &candidates = sequence.getFailedCandidateSet();
347 
348  unsigned msg = 0;
350 
351  switch (sequence.getFailedOverloadResult()) {
352  case OR_Success: llvm_unreachable("successful failed overload");
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.
382 static 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.
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 =
436  *T2ObjCPtrType =
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.
485 static bool
486 CastsAwayConstness(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 ObjC mode, there's nothing to check.
493  if (!CheckCVR && CheckObjCLifetime &&
494  !Self.Context.getLangOpts().ObjC1)
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);
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.
573 void 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 &&
687  Self.IsDerivedFrom(OpRange.getBegin(), SrcPointee, DestPointee)) {
688  if (Self.CheckDerivedToBaseConversion(SrcPointee, DestPointee,
689  OpRange.getBegin(), OpRange,
690  &BasePath)) {
691  SrcExpr = ExprError();
692  return;
693  }
694 
696  return;
697  }
698 
699  // C++ 5.2.7p6: Otherwise, v shall be [polymorphic].
700  const RecordDecl *SrcDecl = SrcRecord->getDecl()->getDefinition();
701  assert(SrcDecl && "Definition missing");
702  if (!cast<CXXRecordDecl>(SrcDecl)->isPolymorphic()) {
703  Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_polymorphic)
704  << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange();
705  SrcExpr = ExprError();
706  }
707 
708  // dynamic_cast is not available with -fno-rtti.
709  // As an exception, dynamic_cast to void* is available because it doesn't
710  // use RTTI.
711  if (!Self.getLangOpts().RTTI && !DestPointee->isVoidType()) {
712  Self.Diag(OpRange.getBegin(), diag::err_no_dynamic_cast_with_fno_rtti);
713  SrcExpr = ExprError();
714  return;
715  }
716 
717  // Done. Everything else is run-time checks.
718  Kind = CK_Dynamic;
719 }
720 
721 /// CheckConstCast - Check that a const_cast<DestType>(SrcExpr) is valid.
722 /// Refer to C++ 5.2.11 for details. const_cast is typically used in code
723 /// like this:
724 /// const char *str = "literal";
725 /// legacy_function(const_cast<char*>(str));
726 void CastOperation::CheckConstCast() {
727  if (ValueKind == VK_RValue)
728  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
729  else if (isPlaceholder())
730  SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get());
731  if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
732  return;
733 
734  unsigned msg = diag::err_bad_cxx_cast_generic;
735  if (TryConstCast(Self, SrcExpr, DestType, /*CStyle*/false, msg) != TC_Success
736  && msg != 0) {
737  Self.Diag(OpRange.getBegin(), msg) << CT_Const
738  << SrcExpr.get()->getType() << DestType << OpRange;
739  SrcExpr = ExprError();
740  }
741 }
742 
743 /// Check that a reinterpret_cast<DestType>(SrcExpr) is not used as upcast
744 /// or downcast between respective pointers or references.
745 static void DiagnoseReinterpretUpDownCast(Sema &Self, const Expr *SrcExpr,
746  QualType DestType,
747  SourceRange OpRange) {
748  QualType SrcType = SrcExpr->getType();
749  // When casting from pointer or reference, get pointee type; use original
750  // type otherwise.
751  const CXXRecordDecl *SrcPointeeRD = SrcType->getPointeeCXXRecordDecl();
752  const CXXRecordDecl *SrcRD =
753  SrcPointeeRD ? SrcPointeeRD : SrcType->getAsCXXRecordDecl();
754 
755  // Examining subobjects for records is only possible if the complete and
756  // valid definition is available. Also, template instantiation is not
757  // allowed here.
758  if (!SrcRD || !SrcRD->isCompleteDefinition() || SrcRD->isInvalidDecl())
759  return;
760 
761  const CXXRecordDecl *DestRD = DestType->getPointeeCXXRecordDecl();
762 
763  if (!DestRD || !DestRD->isCompleteDefinition() || DestRD->isInvalidDecl())
764  return;
765 
766  enum {
767  ReinterpretUpcast,
768  ReinterpretDowncast
769  } ReinterpretKind;
770 
771  CXXBasePaths BasePaths;
772 
773  if (SrcRD->isDerivedFrom(DestRD, BasePaths))
774  ReinterpretKind = ReinterpretUpcast;
775  else if (DestRD->isDerivedFrom(SrcRD, BasePaths))
776  ReinterpretKind = ReinterpretDowncast;
777  else
778  return;
779 
780  bool VirtualBase = true;
781  bool NonZeroOffset = false;
782  for (CXXBasePaths::const_paths_iterator I = BasePaths.begin(),
783  E = BasePaths.end();
784  I != E; ++I) {
785  const CXXBasePath &Path = *I;
787  bool IsVirtual = false;
788  for (CXXBasePath::const_iterator IElem = Path.begin(), EElem = Path.end();
789  IElem != EElem; ++IElem) {
790  IsVirtual = IElem->Base->isVirtual();
791  if (IsVirtual)
792  break;
793  const CXXRecordDecl *BaseRD = IElem->Base->getType()->getAsCXXRecordDecl();
794  assert(BaseRD && "Base type should be a valid unqualified class type");
795  // Don't check if any base has invalid declaration or has no definition
796  // since it has no layout info.
797  const CXXRecordDecl *Class = IElem->Class,
798  *ClassDefinition = Class->getDefinition();
799  if (Class->isInvalidDecl() || !ClassDefinition ||
800  !ClassDefinition->isCompleteDefinition())
801  return;
802 
803  const ASTRecordLayout &DerivedLayout =
804  Self.Context.getASTRecordLayout(Class);
805  Offset += DerivedLayout.getBaseClassOffset(BaseRD);
806  }
807  if (!IsVirtual) {
808  // Don't warn if any path is a non-virtually derived base at offset zero.
809  if (Offset.isZero())
810  return;
811  // Offset makes sense only for non-virtual bases.
812  else
813  NonZeroOffset = true;
814  }
815  VirtualBase = VirtualBase && IsVirtual;
816  }
817 
818  (void) NonZeroOffset; // Silence set but not used warning.
819  assert((VirtualBase || NonZeroOffset) &&
820  "Should have returned if has non-virtual base with zero offset");
821 
822  QualType BaseType =
823  ReinterpretKind == ReinterpretUpcast? DestType : SrcType;
824  QualType DerivedType =
825  ReinterpretKind == ReinterpretUpcast? SrcType : DestType;
826 
827  SourceLocation BeginLoc = OpRange.getBegin();
828  Self.Diag(BeginLoc, diag::warn_reinterpret_different_from_static)
829  << DerivedType << BaseType << !VirtualBase << int(ReinterpretKind)
830  << OpRange;
831  Self.Diag(BeginLoc, diag::note_reinterpret_updowncast_use_static)
832  << int(ReinterpretKind)
833  << FixItHint::CreateReplacement(BeginLoc, "static_cast");
834 }
835 
836 /// CheckReinterpretCast - Check that a reinterpret_cast<DestType>(SrcExpr) is
837 /// valid.
838 /// Refer to C++ 5.2.10 for details. reinterpret_cast is typically used in code
839 /// like this:
840 /// char *bytes = reinterpret_cast<char*>(int_ptr);
841 void CastOperation::CheckReinterpretCast() {
842  if (ValueKind == VK_RValue && !isPlaceholder(BuiltinType::Overload))
843  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
844  else
845  checkNonOverloadPlaceholders();
846  if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
847  return;
848 
849  unsigned msg = diag::err_bad_cxx_cast_generic;
850  TryCastResult tcr =
851  TryReinterpretCast(Self, SrcExpr, DestType,
852  /*CStyle*/false, OpRange, msg, Kind);
853  if (tcr != TC_Success && msg != 0)
854  {
855  if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
856  return;
857  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
858  //FIXME: &f<int>; is overloaded and resolvable
859  Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_overload)
860  << OverloadExpr::find(SrcExpr.get()).Expression->getName()
861  << DestType << OpRange;
862  Self.NoteAllOverloadCandidates(SrcExpr.get());
863 
864  } else {
865  diagnoseBadCast(Self, msg, CT_Reinterpret, OpRange, SrcExpr.get(),
866  DestType, /*listInitialization=*/false);
867  }
868  SrcExpr = ExprError();
869  } else if (tcr == TC_Success) {
870  if (Self.getLangOpts().ObjCAutoRefCount)
871  checkObjCARCConversion(Sema::CCK_OtherCast);
872  DiagnoseReinterpretUpDownCast(Self, SrcExpr.get(), DestType, OpRange);
873  }
874 }
875 
876 
877 /// CheckStaticCast - Check that a static_cast<DestType>(SrcExpr) is valid.
878 /// Refer to C++ 5.2.9 for details. Static casts are mostly used for making
879 /// implicit conversions explicit and getting rid of data loss warnings.
880 void CastOperation::CheckStaticCast() {
881  if (isPlaceholder()) {
882  checkNonOverloadPlaceholders();
883  if (SrcExpr.isInvalid())
884  return;
885  }
886 
887  // This test is outside everything else because it's the only case where
888  // a non-lvalue-reference target type does not lead to decay.
889  // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
890  if (DestType->isVoidType()) {
891  Kind = CK_ToVoid;
892 
893  if (claimPlaceholder(BuiltinType::Overload)) {
894  Self.ResolveAndFixSingleFunctionTemplateSpecialization(SrcExpr,
895  false, // Decay Function to ptr
896  true, // Complain
897  OpRange, DestType, diag::err_bad_static_cast_overload);
898  if (SrcExpr.isInvalid())
899  return;
900  }
901 
902  SrcExpr = Self.IgnoredValueConversions(SrcExpr.get());
903  return;
904  }
905 
906  if (ValueKind == VK_RValue && !DestType->isRecordType() &&
907  !isPlaceholder(BuiltinType::Overload)) {
908  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
909  if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
910  return;
911  }
912 
913  unsigned msg = diag::err_bad_cxx_cast_generic;
914  TryCastResult tcr
915  = TryStaticCast(Self, SrcExpr, DestType, Sema::CCK_OtherCast, OpRange, msg,
916  Kind, BasePath, /*ListInitialization=*/false);
917  if (tcr != TC_Success && msg != 0) {
918  if (SrcExpr.isInvalid())
919  return;
920  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
921  OverloadExpr* oe = OverloadExpr::find(SrcExpr.get()).Expression;
922  Self.Diag(OpRange.getBegin(), diag::err_bad_static_cast_overload)
923  << oe->getName() << DestType << OpRange
924  << oe->getQualifierLoc().getSourceRange();
925  Self.NoteAllOverloadCandidates(SrcExpr.get());
926  } else {
927  diagnoseBadCast(Self, msg, CT_Static, OpRange, SrcExpr.get(), DestType,
928  /*listInitialization=*/false);
929  }
930  SrcExpr = ExprError();
931  } else if (tcr == TC_Success) {
932  if (Kind == CK_BitCast)
933  checkCastAlign();
934  if (Self.getLangOpts().ObjCAutoRefCount)
935  checkObjCARCConversion(Sema::CCK_OtherCast);
936  } else if (Kind == CK_BitCast) {
937  checkCastAlign();
938  }
939 }
940 
941 /// TryStaticCast - Check if a static cast can be performed, and do so if
942 /// possible. If @p CStyle, ignore access restrictions on hierarchy casting
943 /// and casting away constness.
945  QualType DestType,
947  SourceRange OpRange, unsigned &msg,
948  CastKind &Kind, CXXCastPath &BasePath,
949  bool ListInitialization) {
950  // Determine whether we have the semantics of a C-style cast.
951  bool CStyle
952  = (CCK == Sema::CCK_CStyleCast || CCK == Sema::CCK_FunctionalCast);
953 
954  // The order the tests is not entirely arbitrary. There is one conversion
955  // that can be handled in two different ways. Given:
956  // struct A {};
957  // struct B : public A {
958  // B(); B(const A&);
959  // };
960  // const A &a = B();
961  // the cast static_cast<const B&>(a) could be seen as either a static
962  // reference downcast, or an explicit invocation of the user-defined
963  // conversion using B's conversion constructor.
964  // DR 427 specifies that the downcast is to be applied here.
965 
966  // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
967  // Done outside this function.
968 
969  TryCastResult tcr;
970 
971  // C++ 5.2.9p5, reference downcast.
972  // See the function for details.
973  // DR 427 specifies that this is to be applied before paragraph 2.
974  tcr = TryStaticReferenceDowncast(Self, SrcExpr.get(), DestType, CStyle,
975  OpRange, msg, Kind, BasePath);
976  if (tcr != TC_NotApplicable)
977  return tcr;
978 
979  // C++11 [expr.static.cast]p3:
980  // A glvalue of type "cv1 T1" can be cast to type "rvalue reference to cv2
981  // T2" if "cv2 T2" is reference-compatible with "cv1 T1".
982  tcr = TryLValueToRValueCast(Self, SrcExpr.get(), DestType, CStyle, Kind,
983  BasePath, msg);
984  if (tcr != TC_NotApplicable)
985  return tcr;
986 
987  // C++ 5.2.9p2: An expression e can be explicitly converted to a type T
988  // [...] if the declaration "T t(e);" is well-formed, [...].
989  tcr = TryStaticImplicitCast(Self, SrcExpr, DestType, CCK, OpRange, msg,
990  Kind, ListInitialization);
991  if (SrcExpr.isInvalid())
992  return TC_Failed;
993  if (tcr != TC_NotApplicable)
994  return tcr;
995 
996  // C++ 5.2.9p6: May apply the reverse of any standard conversion, except
997  // lvalue-to-rvalue, array-to-pointer, function-to-pointer, and boolean
998  // conversions, subject to further restrictions.
999  // Also, C++ 5.2.9p1 forbids casting away constness, which makes reversal
1000  // of qualification conversions impossible.
1001  // In the CStyle case, the earlier attempt to const_cast should have taken
1002  // care of reverse qualification conversions.
1003 
1004  QualType SrcType = Self.Context.getCanonicalType(SrcExpr.get()->getType());
1005 
1006  // C++0x 5.2.9p9: A value of a scoped enumeration type can be explicitly
1007  // converted to an integral type. [...] A value of a scoped enumeration type
1008  // can also be explicitly converted to a floating-point type [...].
1009  if (const EnumType *Enum = SrcType->getAs<EnumType>()) {
1010  if (Enum->getDecl()->isScoped()) {
1011  if (DestType->isBooleanType()) {
1012  Kind = CK_IntegralToBoolean;
1013  return TC_Success;
1014  } else if (DestType->isIntegralType(Self.Context)) {
1015  Kind = CK_IntegralCast;
1016  return TC_Success;
1017  } else if (DestType->isRealFloatingType()) {
1018  Kind = CK_IntegralToFloating;
1019  return TC_Success;
1020  }
1021  }
1022  }
1023 
1024  // Reverse integral promotion/conversion. All such conversions are themselves
1025  // again integral promotions or conversions and are thus already handled by
1026  // p2 (TryDirectInitialization above).
1027  // (Note: any data loss warnings should be suppressed.)
1028  // The exception is the reverse of enum->integer, i.e. integer->enum (and
1029  // enum->enum). See also C++ 5.2.9p7.
1030  // The same goes for reverse floating point promotion/conversion and
1031  // floating-integral conversions. Again, only floating->enum is relevant.
1032  if (DestType->isEnumeralType()) {
1033  if (SrcType->isIntegralOrEnumerationType()) {
1034  Kind = CK_IntegralCast;
1035  return TC_Success;
1036  } else if (SrcType->isRealFloatingType()) {
1037  Kind = CK_FloatingToIntegral;
1038  return TC_Success;
1039  }
1040  }
1041 
1042  // Reverse pointer upcast. C++ 4.10p3 specifies pointer upcast.
1043  // C++ 5.2.9p8 additionally disallows a cast path through virtual inheritance.
1044  tcr = TryStaticPointerDowncast(Self, SrcType, DestType, CStyle, OpRange, msg,
1045  Kind, BasePath);
1046  if (tcr != TC_NotApplicable)
1047  return tcr;
1048 
1049  // Reverse member pointer conversion. C++ 4.11 specifies member pointer
1050  // conversion. C++ 5.2.9p9 has additional information.
1051  // DR54's access restrictions apply here also.
1052  tcr = TryStaticMemberPointerUpcast(Self, SrcExpr, SrcType, DestType, CStyle,
1053  OpRange, msg, Kind, BasePath);
1054  if (tcr != TC_NotApplicable)
1055  return tcr;
1056 
1057  // Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to
1058  // void*. C++ 5.2.9p10 specifies additional restrictions, which really is
1059  // just the usual constness stuff.
1060  if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) {
1061  QualType SrcPointee = SrcPointer->getPointeeType();
1062  if (SrcPointee->isVoidType()) {
1063  if (const PointerType *DestPointer = DestType->getAs<PointerType>()) {
1064  QualType DestPointee = DestPointer->getPointeeType();
1065  if (DestPointee->isIncompleteOrObjectType()) {
1066  // This is definitely the intended conversion, but it might fail due
1067  // to a qualifier violation. Note that we permit Objective-C lifetime
1068  // and GC qualifier mismatches here.
1069  if (!CStyle) {
1070  Qualifiers DestPointeeQuals = DestPointee.getQualifiers();
1071  Qualifiers SrcPointeeQuals = SrcPointee.getQualifiers();
1072  DestPointeeQuals.removeObjCGCAttr();
1073  DestPointeeQuals.removeObjCLifetime();
1074  SrcPointeeQuals.removeObjCGCAttr();
1075  SrcPointeeQuals.removeObjCLifetime();
1076  if (DestPointeeQuals != SrcPointeeQuals &&
1077  !DestPointeeQuals.compatiblyIncludes(SrcPointeeQuals)) {
1078  msg = diag::err_bad_cxx_cast_qualifiers_away;
1079  return TC_Failed;
1080  }
1081  }
1082  Kind = CK_BitCast;
1083  return TC_Success;
1084  }
1085 
1086  // Microsoft permits static_cast from 'pointer-to-void' to
1087  // 'pointer-to-function'.
1088  if (!CStyle && Self.getLangOpts().MSVCCompat &&
1089  DestPointee->isFunctionType()) {
1090  Self.Diag(OpRange.getBegin(), diag::ext_ms_cast_fn_obj) << OpRange;
1091  Kind = CK_BitCast;
1092  return TC_Success;
1093  }
1094  }
1095  else if (DestType->isObjCObjectPointerType()) {
1096  // allow both c-style cast and static_cast of objective-c pointers as
1097  // they are pervasive.
1099  return TC_Success;
1100  }
1101  else if (CStyle && DestType->isBlockPointerType()) {
1102  // allow c-style cast of void * to block pointers.
1104  return TC_Success;
1105  }
1106  }
1107  }
1108  // Allow arbitray objective-c pointer conversion with static casts.
1109  if (SrcType->isObjCObjectPointerType() &&
1110  DestType->isObjCObjectPointerType()) {
1111  Kind = CK_BitCast;
1112  return TC_Success;
1113  }
1114  // Allow ns-pointer to cf-pointer conversion in either direction
1115  // with static casts.
1116  if (!CStyle &&
1117  Self.CheckTollFreeBridgeStaticCast(DestType, SrcExpr.get(), Kind))
1118  return TC_Success;
1119 
1120  // See if it looks like the user is trying to convert between
1121  // related record types, and select a better diagnostic if so.
1122  if (auto SrcPointer = SrcType->getAs<PointerType>())
1123  if (auto DestPointer = DestType->getAs<PointerType>())
1124  if (SrcPointer->getPointeeType()->getAs<RecordType>() &&
1125  DestPointer->getPointeeType()->getAs<RecordType>())
1126  msg = diag::err_bad_cxx_cast_unrelated_class;
1127 
1128  // We tried everything. Everything! Nothing works! :-(
1129  return TC_NotApplicable;
1130 }
1131 
1132 /// Tests whether a conversion according to N2844 is valid.
1134 TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, QualType DestType,
1135  bool CStyle, CastKind &Kind, CXXCastPath &BasePath,
1136  unsigned &msg) {
1137  // C++11 [expr.static.cast]p3:
1138  // A glvalue of type "cv1 T1" can be cast to type "rvalue reference to
1139  // cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1".
1140  const RValueReferenceType *R = DestType->getAs<RValueReferenceType>();
1141  if (!R)
1142  return TC_NotApplicable;
1143 
1144  if (!SrcExpr->isGLValue())
1145  return TC_NotApplicable;
1146 
1147  // Because we try the reference downcast before this function, from now on
1148  // this is the only cast possibility, so we issue an error if we fail now.
1149  // FIXME: Should allow casting away constness if CStyle.
1150  bool DerivedToBase;
1151  bool ObjCConversion;
1152  bool ObjCLifetimeConversion;
1153  QualType FromType = SrcExpr->getType();
1154  QualType ToType = R->getPointeeType();
1155  if (CStyle) {
1156  FromType = FromType.getUnqualifiedType();
1157  ToType = ToType.getUnqualifiedType();
1158  }
1159 
1160  if (Self.CompareReferenceRelationship(SrcExpr->getLocStart(),
1161  ToType, FromType,
1162  DerivedToBase, ObjCConversion,
1163  ObjCLifetimeConversion)
1165  if (CStyle)
1166  return TC_NotApplicable;
1167  msg = diag::err_bad_lvalue_to_rvalue_cast;
1168  return TC_Failed;
1169  }
1170 
1171  if (DerivedToBase) {
1172  Kind = CK_DerivedToBase;
1173  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1174  /*DetectVirtual=*/true);
1175  if (!Self.IsDerivedFrom(SrcExpr->getLocStart(), SrcExpr->getType(),
1176  R->getPointeeType(), Paths))
1177  return TC_NotApplicable;
1178 
1179  Self.BuildBasePathArray(Paths, BasePath);
1180  } else
1181  Kind = CK_NoOp;
1182 
1183  return TC_Success;
1184 }
1185 
1186 /// Tests whether a conversion according to C++ 5.2.9p5 is valid.
1188 TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType,
1189  bool CStyle, SourceRange OpRange,
1190  unsigned &msg, CastKind &Kind,
1191  CXXCastPath &BasePath) {
1192  // C++ 5.2.9p5: An lvalue of type "cv1 B", where B is a class type, can be
1193  // cast to type "reference to cv2 D", where D is a class derived from B,
1194  // if a valid standard conversion from "pointer to D" to "pointer to B"
1195  // exists, cv2 >= cv1, and B is not a virtual base class of D.
1196  // In addition, DR54 clarifies that the base must be accessible in the
1197  // current context. Although the wording of DR54 only applies to the pointer
1198  // variant of this rule, the intent is clearly for it to apply to the this
1199  // conversion as well.
1200 
1201  const ReferenceType *DestReference = DestType->getAs<ReferenceType>();
1202  if (!DestReference) {
1203  return TC_NotApplicable;
1204  }
1205  bool RValueRef = DestReference->isRValueReferenceType();
1206  if (!RValueRef && !SrcExpr->isLValue()) {
1207  // We know the left side is an lvalue reference, so we can suggest a reason.
1208  msg = diag::err_bad_cxx_cast_rvalue;
1209  return TC_NotApplicable;
1210  }
1211 
1212  QualType DestPointee = DestReference->getPointeeType();
1213 
1214  // FIXME: If the source is a prvalue, we should issue a warning (because the
1215  // cast always has undefined behavior), and for AST consistency, we should
1216  // materialize a temporary.
1217  return TryStaticDowncast(Self,
1218  Self.Context.getCanonicalType(SrcExpr->getType()),
1219  Self.Context.getCanonicalType(DestPointee), CStyle,
1220  OpRange, SrcExpr->getType(), DestType, msg, Kind,
1221  BasePath);
1222 }
1223 
1224 /// Tests whether a conversion according to C++ 5.2.9p8 is valid.
1227  bool CStyle, SourceRange OpRange,
1228  unsigned &msg, CastKind &Kind,
1229  CXXCastPath &BasePath) {
1230  // C++ 5.2.9p8: An rvalue of type "pointer to cv1 B", where B is a class
1231  // type, can be converted to an rvalue of type "pointer to cv2 D", where D
1232  // is a class derived from B, if a valid standard conversion from "pointer
1233  // to D" to "pointer to B" exists, cv2 >= cv1, and B is not a virtual base
1234  // class of D.
1235  // In addition, DR54 clarifies that the base must be accessible in the
1236  // current context.
1237 
1238  const PointerType *DestPointer = DestType->getAs<PointerType>();
1239  if (!DestPointer) {
1240  return TC_NotApplicable;
1241  }
1242 
1243  const PointerType *SrcPointer = SrcType->getAs<PointerType>();
1244  if (!SrcPointer) {
1245  msg = diag::err_bad_static_cast_pointer_nonpointer;
1246  return TC_NotApplicable;
1247  }
1248 
1249  return TryStaticDowncast(Self,
1250  Self.Context.getCanonicalType(SrcPointer->getPointeeType()),
1251  Self.Context.getCanonicalType(DestPointer->getPointeeType()),
1252  CStyle, OpRange, SrcType, DestType, msg, Kind,
1253  BasePath);
1254 }
1255 
1256 /// TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and
1257 /// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to
1258 /// DestType is possible and allowed.
1261  bool CStyle, SourceRange OpRange, QualType OrigSrcType,
1262  QualType OrigDestType, unsigned &msg,
1263  CastKind &Kind, CXXCastPath &BasePath) {
1264  // We can only work with complete types. But don't complain if it doesn't work
1265  if (!Self.isCompleteType(OpRange.getBegin(), SrcType) ||
1266  !Self.isCompleteType(OpRange.getBegin(), DestType))
1267  return TC_NotApplicable;
1268 
1269  // Downcast can only happen in class hierarchies, so we need classes.
1270  if (!DestType->getAs<RecordType>() || !SrcType->getAs<RecordType>()) {
1271  return TC_NotApplicable;
1272  }
1273 
1274  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1275  /*DetectVirtual=*/true);
1276  if (!Self.IsDerivedFrom(OpRange.getBegin(), DestType, SrcType, Paths)) {
1277  return TC_NotApplicable;
1278  }
1279 
1280  // Target type does derive from source type. Now we're serious. If an error
1281  // appears now, it's not ignored.
1282  // This may not be entirely in line with the standard. Take for example:
1283  // struct A {};
1284  // struct B : virtual A {
1285  // B(A&);
1286  // };
1287  //
1288  // void f()
1289  // {
1290  // (void)static_cast<const B&>(*((A*)0));
1291  // }
1292  // As far as the standard is concerned, p5 does not apply (A is virtual), so
1293  // p2 should be used instead - "const B& t(*((A*)0));" is perfectly valid.
1294  // However, both GCC and Comeau reject this example, and accepting it would
1295  // mean more complex code if we're to preserve the nice error message.
1296  // FIXME: Being 100% compliant here would be nice to have.
1297 
1298  // Must preserve cv, as always, unless we're in C-style mode.
1299  if (!CStyle && !DestType.isAtLeastAsQualifiedAs(SrcType)) {
1300  msg = diag::err_bad_cxx_cast_qualifiers_away;
1301  return TC_Failed;
1302  }
1303 
1304  if (Paths.isAmbiguous(SrcType.getUnqualifiedType())) {
1305  // This code is analoguous to that in CheckDerivedToBaseConversion, except
1306  // that it builds the paths in reverse order.
1307  // To sum up: record all paths to the base and build a nice string from
1308  // them. Use it to spice up the error message.
1309  if (!Paths.isRecordingPaths()) {
1310  Paths.clear();
1311  Paths.setRecordingPaths(true);
1312  Self.IsDerivedFrom(OpRange.getBegin(), DestType, SrcType, Paths);
1313  }
1314  std::string PathDisplayStr;
1315  std::set<unsigned> DisplayedPaths;
1316  for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end();
1317  PI != PE; ++PI) {
1318  if (DisplayedPaths.insert(PI->back().SubobjectNumber).second) {
1319  // We haven't displayed a path to this particular base
1320  // class subobject yet.
1321  PathDisplayStr += "\n ";
1322  for (CXXBasePath::const_reverse_iterator EI = PI->rbegin(),
1323  EE = PI->rend();
1324  EI != EE; ++EI)
1325  PathDisplayStr += EI->Base->getType().getAsString() + " -> ";
1326  PathDisplayStr += QualType(DestType).getAsString();
1327  }
1328  }
1329 
1330  Self.Diag(OpRange.getBegin(), diag::err_ambiguous_base_to_derived_cast)
1331  << QualType(SrcType).getUnqualifiedType()
1332  << QualType(DestType).getUnqualifiedType()
1333  << PathDisplayStr << OpRange;
1334  msg = 0;
1335  return TC_Failed;
1336  }
1337 
1338  if (Paths.getDetectedVirtual() != nullptr) {
1339  QualType VirtualBase(Paths.getDetectedVirtual(), 0);
1340  Self.Diag(OpRange.getBegin(), diag::err_static_downcast_via_virtual)
1341  << OrigSrcType << OrigDestType << VirtualBase << OpRange;
1342  msg = 0;
1343  return TC_Failed;
1344  }
1345 
1346  if (!CStyle) {
1347  switch (Self.CheckBaseClassAccess(OpRange.getBegin(),
1348  SrcType, DestType,
1349  Paths.front(),
1350  diag::err_downcast_from_inaccessible_base)) {
1351  case Sema::AR_accessible:
1352  case Sema::AR_delayed: // be optimistic
1353  case Sema::AR_dependent: // be optimistic
1354  break;
1355 
1356  case Sema::AR_inaccessible:
1357  msg = 0;
1358  return TC_Failed;
1359  }
1360  }
1361 
1362  Self.BuildBasePathArray(Paths, BasePath);
1363  Kind = CK_BaseToDerived;
1364  return TC_Success;
1365 }
1366 
1367 /// TryStaticMemberPointerUpcast - Tests whether a conversion according to
1368 /// C++ 5.2.9p9 is valid:
1369 ///
1370 /// An rvalue of type "pointer to member of D of type cv1 T" can be
1371 /// converted to an rvalue of type "pointer to member of B of type cv2 T",
1372 /// where B is a base class of D [...].
1373 ///
1376  QualType DestType, bool CStyle,
1377  SourceRange OpRange,
1378  unsigned &msg, CastKind &Kind,
1379  CXXCastPath &BasePath) {
1380  const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>();
1381  if (!DestMemPtr)
1382  return TC_NotApplicable;
1383 
1384  bool WasOverloadedFunction = false;
1385  DeclAccessPair FoundOverload;
1386  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
1387  if (FunctionDecl *Fn
1388  = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(), DestType, false,
1389  FoundOverload)) {
1390  CXXMethodDecl *M = cast<CXXMethodDecl>(Fn);
1391  SrcType = Self.Context.getMemberPointerType(Fn->getType(),
1392  Self.Context.getTypeDeclType(M->getParent()).getTypePtr());
1393  WasOverloadedFunction = true;
1394  }
1395  }
1396 
1397  const MemberPointerType *SrcMemPtr = SrcType->getAs<MemberPointerType>();
1398  if (!SrcMemPtr) {
1399  msg = diag::err_bad_static_cast_member_pointer_nonmp;
1400  return TC_NotApplicable;
1401  }
1402 
1403  // Lock down the inheritance model right now in MS ABI, whether or not the
1404  // pointee types are the same.
1405  if (Self.Context.getTargetInfo().getCXXABI().isMicrosoft())
1406  (void)Self.isCompleteType(OpRange.getBegin(), SrcType);
1407 
1408  // T == T, modulo cv
1409  if (!Self.Context.hasSameUnqualifiedType(SrcMemPtr->getPointeeType(),
1410  DestMemPtr->getPointeeType()))
1411  return TC_NotApplicable;
1412 
1413  // B base of D
1414  QualType SrcClass(SrcMemPtr->getClass(), 0);
1415  QualType DestClass(DestMemPtr->getClass(), 0);
1416  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1417  /*DetectVirtual=*/true);
1418  if (!Self.IsDerivedFrom(OpRange.getBegin(), SrcClass, DestClass, Paths))
1419  return TC_NotApplicable;
1420 
1421  // B is a base of D. But is it an allowed base? If not, it's a hard error.
1422  if (Paths.isAmbiguous(Self.Context.getCanonicalType(DestClass))) {
1423  Paths.clear();
1424  Paths.setRecordingPaths(true);
1425  bool StillOkay =
1426  Self.IsDerivedFrom(OpRange.getBegin(), SrcClass, DestClass, Paths);
1427  assert(StillOkay);
1428  (void)StillOkay;
1429  std::string PathDisplayStr = Self.getAmbiguousPathsDisplayString(Paths);
1430  Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv)
1431  << 1 << SrcClass << DestClass << PathDisplayStr << OpRange;
1432  msg = 0;
1433  return TC_Failed;
1434  }
1435 
1436  if (const RecordType *VBase = Paths.getDetectedVirtual()) {
1437  Self.Diag(OpRange.getBegin(), diag::err_memptr_conv_via_virtual)
1438  << SrcClass << DestClass << QualType(VBase, 0) << OpRange;
1439  msg = 0;
1440  return TC_Failed;
1441  }
1442 
1443  if (!CStyle) {
1444  switch (Self.CheckBaseClassAccess(OpRange.getBegin(),
1445  DestClass, SrcClass,
1446  Paths.front(),
1447  diag::err_upcast_to_inaccessible_base)) {
1448  case Sema::AR_accessible:
1449  case Sema::AR_delayed:
1450  case Sema::AR_dependent:
1451  // Optimistically assume that the delayed and dependent cases
1452  // will work out.
1453  break;
1454 
1455  case Sema::AR_inaccessible:
1456  msg = 0;
1457  return TC_Failed;
1458  }
1459  }
1460 
1461  if (WasOverloadedFunction) {
1462  // Resolve the address of the overloaded function again, this time
1463  // allowing complaints if something goes wrong.
1464  FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(),
1465  DestType,
1466  true,
1467  FoundOverload);
1468  if (!Fn) {
1469  msg = 0;
1470  return TC_Failed;
1471  }
1472 
1473  SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr, FoundOverload, Fn);
1474  if (!SrcExpr.isUsable()) {
1475  msg = 0;
1476  return TC_Failed;
1477  }
1478  }
1479 
1480  Self.BuildBasePathArray(Paths, BasePath);
1482  return TC_Success;
1483 }
1484 
1485 /// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2
1486 /// is valid:
1487 ///
1488 /// An expression e can be explicitly converted to a type T using a
1489 /// @c static_cast if the declaration "T t(e);" is well-formed [...].
1491 TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
1493  SourceRange OpRange, unsigned &msg,
1494  CastKind &Kind, bool ListInitialization) {
1495  if (DestType->isRecordType()) {
1496  if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
1497  diag::err_bad_dynamic_cast_incomplete) ||
1498  Self.RequireNonAbstractType(OpRange.getBegin(), DestType,
1499  diag::err_allocation_of_abstract_type)) {
1500  msg = 0;
1501  return TC_Failed;
1502  }
1503  }
1504 
1506  InitializationKind InitKind
1507  = (CCK == Sema::CCK_CStyleCast)
1508  ? InitializationKind::CreateCStyleCast(OpRange.getBegin(), OpRange,
1509  ListInitialization)
1510  : (CCK == Sema::CCK_FunctionalCast)
1511  ? InitializationKind::CreateFunctionalCast(OpRange, ListInitialization)
1512  : InitializationKind::CreateCast(OpRange);
1513  Expr *SrcExprRaw = SrcExpr.get();
1514  InitializationSequence InitSeq(Self, Entity, InitKind, SrcExprRaw);
1515 
1516  // At this point of CheckStaticCast, if the destination is a reference,
1517  // or the expression is an overload expression this has to work.
1518  // There is no other way that works.
1519  // On the other hand, if we're checking a C-style cast, we've still got
1520  // the reinterpret_cast way.
1521  bool CStyle
1522  = (CCK == Sema::CCK_CStyleCast || CCK == Sema::CCK_FunctionalCast);
1523  if (InitSeq.Failed() && (CStyle || !DestType->isReferenceType()))
1524  return TC_NotApplicable;
1525 
1526  ExprResult Result = InitSeq.Perform(Self, Entity, InitKind, SrcExprRaw);
1527  if (Result.isInvalid()) {
1528  msg = 0;
1529  return TC_Failed;
1530  }
1531 
1532  if (InitSeq.isConstructorInitialization())
1533  Kind = CK_ConstructorConversion;
1534  else
1535  Kind = CK_NoOp;
1536 
1537  SrcExpr = Result;
1538  return TC_Success;
1539 }
1540 
1541 /// TryConstCast - See if a const_cast from source to destination is allowed,
1542 /// and perform it if it is.
1544  QualType DestType, bool CStyle,
1545  unsigned &msg) {
1546  DestType = Self.Context.getCanonicalType(DestType);
1547  QualType SrcType = SrcExpr.get()->getType();
1548  bool NeedToMaterializeTemporary = false;
1549 
1550  if (const ReferenceType *DestTypeTmp =DestType->getAs<ReferenceType>()) {
1551  // C++11 5.2.11p4:
1552  // if a pointer to T1 can be explicitly converted to the type "pointer to
1553  // T2" using a const_cast, then the following conversions can also be
1554  // made:
1555  // -- an lvalue of type T1 can be explicitly converted to an lvalue of
1556  // type T2 using the cast const_cast<T2&>;
1557  // -- a glvalue of type T1 can be explicitly converted to an xvalue of
1558  // type T2 using the cast const_cast<T2&&>; and
1559  // -- if T1 is a class type, a prvalue of type T1 can be explicitly
1560  // converted to an xvalue of type T2 using the cast const_cast<T2&&>.
1561 
1562  if (isa<LValueReferenceType>(DestTypeTmp) && !SrcExpr.get()->isLValue()) {
1563  // Cannot const_cast non-lvalue to lvalue reference type. But if this
1564  // is C-style, static_cast might find a way, so we simply suggest a
1565  // message and tell the parent to keep searching.
1566  msg = diag::err_bad_cxx_cast_rvalue;
1567  return TC_NotApplicable;
1568  }
1569 
1570  if (isa<RValueReferenceType>(DestTypeTmp) && SrcExpr.get()->isRValue()) {
1571  if (!SrcType->isRecordType()) {
1572  // Cannot const_cast non-class prvalue to rvalue reference type. But if
1573  // this is C-style, static_cast can do this.
1574  msg = diag::err_bad_cxx_cast_rvalue;
1575  return TC_NotApplicable;
1576  }
1577 
1578  // Materialize the class prvalue so that the const_cast can bind a
1579  // reference to it.
1580  NeedToMaterializeTemporary = true;
1581  }
1582 
1583  // It's not completely clear under the standard whether we can
1584  // const_cast bit-field gl-values. Doing so would not be
1585  // intrinsically complicated, but for now, we say no for
1586  // consistency with other compilers and await the word of the
1587  // committee.
1588  if (SrcExpr.get()->refersToBitField()) {
1589  msg = diag::err_bad_cxx_cast_bitfield;
1590  return TC_NotApplicable;
1591  }
1592 
1593  DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType());
1594  SrcType = Self.Context.getPointerType(SrcType);
1595  }
1596 
1597  // C++ 5.2.11p5: For a const_cast involving pointers to data members [...]
1598  // the rules for const_cast are the same as those used for pointers.
1599 
1600  if (!DestType->isPointerType() &&
1601  !DestType->isMemberPointerType() &&
1602  !DestType->isObjCObjectPointerType()) {
1603  // Cannot cast to non-pointer, non-reference type. Note that, if DestType
1604  // was a reference type, we converted it to a pointer above.
1605  // The status of rvalue references isn't entirely clear, but it looks like
1606  // conversion to them is simply invalid.
1607  // C++ 5.2.11p3: For two pointer types [...]
1608  if (!CStyle)
1609  msg = diag::err_bad_const_cast_dest;
1610  return TC_NotApplicable;
1611  }
1612  if (DestType->isFunctionPointerType() ||
1613  DestType->isMemberFunctionPointerType()) {
1614  // Cannot cast direct function pointers.
1615  // C++ 5.2.11p2: [...] where T is any object type or the void type [...]
1616  // T is the ultimate pointee of source and target type.
1617  if (!CStyle)
1618  msg = diag::err_bad_const_cast_dest;
1619  return TC_NotApplicable;
1620  }
1621  SrcType = Self.Context.getCanonicalType(SrcType);
1622 
1623  // Unwrap the pointers. Ignore qualifiers. Terminate early if the types are
1624  // completely equal.
1625  // C++ 5.2.11p3 describes the core semantics of const_cast. All cv specifiers
1626  // in multi-level pointers may change, but the level count must be the same,
1627  // as must be the final pointee type.
1628  while (SrcType != DestType &&
1629  Self.Context.UnwrapSimilarPointerTypes(SrcType, DestType)) {
1630  Qualifiers SrcQuals, DestQuals;
1631  SrcType = Self.Context.getUnqualifiedArrayType(SrcType, SrcQuals);
1632  DestType = Self.Context.getUnqualifiedArrayType(DestType, DestQuals);
1633 
1634  // const_cast is permitted to strip cvr-qualifiers, only. Make sure that
1635  // the other qualifiers (e.g., address spaces) are identical.
1636  SrcQuals.removeCVRQualifiers();
1637  DestQuals.removeCVRQualifiers();
1638  if (SrcQuals != DestQuals)
1639  return TC_NotApplicable;
1640  }
1641 
1642  // Since we're dealing in canonical types, the remainder must be the same.
1643  if (SrcType != DestType)
1644  return TC_NotApplicable;
1645 
1646  if (NeedToMaterializeTemporary)
1647  // This is a const_cast from a class prvalue to an rvalue reference type.
1648  // Materialize a temporary to store the result of the conversion.
1649  SrcExpr = new (Self.Context) MaterializeTemporaryExpr(
1650  SrcType, SrcExpr.get(), /*IsLValueReference*/ false);
1651 
1652  return TC_Success;
1653 }
1654 
1655 // Checks for undefined behavior in reinterpret_cast.
1656 // The cases that is checked for is:
1657 // *reinterpret_cast<T*>(&a)
1658 // reinterpret_cast<T&>(a)
1659 // where accessing 'a' as type 'T' will result in undefined behavior.
1661  bool IsDereference,
1662  SourceRange Range) {
1663  unsigned DiagID = IsDereference ?
1664  diag::warn_pointer_indirection_from_incompatible_type :
1665  diag::warn_undefined_reinterpret_cast;
1666 
1667  if (Diags.isIgnored(DiagID, Range.getBegin()))
1668  return;
1669 
1670  QualType SrcTy, DestTy;
1671  if (IsDereference) {
1672  if (!SrcType->getAs<PointerType>() || !DestType->getAs<PointerType>()) {
1673  return;
1674  }
1675  SrcTy = SrcType->getPointeeType();
1676  DestTy = DestType->getPointeeType();
1677  } else {
1678  if (!DestType->getAs<ReferenceType>()) {
1679  return;
1680  }
1681  SrcTy = SrcType;
1682  DestTy = DestType->getPointeeType();
1683  }
1684 
1685  // Cast is compatible if the types are the same.
1686  if (Context.hasSameUnqualifiedType(DestTy, SrcTy)) {
1687  return;
1688  }
1689  // or one of the types is a char or void type
1690  if (DestTy->isAnyCharacterType() || DestTy->isVoidType() ||
1691  SrcTy->isAnyCharacterType() || SrcTy->isVoidType()) {
1692  return;
1693  }
1694  // or one of the types is a tag type.
1695  if (SrcTy->getAs<TagType>() || DestTy->getAs<TagType>()) {
1696  return;
1697  }
1698 
1699  // FIXME: Scoped enums?
1700  if ((SrcTy->isUnsignedIntegerType() && DestTy->isSignedIntegerType()) ||
1701  (SrcTy->isSignedIntegerType() && DestTy->isUnsignedIntegerType())) {
1702  if (Context.getTypeSize(DestTy) == Context.getTypeSize(SrcTy)) {
1703  return;
1704  }
1705  }
1706 
1707  Diag(Range.getBegin(), DiagID) << SrcType << DestType << Range;
1708 }
1709 
1710 static void DiagnoseCastOfObjCSEL(Sema &Self, const ExprResult &SrcExpr,
1711  QualType DestType) {
1712  QualType SrcType = SrcExpr.get()->getType();
1713  if (Self.Context.hasSameType(SrcType, DestType))
1714  return;
1715  if (const PointerType *SrcPtrTy = SrcType->getAs<PointerType>())
1716  if (SrcPtrTy->isObjCSelType()) {
1717  QualType DT = DestType;
1718  if (isa<PointerType>(DestType))
1719  DT = DestType->getPointeeType();
1720  if (!DT.getUnqualifiedType()->isVoidType())
1721  Self.Diag(SrcExpr.get()->getExprLoc(),
1722  diag::warn_cast_pointer_from_sel)
1723  << SrcType << DestType << SrcExpr.get()->getSourceRange();
1724  }
1725 }
1726 
1727 static void checkIntToPointerCast(bool CStyle, SourceLocation Loc,
1728  const Expr *SrcExpr, QualType DestType,
1729  Sema &Self) {
1730  QualType SrcType = SrcExpr->getType();
1731 
1732  // Not warning on reinterpret_cast, boolean, constant expressions, etc
1733  // are not explicit design choices, but consistent with GCC's behavior.
1734  // Feel free to modify them if you've reason/evidence for an alternative.
1735  if (CStyle && SrcType->isIntegralType(Self.Context)
1736  && !SrcType->isBooleanType()
1737  && !SrcType->isEnumeralType()
1738  && !SrcExpr->isIntegerConstantExpr(Self.Context)
1739  && Self.Context.getTypeSize(DestType) >
1740  Self.Context.getTypeSize(SrcType)) {
1741  // Separate between casts to void* and non-void* pointers.
1742  // Some APIs use (abuse) void* for something like a user context,
1743  // and often that value is an integer even if it isn't a pointer itself.
1744  // Having a separate warning flag allows users to control the warning
1745  // for their workflow.
1746  unsigned Diag = DestType->isVoidPointerType() ?
1747  diag::warn_int_to_void_pointer_cast
1748  : diag::warn_int_to_pointer_cast;
1749  Self.Diag(Loc, Diag) << SrcType << DestType;
1750  }
1751 }
1752 
1754  QualType DestType, bool CStyle,
1755  SourceRange OpRange,
1756  unsigned &msg,
1757  CastKind &Kind) {
1758  bool IsLValueCast = false;
1759 
1760  DestType = Self.Context.getCanonicalType(DestType);
1761  QualType SrcType = SrcExpr.get()->getType();
1762 
1763  // Is the source an overloaded name? (i.e. &foo)
1764  // If so, reinterpret_cast can not help us here (13.4, p1, bullet 5) ...
1765  if (SrcType == Self.Context.OverloadTy) {
1766  // ... unless foo<int> resolves to an lvalue unambiguously.
1767  // TODO: what if this fails because of DiagnoseUseOfDecl or something
1768  // like it?
1769  ExprResult SingleFunctionExpr = SrcExpr;
1771  SingleFunctionExpr,
1772  Expr::getValueKindForType(DestType) == VK_RValue // Convert Fun to Ptr
1773  ) && SingleFunctionExpr.isUsable()) {
1774  SrcExpr = SingleFunctionExpr;
1775  SrcType = SrcExpr.get()->getType();
1776  } else {
1777  return TC_NotApplicable;
1778  }
1779  }
1780 
1781  if (const ReferenceType *DestTypeTmp = DestType->getAs<ReferenceType>()) {
1782  if (!SrcExpr.get()->isGLValue()) {
1783  // Cannot cast non-glvalue to (lvalue or rvalue) reference type. See the
1784  // similar comment in const_cast.
1785  msg = diag::err_bad_cxx_cast_rvalue;
1786  return TC_NotApplicable;
1787  }
1788 
1789  if (!CStyle) {
1790  Self.CheckCompatibleReinterpretCast(SrcType, DestType,
1791  /*isDereference=*/false, OpRange);
1792  }
1793 
1794  // C++ 5.2.10p10: [...] a reference cast reinterpret_cast<T&>(x) has the
1795  // same effect as the conversion *reinterpret_cast<T*>(&x) with the
1796  // built-in & and * operators.
1797 
1798  const char *inappropriate = nullptr;
1799  switch (SrcExpr.get()->getObjectKind()) {
1800  case OK_Ordinary:
1801  break;
1802  case OK_BitField: inappropriate = "bit-field"; break;
1803  case OK_VectorComponent: inappropriate = "vector element"; break;
1804  case OK_ObjCProperty: inappropriate = "property expression"; break;
1805  case OK_ObjCSubscript: inappropriate = "container subscripting expression";
1806  break;
1807  }
1808  if (inappropriate) {
1809  Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_reference)
1810  << inappropriate << DestType
1811  << OpRange << SrcExpr.get()->getSourceRange();
1812  msg = 0; SrcExpr = ExprError();
1813  return TC_NotApplicable;
1814  }
1815 
1816  // This code does this transformation for the checked types.
1817  DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType());
1818  SrcType = Self.Context.getPointerType(SrcType);
1819 
1820  IsLValueCast = true;
1821  }
1822 
1823  // Canonicalize source for comparison.
1824  SrcType = Self.Context.getCanonicalType(SrcType);
1825 
1826  const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>(),
1827  *SrcMemPtr = SrcType->getAs<MemberPointerType>();
1828  if (DestMemPtr && SrcMemPtr) {
1829  // C++ 5.2.10p9: An rvalue of type "pointer to member of X of type T1"
1830  // can be explicitly converted to an rvalue of type "pointer to member
1831  // of Y of type T2" if T1 and T2 are both function types or both object
1832  // types.
1833  if (DestMemPtr->isMemberFunctionPointer() !=
1834  SrcMemPtr->isMemberFunctionPointer())
1835  return TC_NotApplicable;
1836 
1837  // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away
1838  // constness.
1839  // A reinterpret_cast followed by a const_cast can, though, so in C-style,
1840  // we accept it.
1841  if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle,
1842  /*CheckObjCLifetime=*/CStyle)) {
1843  msg = diag::err_bad_cxx_cast_qualifiers_away;
1844  return TC_Failed;
1845  }
1846 
1847  if (Self.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1848  // We need to determine the inheritance model that the class will use if
1849  // haven't yet.
1850  (void)Self.isCompleteType(OpRange.getBegin(), SrcType);
1851  (void)Self.isCompleteType(OpRange.getBegin(), DestType);
1852  }
1853 
1854  // Don't allow casting between member pointers of different sizes.
1855  if (Self.Context.getTypeSize(DestMemPtr) !=
1856  Self.Context.getTypeSize(SrcMemPtr)) {
1857  msg = diag::err_bad_cxx_cast_member_pointer_size;
1858  return TC_Failed;
1859  }
1860 
1861  // A valid member pointer cast.
1862  assert(!IsLValueCast);
1864  return TC_Success;
1865  }
1866 
1867  // See below for the enumeral issue.
1868  if (SrcType->isNullPtrType() && DestType->isIntegralType(Self.Context)) {
1869  // C++0x 5.2.10p4: A pointer can be explicitly converted to any integral
1870  // type large enough to hold it. A value of std::nullptr_t can be
1871  // converted to an integral type; the conversion has the same meaning
1872  // and validity as a conversion of (void*)0 to the integral type.
1873  if (Self.Context.getTypeSize(SrcType) >
1874  Self.Context.getTypeSize(DestType)) {
1875  msg = diag::err_bad_reinterpret_cast_small_int;
1876  return TC_Failed;
1877  }
1878  Kind = CK_PointerToIntegral;
1879  return TC_Success;
1880  }
1881 
1882  // Allow reinterpret_casts between vectors of the same size and
1883  // between vectors and integers of the same size.
1884  bool destIsVector = DestType->isVectorType();
1885  bool srcIsVector = SrcType->isVectorType();
1886  if (srcIsVector || destIsVector) {
1887  // The non-vector type, if any, must have integral type. This is
1888  // the same rule that C vector casts use; note, however, that enum
1889  // types are not integral in C++.
1890  if ((!destIsVector && !DestType->isIntegralType(Self.Context)) ||
1891  (!srcIsVector && !SrcType->isIntegralType(Self.Context)))
1892  return TC_NotApplicable;
1893 
1894  // The size we want to consider is eltCount * eltSize.
1895  // That's exactly what the lax-conversion rules will check.
1896  if (Self.areLaxCompatibleVectorTypes(SrcType, DestType)) {
1897  Kind = CK_BitCast;
1898  return TC_Success;
1899  }
1900 
1901  // Otherwise, pick a reasonable diagnostic.
1902  if (!destIsVector)
1903  msg = diag::err_bad_cxx_cast_vector_to_scalar_different_size;
1904  else if (!srcIsVector)
1905  msg = diag::err_bad_cxx_cast_scalar_to_vector_different_size;
1906  else
1907  msg = diag::err_bad_cxx_cast_vector_to_vector_different_size;
1908 
1909  return TC_Failed;
1910  }
1911 
1912  if (SrcType == DestType) {
1913  // C++ 5.2.10p2 has a note that mentions that, subject to all other
1914  // restrictions, a cast to the same type is allowed so long as it does not
1915  // cast away constness. In C++98, the intent was not entirely clear here,
1916  // since all other paragraphs explicitly forbid casts to the same type.
1917  // C++11 clarifies this case with p2.
1918  //
1919  // The only allowed types are: integral, enumeration, pointer, or
1920  // pointer-to-member types. We also won't restrict Obj-C pointers either.
1921  Kind = CK_NoOp;
1923  if (SrcType->isIntegralOrEnumerationType() ||
1924  SrcType->isAnyPointerType() ||
1925  SrcType->isMemberPointerType() ||
1926  SrcType->isBlockPointerType()) {
1927  Result = TC_Success;
1928  }
1929  return Result;
1930  }
1931 
1932  bool destIsPtr = DestType->isAnyPointerType() ||
1933  DestType->isBlockPointerType();
1934  bool srcIsPtr = SrcType->isAnyPointerType() ||
1935  SrcType->isBlockPointerType();
1936  if (!destIsPtr && !srcIsPtr) {
1937  // Except for std::nullptr_t->integer and lvalue->reference, which are
1938  // handled above, at least one of the two arguments must be a pointer.
1939  return TC_NotApplicable;
1940  }
1941 
1942  if (DestType->isIntegralType(Self.Context)) {
1943  assert(srcIsPtr && "One type must be a pointer");
1944  // C++ 5.2.10p4: A pointer can be explicitly converted to any integral
1945  // type large enough to hold it; except in Microsoft mode, where the
1946  // integral type size doesn't matter (except we don't allow bool).
1947  bool MicrosoftException = Self.getLangOpts().MicrosoftExt &&
1948  !DestType->isBooleanType();
1949  if ((Self.Context.getTypeSize(SrcType) >
1950  Self.Context.getTypeSize(DestType)) &&
1951  !MicrosoftException) {
1952  msg = diag::err_bad_reinterpret_cast_small_int;
1953  return TC_Failed;
1954  }
1955  Kind = CK_PointerToIntegral;
1956  return TC_Success;
1957  }
1958 
1959  if (SrcType->isIntegralOrEnumerationType()) {
1960  assert(destIsPtr && "One type must be a pointer");
1961  checkIntToPointerCast(CStyle, OpRange.getBegin(), SrcExpr.get(), DestType,
1962  Self);
1963  // C++ 5.2.10p5: A value of integral or enumeration type can be explicitly
1964  // converted to a pointer.
1965  // C++ 5.2.10p9: [Note: ...a null pointer constant of integral type is not
1966  // necessarily converted to a null pointer value.]
1967  Kind = CK_IntegralToPointer;
1968  return TC_Success;
1969  }
1970 
1971  if (!destIsPtr || !srcIsPtr) {
1972  // With the valid non-pointer conversions out of the way, we can be even
1973  // more stringent.
1974  return TC_NotApplicable;
1975  }
1976 
1977  // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away constness.
1978  // The C-style cast operator can.
1979  if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle,
1980  /*CheckObjCLifetime=*/CStyle)) {
1981  msg = diag::err_bad_cxx_cast_qualifiers_away;
1982  return TC_Failed;
1983  }
1984 
1985  // Cannot convert between block pointers and Objective-C object pointers.
1986  if ((SrcType->isBlockPointerType() && DestType->isObjCObjectPointerType()) ||
1987  (DestType->isBlockPointerType() && SrcType->isObjCObjectPointerType()))
1988  return TC_NotApplicable;
1989 
1990  if (IsLValueCast) {
1991  Kind = CK_LValueBitCast;
1992  } else if (DestType->isObjCObjectPointerType()) {
1993  Kind = Self.PrepareCastToObjCObjectPointer(SrcExpr);
1994  } else if (DestType->isBlockPointerType()) {
1995  if (!SrcType->isBlockPointerType()) {
1997  } else {
1998  Kind = CK_BitCast;
1999  }
2000  } else {
2001  Kind = CK_BitCast;
2002  }
2003 
2004  // Any pointer can be cast to an Objective-C pointer type with a C-style
2005  // cast.
2006  if (CStyle && DestType->isObjCObjectPointerType()) {
2007  return TC_Success;
2008  }
2009  if (CStyle)
2010  DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType);
2011 
2012  // Not casting away constness, so the only remaining check is for compatible
2013  // pointer categories.
2014 
2015  if (SrcType->isFunctionPointerType()) {
2016  if (DestType->isFunctionPointerType()) {
2017  // C++ 5.2.10p6: A pointer to a function can be explicitly converted to
2018  // a pointer to a function of a different type.
2019  return TC_Success;
2020  }
2021 
2022  // C++0x 5.2.10p8: Converting a pointer to a function into a pointer to
2023  // an object type or vice versa is conditionally-supported.
2024  // Compilers support it in C++03 too, though, because it's necessary for
2025  // casting the return value of dlsym() and GetProcAddress().
2026  // FIXME: Conditionally-supported behavior should be configurable in the
2027  // TargetInfo or similar.
2028  Self.Diag(OpRange.getBegin(),
2029  Self.getLangOpts().CPlusPlus11 ?
2030  diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj)
2031  << OpRange;
2032  return TC_Success;
2033  }
2034 
2035  if (DestType->isFunctionPointerType()) {
2036  // See above.
2037  Self.Diag(OpRange.getBegin(),
2038  Self.getLangOpts().CPlusPlus11 ?
2039  diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj)
2040  << OpRange;
2041  return TC_Success;
2042  }
2043 
2044  // C++ 5.2.10p7: A pointer to an object can be explicitly converted to
2045  // a pointer to an object of different type.
2046  // Void pointers are not specified, but supported by every compiler out there.
2047  // So we finish by allowing everything that remains - it's got to be two
2048  // object pointers.
2049  return TC_Success;
2050 }
2051 
2052 void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
2053  bool ListInitialization) {
2054  // Handle placeholders.
2055  if (isPlaceholder()) {
2056  // C-style casts can resolve __unknown_any types.
2057  if (claimPlaceholder(BuiltinType::UnknownAny)) {
2058  SrcExpr = Self.checkUnknownAnyCast(DestRange, DestType,
2059  SrcExpr.get(), Kind,
2060  ValueKind, BasePath);
2061  return;
2062  }
2063 
2064  checkNonOverloadPlaceholders();
2065  if (SrcExpr.isInvalid())
2066  return;
2067  }
2068 
2069  // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
2070  // This test is outside everything else because it's the only case where
2071  // a non-lvalue-reference target type does not lead to decay.
2072  if (DestType->isVoidType()) {
2073  Kind = CK_ToVoid;
2074 
2075  if (claimPlaceholder(BuiltinType::Overload)) {
2076  Self.ResolveAndFixSingleFunctionTemplateSpecialization(
2077  SrcExpr, /* Decay Function to ptr */ false,
2078  /* Complain */ true, DestRange, DestType,
2079  diag::err_bad_cstyle_cast_overload);
2080  if (SrcExpr.isInvalid())
2081  return;
2082  }
2083 
2084  SrcExpr = Self.IgnoredValueConversions(SrcExpr.get());
2085  return;
2086  }
2087 
2088  // If the type is dependent, we won't do any other semantic analysis now.
2089  if (DestType->isDependentType() || SrcExpr.get()->isTypeDependent() ||
2090  SrcExpr.get()->isValueDependent()) {
2091  assert(Kind == CK_Dependent);
2092  return;
2093  }
2094 
2095  if (ValueKind == VK_RValue && !DestType->isRecordType() &&
2096  !isPlaceholder(BuiltinType::Overload)) {
2097  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
2098  if (SrcExpr.isInvalid())
2099  return;
2100  }
2101 
2102  // AltiVec vector initialization with a single literal.
2103  if (const VectorType *vecTy = DestType->getAs<VectorType>())
2104  if (vecTy->getVectorKind() == VectorType::AltiVecVector
2105  && (SrcExpr.get()->getType()->isIntegerType()
2106  || SrcExpr.get()->getType()->isFloatingType())) {
2107  Kind = CK_VectorSplat;
2108  SrcExpr = Self.prepareVectorSplat(DestType, SrcExpr.get());
2109  return;
2110  }
2111 
2112  // C++ [expr.cast]p5: The conversions performed by
2113  // - a const_cast,
2114  // - a static_cast,
2115  // - a static_cast followed by a const_cast,
2116  // - a reinterpret_cast, or
2117  // - a reinterpret_cast followed by a const_cast,
2118  // can be performed using the cast notation of explicit type conversion.
2119  // [...] If a conversion can be interpreted in more than one of the ways
2120  // listed above, the interpretation that appears first in the list is used,
2121  // even if a cast resulting from that interpretation is ill-formed.
2122  // In plain language, this means trying a const_cast ...
2123  unsigned msg = diag::err_bad_cxx_cast_generic;
2124  TryCastResult tcr = TryConstCast(Self, SrcExpr, DestType,
2125  /*CStyle*/true, msg);
2126  if (SrcExpr.isInvalid())
2127  return;
2128  if (tcr == TC_Success)
2129  Kind = CK_NoOp;
2130 
2132  = FunctionalStyle? Sema::CCK_FunctionalCast
2134  if (tcr == TC_NotApplicable) {
2135  // ... or if that is not possible, a static_cast, ignoring const, ...
2136  tcr = TryStaticCast(Self, SrcExpr, DestType, CCK, OpRange,
2137  msg, Kind, BasePath, ListInitialization);
2138  if (SrcExpr.isInvalid())
2139  return;
2140 
2141  if (tcr == TC_NotApplicable) {
2142  // ... and finally a reinterpret_cast, ignoring const.
2143  tcr = TryReinterpretCast(Self, SrcExpr, DestType, /*CStyle*/true,
2144  OpRange, msg, Kind);
2145  if (SrcExpr.isInvalid())
2146  return;
2147  }
2148  }
2149 
2150  if (Self.getLangOpts().ObjCAutoRefCount && tcr == TC_Success)
2151  checkObjCARCConversion(CCK);
2152 
2153  if (tcr != TC_Success && msg != 0) {
2154  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
2155  DeclAccessPair Found;
2156  FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(),
2157  DestType,
2158  /*Complain*/ true,
2159  Found);
2160  if (Fn) {
2161  // If DestType is a function type (not to be confused with the function
2162  // pointer type), it will be possible to resolve the function address,
2163  // but the type cast should be considered as failure.
2164  OverloadExpr *OE = OverloadExpr::find(SrcExpr.get()).Expression;
2165  Self.Diag(OpRange.getBegin(), diag::err_bad_cstyle_cast_overload)
2166  << OE->getName() << DestType << OpRange
2167  << OE->getQualifierLoc().getSourceRange();
2168  Self.NoteAllOverloadCandidates(SrcExpr.get());
2169  }
2170  } else {
2171  diagnoseBadCast(Self, msg, (FunctionalStyle ? CT_Functional : CT_CStyle),
2172  OpRange, SrcExpr.get(), DestType, ListInitialization);
2173  }
2174  } else if (Kind == CK_BitCast) {
2175  checkCastAlign();
2176  }
2177 
2178  // Clear out SrcExpr if there was a fatal error.
2179  if (tcr != TC_Success)
2180  SrcExpr = ExprError();
2181 }
2182 
2183 /// DiagnoseBadFunctionCast - Warn whenever a function call is cast to a
2184 /// non-matching type. Such as enum function call to int, int call to
2185 /// pointer; etc. Cast to 'void' is an exception.
2186 static void DiagnoseBadFunctionCast(Sema &Self, const ExprResult &SrcExpr,
2187  QualType DestType) {
2188  if (Self.Diags.isIgnored(diag::warn_bad_function_cast,
2189  SrcExpr.get()->getExprLoc()))
2190  return;
2191 
2192  if (!isa<CallExpr>(SrcExpr.get()))
2193  return;
2194 
2195  QualType SrcType = SrcExpr.get()->getType();
2196  if (DestType.getUnqualifiedType()->isVoidType())
2197  return;
2198  if ((SrcType->isAnyPointerType() || SrcType->isBlockPointerType())
2199  && (DestType->isAnyPointerType() || DestType->isBlockPointerType()))
2200  return;
2201  if (SrcType->isIntegerType() && DestType->isIntegerType() &&
2202  (SrcType->isBooleanType() == DestType->isBooleanType()) &&
2203  (SrcType->isEnumeralType() == DestType->isEnumeralType()))
2204  return;
2205  if (SrcType->isRealFloatingType() && DestType->isRealFloatingType())
2206  return;
2207  if (SrcType->isEnumeralType() && DestType->isEnumeralType())
2208  return;
2209  if (SrcType->isComplexType() && DestType->isComplexType())
2210  return;
2211  if (SrcType->isComplexIntegerType() && DestType->isComplexIntegerType())
2212  return;
2213 
2214  Self.Diag(SrcExpr.get()->getExprLoc(),
2215  diag::warn_bad_function_cast)
2216  << SrcType << DestType << SrcExpr.get()->getSourceRange();
2217 }
2218 
2219 /// Check the semantics of a C-style cast operation, in C.
2220 void CastOperation::CheckCStyleCast() {
2221  assert(!Self.getLangOpts().CPlusPlus);
2222 
2223  // C-style casts can resolve __unknown_any types.
2224  if (claimPlaceholder(BuiltinType::UnknownAny)) {
2225  SrcExpr = Self.checkUnknownAnyCast(DestRange, DestType,
2226  SrcExpr.get(), Kind,
2227  ValueKind, BasePath);
2228  return;
2229  }
2230 
2231  // C99 6.5.4p2: the cast type needs to be void or scalar and the expression
2232  // type needs to be scalar.
2233  if (DestType->isVoidType()) {
2234  // We don't necessarily do lvalue-to-rvalue conversions on this.
2235  SrcExpr = Self.IgnoredValueConversions(SrcExpr.get());
2236  if (SrcExpr.isInvalid())
2237  return;
2238 
2239  // Cast to void allows any expr type.
2240  Kind = CK_ToVoid;
2241  return;
2242  }
2243 
2244  // Overloads are allowed with C extensions, so we need to support them.
2245  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
2246  DeclAccessPair DAP;
2247  if (FunctionDecl *FD = Self.ResolveAddressOfOverloadedFunction(
2248  SrcExpr.get(), DestType, /*Complain=*/true, DAP))
2249  SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr.get(), DAP, FD);
2250  else
2251  return;
2252  assert(SrcExpr.isUsable());
2253  }
2254  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
2255  if (SrcExpr.isInvalid())
2256  return;
2257  QualType SrcType = SrcExpr.get()->getType();
2258 
2259  assert(!SrcType->isPlaceholderType());
2260 
2261  // OpenCL v1 s6.5: Casting a pointer to address space A to a pointer to
2262  // address space B is illegal.
2263  if (Self.getLangOpts().OpenCL && DestType->isPointerType() &&
2264  SrcType->isPointerType()) {
2265  const PointerType *DestPtr = DestType->getAs<PointerType>();
2266  if (!DestPtr->isAddressSpaceOverlapping(*SrcType->getAs<PointerType>())) {
2267  Self.Diag(OpRange.getBegin(),
2268  diag::err_typecheck_incompatible_address_space)
2269  << SrcType << DestType << Sema::AA_Casting
2270  << SrcExpr.get()->getSourceRange();
2271  SrcExpr = ExprError();
2272  return;
2273  }
2274  }
2275 
2276  if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
2277  diag::err_typecheck_cast_to_incomplete)) {
2278  SrcExpr = ExprError();
2279  return;
2280  }
2281 
2282  if (!DestType->isScalarType() && !DestType->isVectorType()) {
2283  const RecordType *DestRecordTy = DestType->getAs<RecordType>();
2284 
2285  if (DestRecordTy && Self.Context.hasSameUnqualifiedType(DestType, SrcType)){
2286  // GCC struct/union extension: allow cast to self.
2287  Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_nonscalar)
2288  << DestType << SrcExpr.get()->getSourceRange();
2289  Kind = CK_NoOp;
2290  return;
2291  }
2292 
2293  // GCC's cast to union extension.
2294  if (DestRecordTy && DestRecordTy->getDecl()->isUnion()) {
2295  RecordDecl *RD = DestRecordTy->getDecl();
2296  RecordDecl::field_iterator Field, FieldEnd;
2297  for (Field = RD->field_begin(), FieldEnd = RD->field_end();
2298  Field != FieldEnd; ++Field) {
2299  if (Self.Context.hasSameUnqualifiedType(Field->getType(), SrcType) &&
2300  !Field->isUnnamedBitfield()) {
2301  Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_to_union)
2302  << SrcExpr.get()->getSourceRange();
2303  break;
2304  }
2305  }
2306  if (Field == FieldEnd) {
2307  Self.Diag(OpRange.getBegin(), diag::err_typecheck_cast_to_union_no_type)
2308  << SrcType << SrcExpr.get()->getSourceRange();
2309  SrcExpr = ExprError();
2310  return;
2311  }
2312  Kind = CK_ToUnion;
2313  return;
2314  }
2315 
2316  // Reject any other conversions to non-scalar types.
2317  Self.Diag(OpRange.getBegin(), diag::err_typecheck_cond_expect_scalar)
2318  << DestType << SrcExpr.get()->getSourceRange();
2319  SrcExpr = ExprError();
2320  return;
2321  }
2322 
2323  // The type we're casting to is known to be a scalar or vector.
2324 
2325  // Require the operand to be a scalar or vector.
2326  if (!SrcType->isScalarType() && !SrcType->isVectorType()) {
2327  Self.Diag(SrcExpr.get()->getExprLoc(),
2328  diag::err_typecheck_expect_scalar_operand)
2329  << SrcType << SrcExpr.get()->getSourceRange();
2330  SrcExpr = ExprError();
2331  return;
2332  }
2333 
2334  if (DestType->isExtVectorType()) {
2335  SrcExpr = Self.CheckExtVectorCast(OpRange, DestType, SrcExpr.get(), Kind);
2336  return;
2337  }
2338 
2339  if (const VectorType *DestVecTy = DestType->getAs<VectorType>()) {
2340  if (DestVecTy->getVectorKind() == VectorType::AltiVecVector &&
2341  (SrcType->isIntegerType() || SrcType->isFloatingType())) {
2342  Kind = CK_VectorSplat;
2343  SrcExpr = Self.prepareVectorSplat(DestType, SrcExpr.get());
2344  } else if (Self.CheckVectorCast(OpRange, DestType, SrcType, Kind)) {
2345  SrcExpr = ExprError();
2346  }
2347  return;
2348  }
2349 
2350  if (SrcType->isVectorType()) {
2351  if (Self.CheckVectorCast(OpRange, SrcType, DestType, Kind))
2352  SrcExpr = ExprError();
2353  return;
2354  }
2355 
2356  // The source and target types are both scalars, i.e.
2357  // - arithmetic types (fundamental, enum, and complex)
2358  // - all kinds of pointers
2359  // Note that member pointers were filtered out with C++, above.
2360 
2361  if (isa<ObjCSelectorExpr>(SrcExpr.get())) {
2362  Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_selector_expr);
2363  SrcExpr = ExprError();
2364  return;
2365  }
2366 
2367  // If either type is a pointer, the other type has to be either an
2368  // integer or a pointer.
2369  if (!DestType->isArithmeticType()) {
2370  if (!SrcType->isIntegralType(Self.Context) && SrcType->isArithmeticType()) {
2371  Self.Diag(SrcExpr.get()->getExprLoc(),
2372  diag::err_cast_pointer_from_non_pointer_int)
2373  << SrcType << SrcExpr.get()->getSourceRange();
2374  SrcExpr = ExprError();
2375  return;
2376  }
2377  checkIntToPointerCast(/* CStyle */ true, OpRange.getBegin(), SrcExpr.get(),
2378  DestType, Self);
2379  } else if (!SrcType->isArithmeticType()) {
2380  if (!DestType->isIntegralType(Self.Context) &&
2381  DestType->isArithmeticType()) {
2382  Self.Diag(SrcExpr.get()->getLocStart(),
2383  diag::err_cast_pointer_to_non_pointer_int)
2384  << DestType << SrcExpr.get()->getSourceRange();
2385  SrcExpr = ExprError();
2386  return;
2387  }
2388  }
2389 
2390  if (Self.getLangOpts().OpenCL && !Self.getOpenCLOptions().cl_khr_fp16) {
2391  if (DestType->isHalfType()) {
2392  Self.Diag(SrcExpr.get()->getLocStart(), diag::err_opencl_cast_to_half)
2393  << DestType << SrcExpr.get()->getSourceRange();
2394  SrcExpr = ExprError();
2395  return;
2396  }
2397  }
2398 
2399  // ARC imposes extra restrictions on casts.
2400  if (Self.getLangOpts().ObjCAutoRefCount) {
2401  checkObjCARCConversion(Sema::CCK_CStyleCast);
2402  if (SrcExpr.isInvalid())
2403  return;
2404 
2405  if (const PointerType *CastPtr = DestType->getAs<PointerType>()) {
2406  if (const PointerType *ExprPtr = SrcType->getAs<PointerType>()) {
2407  Qualifiers CastQuals = CastPtr->getPointeeType().getQualifiers();
2408  Qualifiers ExprQuals = ExprPtr->getPointeeType().getQualifiers();
2409  if (CastPtr->getPointeeType()->isObjCLifetimeType() &&
2410  ExprPtr->getPointeeType()->isObjCLifetimeType() &&
2411  !CastQuals.compatiblyIncludesObjCLifetime(ExprQuals)) {
2412  Self.Diag(SrcExpr.get()->getLocStart(),
2413  diag::err_typecheck_incompatible_ownership)
2414  << SrcType << DestType << Sema::AA_Casting
2415  << SrcExpr.get()->getSourceRange();
2416  return;
2417  }
2418  }
2419  }
2420  else if (!Self.CheckObjCARCUnavailableWeakConversion(DestType, SrcType)) {
2421  Self.Diag(SrcExpr.get()->getLocStart(),
2422  diag::err_arc_convesion_of_weak_unavailable)
2423  << 1 << SrcType << DestType << SrcExpr.get()->getSourceRange();
2424  SrcExpr = ExprError();
2425  return;
2426  }
2427  }
2428 
2429  DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType);
2430  DiagnoseBadFunctionCast(Self, SrcExpr, DestType);
2431  Kind = Self.PrepareScalarCast(SrcExpr, DestType);
2432  if (SrcExpr.isInvalid())
2433  return;
2434 
2435  if (Kind == CK_BitCast)
2436  checkCastAlign();
2437 
2438  // -Wcast-qual
2439  QualType TheOffendingSrcType, TheOffendingDestType;
2440  Qualifiers CastAwayQualifiers;
2441  if (SrcType->isAnyPointerType() && DestType->isAnyPointerType() &&
2442  CastsAwayConstness(Self, SrcType, DestType, true, false,
2443  &TheOffendingSrcType, &TheOffendingDestType,
2444  &CastAwayQualifiers)) {
2445  int qualifiers = -1;
2446  if (CastAwayQualifiers.hasConst() && CastAwayQualifiers.hasVolatile()) {
2447  qualifiers = 0;
2448  } else if (CastAwayQualifiers.hasConst()) {
2449  qualifiers = 1;
2450  } else if (CastAwayQualifiers.hasVolatile()) {
2451  qualifiers = 2;
2452  }
2453  // This is a variant of int **x; const int **y = (const int **)x;
2454  if (qualifiers == -1)
2455  Self.Diag(SrcExpr.get()->getLocStart(), diag::warn_cast_qual2) <<
2456  SrcType << DestType;
2457  else
2458  Self.Diag(SrcExpr.get()->getLocStart(), diag::warn_cast_qual) <<
2459  TheOffendingSrcType << TheOffendingDestType << qualifiers;
2460  }
2461 }
2462 
2464  TypeSourceInfo *CastTypeInfo,
2465  SourceLocation RPLoc,
2466  Expr *CastExpr) {
2467  CastOperation Op(*this, CastTypeInfo->getType(), CastExpr);
2468  Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
2469  Op.OpRange = SourceRange(LPLoc, CastExpr->getLocEnd());
2470 
2471  if (getLangOpts().CPlusPlus) {
2472  Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ false,
2473  isa<InitListExpr>(CastExpr));
2474  } else {
2475  Op.CheckCStyleCast();
2476  }
2477 
2478  if (Op.SrcExpr.isInvalid())
2479  return ExprError();
2480 
2481  return Op.complete(CStyleCastExpr::Create(Context, Op.ResultType,
2482  Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
2483  &Op.BasePath, CastTypeInfo, LPLoc, RPLoc));
2484 }
2485 
2487  SourceLocation LPLoc,
2488  Expr *CastExpr,
2489  SourceLocation RPLoc) {
2490  assert(LPLoc.isValid() && "List-initialization shouldn't get here.");
2491  CastOperation Op(*this, CastTypeInfo->getType(), CastExpr);
2492  Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
2493  Op.OpRange = SourceRange(Op.DestRange.getBegin(), CastExpr->getLocEnd());
2494 
2495  Op.CheckCXXCStyleCast(/*FunctionalStyle=*/true, /*ListInit=*/false);
2496  if (Op.SrcExpr.isInvalid())
2497  return ExprError();
2498 
2499  auto *SubExpr = Op.SrcExpr.get();
2500  if (auto *BindExpr = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
2501  SubExpr = BindExpr->getSubExpr();
2502  if (auto *ConstructExpr = dyn_cast<CXXConstructExpr>(SubExpr))
2503  ConstructExpr->setParenOrBraceRange(SourceRange(LPLoc, RPLoc));
2504 
2505  return Op.complete(CXXFunctionalCastExpr::Create(Context, Op.ResultType,
2506  Op.ValueKind, CastTypeInfo, Op.Kind,
2507  Op.SrcExpr.get(), &Op.BasePath, LPLoc, RPLoc));
2508 }
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Definition: Type.h:446
Defines the clang::ASTContext interface.
SourceLocation getEnd() const
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
const RecordType * getDetectedVirtual() const
The virtual base discovered on the path (if we are merely detecting virtuals).
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1483
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
bool isNullPtrType() const
Definition: Type.h:5559
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2147
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Definition: Type.h:5242
A (possibly-)qualified type.
Definition: Type.h:575
bool isInvalid() const
Definition: Ownership.h:159
A cast other than a C-style cast.
Definition: Sema.h:8205
bool isMemberPointerType() const
Definition: Type.h:5329
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2627
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1673
const LangOptions & getLangOpts() const
Definition: Sema.h:1041
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1680
static CXXDynamicCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Definition: ExprCXX.cpp:608
bool isRecordType() const
Definition: Type.h:5362
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1118
CK_ToUnion - The GCC cast-to-union extension.
static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, Sema::CheckedConversionKind CCK, SourceRange OpRange, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath, bool ListInitialization)
TryStaticCast - Check if a static cast can be performed, and do so if possible.
Definition: SemaCast.cpp:944
The cast method is appropriate and successful.
Definition: SemaCast.cpp:34
bool isVoidPointerType() const
Definition: Type.cpp:385
bool isEnumeralType() const
Definition: Type.h:5365
std::string getAsString() const
Definition: Type.h:901
PtrTy get() const
Definition: Ownership.h:163
QualType getPointeeType() const
Definition: Type.h:2388
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Definition: Expr.h:390
Overloading for a user-defined conversion failed.
Ambiguous candidates found.
Definition: Overload.h:43
CK_FloatingToIntegral - Floating point to integral.
bool isBooleanType() const
Definition: Type.h:5609
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
Definition: Type.h:427
A container of type source information.
Definition: Decl.h:61
bool isBlockPointerType() const
Definition: Type.h:5311
static CXXFunctionalCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, TypeSourceInfo *Written, CastKind Kind, Expr *Op, const CXXCastPath *Path, SourceLocation LPLoc, SourceLocation RPLoc)
Definition: ExprCXX.cpp:704
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3864
static_cast
Definition: SemaCast.cpp:41
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
CK_IntegralToFloating - Integral to floating point.
An Objective-C array/dictionary subscripting which reads an object or writes at the subscripted array...
Definition: Specifiers.h:133
CK_IntegralCast - A cast between integral types (other than to boolean).
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1608
void removeObjCLifetime()
Definition: Type.h:296
DiagnosticsEngine & Diags
Definition: Sema.h:297
void clear()
Clear the base-paths results.
field_iterator field_begin() const
Definition: Decl.cpp:3746
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1793
CK_Dynamic - A C++ dynamic_cast.
CK_Dependent - A conversion which cannot yet be analyzed because either the expression or target type...
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isVoidType() const
Definition: Type.h:5546
The collection of all-type qualifiers we support.
Definition: Type.h:116
std::list< CXXBasePath >::const_iterator const_paths_iterator
Expr * FixOverloadedFunctionReference(Expr *E, DeclAccessPair FoundDecl, FunctionDecl *Fn)
FixOverloadedFunctionReference - E is an expression that refers to a C++ overloaded function (possibl...
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3166
bool isScalarType() const
Definition: Type.h:5581
void setRecordingPaths(bool RP)
Specify whether we should be recording paths or not.
A vector component is an element or range of elements on a vector.
Definition: Specifiers.h:124
(Type)expr
Definition: SemaCast.cpp:44
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:91
The cast method is not applicable.
Definition: SemaCast.cpp:33
A C-style cast.
Definition: Sema.h:8201
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
bool isRecordingPaths() const
Whether we are recording paths.
bool isReferenceType() const
Definition: Type.h:5314
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2788
TryCastResult
Definition: SemaCast.cpp:32
bool isAnyPointerType() const
Definition: Type.h:5308
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that that type refers to...
Definition: Type.cpp:1507
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:675
unsigned getCVRQualifiers() const
Definition: Type.h:251
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1962
CK_VectorSplat - A conversion from an arithmetic type to a vector of that element type...
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1191
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:1987
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator, which is not a function declaration or definition and therefore is not permitted to have default arguments.
CK_PointerToIntegral - Pointer to integral.
CK_IntegralToPointer - Integral to pointer.
OverloadCandidateDisplayKind
Definition: Overload.h:47
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:102
CK_IntegralToBoolean - Integral to boolean.
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1416
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2351
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:580
bool UnwrapSimilarPointerTypes(QualType &T1, QualType &T2)
UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that may be similar (C++ 4...
const LangOptions & getLangOpts() const
Definition: ASTContext.h:596
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, bool &DerivedToBase, bool &ObjCConversion, bool &ObjCLifetimeConversion)
CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are referenc...
Succeeded, but refers to a deleted function.
Definition: Overload.h:44
uint32_t Offset
Definition: CacheTokens.cpp:44
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
OverloadCandidateSet & getFailedCandidateSet()
Retrieve a reference to the candidate set when overload resolution fails.
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:1801
RecordDecl * getDecl() const
Definition: Type.h:3553
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:8197
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:1740
static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind)
Definition: SemaCast.cpp:1753
FunctionDecl * ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, QualType TargetType, bool Complain, DeclAccessPair &Found, bool *pHadMultipleCandidates=nullptr)
ResolveAddressOfOverloadedFunction - Try to resolve the address of an overloaded function (C++ [over...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence...
Definition: SemaInit.cpp:6046
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2610
bool hasConst() const
Definition: Type.h:229
An ordinary object is located at an address in memory.
Definition: Specifiers.h:118
static bool UnwrapDissimilarPointerTypes(QualType &T1, QualType &T2)
UnwrapDissimilarPointerTypes - Like Sema::UnwrapSimilarPointerTypes, this removes one level of indire...
Definition: SemaCast.cpp:426
bool isExtVectorType() const
Definition: Type.h:5374
detail::InMemoryDirectory::const_iterator I
bool isMemberFunctionPointer() const
Returns true if the member type (i.e.
Definition: Type.h:2392
field_iterator field_end() const
Definition: Decl.h:3298
CK_AnyPointerToBlockPointerCast - Casting any non-block pointer to a block pointer.
bool isUnion() const
Definition: Decl.h:2856
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:259
A functional-style cast.
Definition: Sema.h:8203
CastKind
CastKind - The kind of operation required for a conversion.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1759
static TryCastResult TryConstCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, bool CStyle, unsigned &msg)
TryConstCast - See if a const_cast from source to destination is allowed, and perform it if it is...
Definition: SemaCast.cpp:1543
ASTContext * Context
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
bool isFunctionPointerType() const
Definition: Type.h:5323
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1793
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:34
bool hasVolatile() const
Definition: Type.h:236
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:128
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:155
QualType getPointeeType() const
Definition: Type.h:2268
Expr - This represents one expression.
Definition: Expr.h:104
static void diagnoseBadCast(Sema &S, unsigned msg, CastType castType, SourceRange opRange, Expr *src, QualType destType, bool listInitialization)
Diagnose a failed cast.
Definition: SemaCast.cpp:382
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:99
CK_BitCast - A conversion which causes a bit pattern of one type to be reinterpreted as a bit pattern...
static InitializationKind CreateFunctionalCast(SourceRange TypeRange, bool InitList)
Create a direct initialization for a functional cast.
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
Definition: ExprCXX.h:2518
void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath)
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2464
static CXXStaticCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Definition: ExprCXX.cpp:583
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:224
Overload resolution succeeded.
Definition: Overload.h:41
bool isFloatingType() const
Definition: Type.cpp:1777
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
Definition: SemaCast.cpp:236
static TryCastResult TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, Sema::CheckedConversionKind CCK, SourceRange OpRange, unsigned &msg, CastKind &Kind, bool ListInitialization)
TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2 is valid: ...
Definition: SemaCast.cpp:1491
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:6518
void NoteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation())
PrintOverloadCandidates - When overload resolution fails, prints diagnostic messages containing the c...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1751
CK_ConstructorConversion - Conversion by constructor.
static TryCastResult TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath)
TryStaticMemberPointerUpcast - Tests whether a conversion according to C++ 5.2.9p9 is valid: ...
Definition: SemaCast.cpp:1375
bool ResolveAndFixSingleFunctionTemplateSpecialization(ExprResult &SrcExpr, bool DoFunctionPointerConverion=false, bool Complain=false, SourceRange OpRangeForComplaining=SourceRange(), QualType DestTypeForComplaining=QualType(), unsigned DiagIDForComplaining=0)
bool isAtLeastAsQualifiedAs(CanQual< T > Other) const
Determines whether this canonical type is at least as qualified as the Other canonical type...
Type(expr)
Definition: SemaCast.cpp:45
Represents a GCC generic vector type.
Definition: Type.h:2724
static TryCastResult TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath)
Tests whether a conversion according to C++ 5.2.9p5 is valid.
Definition: SemaCast.cpp:1188
FailureKind getFailureKind() const
Determine why initialization failed.
bool isGLValue() const
Definition: Expr.h:249
bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr, CastKind &Kind)
bool isComplexIntegerType() const
Definition: Type.cpp:403
The result type of a method or function.
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3285
void removeCVRQualifiers(unsigned mask)
Definition: Type.h:256
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
Definition: SemaType.cpp:4455
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
Definition: SemaCast.cpp:2463
bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType)
Are the two types lax-compatible vector types? That is, given that one of them is a vector...
Definition: SemaExpr.cpp:5689
CK_CPointerToObjCPointerCast - Casting a C pointer kind to an Objective-C pointer.
static TryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType, bool CStyle, SourceRange OpRange, QualType OrigSrcType, QualType OrigDestType, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath)
TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and TryStaticPointerDowncast.
Definition: SemaCast.cpp:1260
CanQualType OverloadTy
Definition: ASTContext.h:896
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:215
static CXXConstCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Definition: ExprCXX.cpp:690
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2402
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5596
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:145
Encodes a location in the source.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3570
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Prepare a conversion of the given expression to an ObjC object pointer type.
Definition: SemaExpr.cpp:5482
static TryCastResult TryStaticPointerDowncast(Sema &Self, QualType SrcType, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath)
Tests whether a conversion according to C++ 5.2.9p8 is valid.
Definition: SemaCast.cpp:1226
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:397
bool isValid() const
Return true if this is a valid SourceLocation object.
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1701
paths_iterator begin()
CK_ReinterpretMemberPointer - Reinterpret a member pointer as a different kind of member pointer...
ExprResult ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, SourceLocation LAngleBracketLoc, Declarator &D, SourceLocation RAngleBracketLoc, SourceLocation LParenLoc, Expr *E, SourceLocation RParenLoc)
ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
Definition: SemaCast.cpp:213
CK_DerivedToBase - A conversion from a C++ class pointer to a base class pointer. ...
std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)
Builds a string representing ambiguous paths from a specific derived class to different subobjects of...
Ref_Compatible_With_Added_Qualification - The two types are reference-compatible with added qualifica...
Definition: Sema.h:8563
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
Represents a canonical, potentially-qualified type.
Definition: CanonicalType.h:52
CanQualType VoidTy
Definition: ASTContext.h:881
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
Describes the kind of initialization being performed, along with location information for tokens rela...
const_cast
Definition: SemaCast.cpp:40
Overloading for initialization by constructor failed.
is AltiVec vector
Definition: Type.h:2728
SourceLocation getBegin() const
Requests that all candidates be shown.
Definition: Overload.h:50
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:164
bool isVectorType() const
Definition: Type.h:5371
bool isMemberFunctionPointerType() const
Definition: Type.h:5332
void removeObjCGCAttr()
Definition: Type.h:273
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:700
reinterpret_cast
Definition: SemaCast.cpp:42
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:645
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:69
static InitializationKind CreateCast(SourceRange TypeRange)
Create a direct initialization due to a cast that isn't a C-style or functional cast.
static CXXReinterpretCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Definition: ExprCXX.cpp:667
QualType getPointeeType() const
Definition: Type.h:2161
A POD class for pairing a NamedDecl* with an access specifier.
dynamic_cast
Definition: SemaCast.cpp:43
QualType getType() const
Definition: Expr.h:125
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
bool isInvalidDecl() const
Definition: DeclBase.h:509
CK_BaseToDerived - A conversion from a C++ class pointer/reference to a derived class pointer/referen...
void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, bool IsDereference, SourceRange Range)
Definition: SemaCast.cpp:1660
The cast method is appropriate, but failed.
Definition: SemaCast.cpp:35
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
Definition: Expr.h:246
static void checkIntToPointerCast(bool CStyle, SourceLocation Loc, const Expr *SrcExpr, QualType DestType, Sema &Self)
Definition: SemaCast.cpp:1727
Requests that only viable candidates be shown.
Definition: Overload.h:53
detail::InMemoryDirectory::const_iterator E
bool isAmbiguous(CanQualType BaseType)
Determine whether the path from the most-derived type to the given base type is ambiguous (i...
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2369
ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, SourceLocation LParenLoc, Expr *CastExpr, SourceLocation RParenLoc)
Definition: SemaCast.cpp:2486
bool isHalfType() const
Definition: Type.h:5552
void setCVRQualifiers(unsigned mask)
Definition: Type.h:252
static InitializationKind CreateCStyleCast(SourceLocation StartLoc, SourceRange TypeRange, bool InitList)
Create a direct initialization for a C-style cast.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1946
static void DiagnoseCastOfObjCSEL(Sema &Self, const ExprResult &SrcExpr, QualType DestType)
Definition: SemaCast.cpp:1710
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1459
bool isRValueReferenceType() const
Definition: Type.h:5320
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:4836
Represents a pointer to an Objective C object.
Definition: Type.h:4821
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:127
Pointer to a block type.
Definition: Type.h:2254
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3544
static bool tryDiagnoseOverloadedCast(Sema &S, CastType CT, SourceRange range, Expr *src, QualType destType, bool listInitialization)
Try to diagnose a failed overloaded cast.
Definition: SemaCast.cpp:306
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
bool isAddressSpaceOverlapping(const PointerType &other) const
Returns true if address spaces of pointers overlap.
Definition: Type.h:2171
QualType getCanonicalType() const
Definition: Type.h:5128
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
Definition: Expr.cpp:1780
bool isFunctionType() const
Definition: Type.h:5302
CK_LValueBitCast - A conversion which reinterprets the address of an l-value as an l-value of a diffe...
CXXBasePath & front()
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2287
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1522
static bool CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType, bool CheckCVR, bool CheckObjCLifetime, QualType *TheOffendingSrcType=nullptr, QualType *TheOffendingDestType=nullptr, Qualifiers *CastAwayQualifiers=nullptr)
CastsAwayConstness - Check if the pointer conversion from SrcType to DestType casts away constness as...
Definition: SemaCast.cpp:486
static TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, QualType DestType, bool CStyle, CastKind &Kind, CXXCastPath &BasePath, unsigned &msg)
Tests whether a conversion according to N2844 is valid.
Definition: SemaCast.cpp:1134
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
A bitfield object is a bitfield on a C or C++ record.
Definition: Specifiers.h:121
bool isUsable() const
Definition: Ownership.h:160
QualType getPointeeType() const
Definition: Type.h:2308
OverloadingResult getFailedOverloadResult() const
Get the overloading result, for when the initialization sequence failed due to a bad overload...
const Type * getClass() const
Definition: Type.h:2402
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang's AST.
Definition: ASTMatchers.h:1695
bool Failed() const
Determine whether the initialization sequence is invalid.
Describes the sequence of initializations required to initialize a given object or reference with a s...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5169
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
bool isObjCObjectPointerType() const
Definition: Type.h:5377
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
Definition: Type.h:5520
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
Checks access for a hierarchy conversion.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:115
This class is used for builtin types like 'int'.
Definition: Type.h:2011
Defines the clang::TargetInfo interface.
DeclarationName getName() const
Gets the name looked up.
Definition: ExprCXX.h:2506
ExprResult ExprError()
Definition: Ownership.h:267
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
static void DiagnoseBadFunctionCast(Sema &Self, const ExprResult &SrcExpr, QualType DestType)
DiagnoseBadFunctionCast - Warn whenever a function call is cast to a non-matching type...
Definition: SemaCast.cpp:2186
CK_NoOp - A conversion which does not affect the type other than (possibly) adding qualifiers...
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:400
CK_DerivedToBaseMemberPointer - Member pointer in derived class to member pointer in base class...
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
No viable function found.
Definition: Overload.h:42
bool isConstructorInitialization() const
Determine whether this initialization is direct call to a constructor.
Definition: SemaInit.cpp:3028
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:295
paths_iterator end()
bool isInvalidType() const
Definition: DeclSpec.h:2200
bool isArithmeticType() const
Definition: Type.cpp:1808
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1700
Describes an entity that is being initialized.
CK_ToVoid - Cast to void, discarding the computed value.
bool isIntegralType(ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1619
std::list< CXXBasePath >::iterator paths_iterator
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
CastType
Definition: SemaCast.cpp:39
static void DiagnoseReinterpretUpDownCast(Sema &Self, const Expr *SrcExpr, QualType DestType, SourceRange OpRange)
Check that a reinterpret_cast<DestType>(SrcExpr) is not used as upcast or downcast between respective...
Definition: SemaCast.cpp:745
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:5568
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5116
bool isPointerType() const
Definition: Type.h:5305
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1551