clang  3.9.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"
25 #include "clang/Lex/Preprocessor.h"
27 #include "llvm/ADT/SmallVector.h"
28 #include <set>
29 using namespace clang;
30 
31 
32 
34  TC_NotApplicable, ///< The cast method is not applicable.
35  TC_Success, ///< The cast method is appropriate and successful.
36  TC_Failed ///< The cast method is appropriate, but failed. A
37  ///< diagnostic has been emitted.
38 };
39 
40 enum CastType {
41  CT_Const, ///< const_cast
42  CT_Static, ///< static_cast
43  CT_Reinterpret, ///< reinterpret_cast
44  CT_Dynamic, ///< dynamic_cast
45  CT_CStyle, ///< (Type)expr
46  CT_Functional ///< Type(expr)
47 };
48 
49 namespace {
50  struct CastOperation {
51  CastOperation(Sema &S, QualType destType, ExprResult src)
52  : Self(S), SrcExpr(src), DestType(destType),
53  ResultType(destType.getNonLValueExprType(S.Context)),
54  ValueKind(Expr::getValueKindForType(destType)),
55  Kind(CK_Dependent), IsARCUnbridgedCast(false) {
56 
57  if (const BuiltinType *placeholder =
58  src.get()->getType()->getAsPlaceholderType()) {
59  PlaceholderKind = placeholder->getKind();
60  } else {
61  PlaceholderKind = (BuiltinType::Kind) 0;
62  }
63  }
64 
65  Sema &Self;
66  ExprResult SrcExpr;
67  QualType DestType;
68  QualType ResultType;
69  ExprValueKind ValueKind;
70  CastKind Kind;
71  BuiltinType::Kind PlaceholderKind;
72  CXXCastPath BasePath;
73  bool IsARCUnbridgedCast;
74 
75  SourceRange OpRange;
76  SourceRange DestRange;
77 
78  // Top-level semantics-checking routines.
79  void CheckConstCast();
80  void CheckReinterpretCast();
81  void CheckStaticCast();
82  void CheckDynamicCast();
83  void CheckCXXCStyleCast(bool FunctionalCast, bool ListInitialization);
84  void CheckCStyleCast();
85 
86  /// Complete an apparently-successful cast operation that yields
87  /// the given expression.
88  ExprResult complete(CastExpr *castExpr) {
89  // If this is an unbridged cast, wrap the result in an implicit
90  // cast that yields the unbridged-cast placeholder type.
91  if (IsARCUnbridgedCast) {
92  castExpr = ImplicitCastExpr::Create(Self.Context,
93  Self.Context.ARCUnbridgedCastTy,
94  CK_Dependent, castExpr, nullptr,
95  castExpr->getValueKind());
96  }
97  return castExpr;
98  }
99 
100  // Internal convenience methods.
101 
102  /// Try to handle the given placeholder expression kind. Return
103  /// true if the source expression has the appropriate placeholder
104  /// kind. A placeholder can only be claimed once.
105  bool claimPlaceholder(BuiltinType::Kind K) {
106  if (PlaceholderKind != K) return false;
107 
108  PlaceholderKind = (BuiltinType::Kind) 0;
109  return true;
110  }
111 
112  bool isPlaceholder() const {
113  return PlaceholderKind != 0;
114  }
115  bool isPlaceholder(BuiltinType::Kind K) const {
116  return PlaceholderKind == K;
117  }
118 
119  void checkCastAlign() {
120  Self.CheckCastAlign(SrcExpr.get(), DestType, OpRange);
121  }
122 
123  void checkObjCARCConversion(Sema::CheckedConversionKind CCK) {
124  assert(Self.getLangOpts().ObjCAutoRefCount);
125 
126  Expr *src = SrcExpr.get();
127  if (Self.CheckObjCARCConversion(OpRange, DestType, src, CCK) ==
129  IsARCUnbridgedCast = true;
130  SrcExpr = src;
131  }
132 
133  /// Check for and handle non-overload placeholder expressions.
134  void checkNonOverloadPlaceholders() {
135  if (!isPlaceholder() || isPlaceholder(BuiltinType::Overload))
136  return;
137 
138  SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get());
139  if (SrcExpr.isInvalid())
140  return;
141  PlaceholderKind = (BuiltinType::Kind) 0;
142  }
143  };
144 }
145 
146 // The Try functions attempt a specific way of casting. If they succeed, they
147 // return TC_Success. If their way of casting is not appropriate for the given
148 // arguments, they return TC_NotApplicable and *may* set diag to a diagnostic
149 // to emit if no other way succeeds. If their way of casting is appropriate but
150 // fails, they return TC_Failed and *must* set diag; they can set it to 0 if
151 // they emit a specialized diagnostic.
152 // All diagnostics returned by these functions must expect the same three
153 // arguments:
154 // %0: Cast Type (a value from the CastType enumeration)
155 // %1: Source Type
156 // %2: Destination Type
157 static TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr,
158  QualType DestType, bool CStyle,
159  CastKind &Kind,
160  CXXCastPath &BasePath,
161  unsigned &msg);
162 static TryCastResult TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr,
163  QualType DestType, bool CStyle,
164  SourceRange OpRange,
165  unsigned &msg,
166  CastKind &Kind,
167  CXXCastPath &BasePath);
169  QualType DestType, bool CStyle,
170  SourceRange OpRange,
171  unsigned &msg,
172  CastKind &Kind,
173  CXXCastPath &BasePath);
174 static TryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType,
175  CanQualType DestType, bool CStyle,
176  SourceRange OpRange,
177  QualType OrigSrcType,
178  QualType OrigDestType, unsigned &msg,
179  CastKind &Kind,
180  CXXCastPath &BasePath);
182  QualType SrcType,
183  QualType DestType,bool CStyle,
184  SourceRange OpRange,
185  unsigned &msg,
186  CastKind &Kind,
187  CXXCastPath &BasePath);
188 
189 static TryCastResult TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr,
190  QualType DestType,
192  SourceRange OpRange,
193  unsigned &msg, CastKind &Kind,
194  bool ListInitialization);
195 static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr,
196  QualType DestType,
198  SourceRange OpRange,
199  unsigned &msg, CastKind &Kind,
200  CXXCastPath &BasePath,
201  bool ListInitialization);
202 static TryCastResult TryConstCast(Sema &Self, ExprResult &SrcExpr,
203  QualType DestType, bool CStyle,
204  unsigned &msg);
205 static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
206  QualType DestType, bool CStyle,
207  SourceRange OpRange,
208  unsigned &msg,
209  CastKind &Kind);
210 
211 
212 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
215  SourceLocation LAngleBracketLoc, Declarator &D,
216  SourceLocation RAngleBracketLoc,
217  SourceLocation LParenLoc, Expr *E,
218  SourceLocation RParenLoc) {
219 
220  assert(!D.isInvalidType());
221 
223  if (D.isInvalidType())
224  return ExprError();
225 
226  if (getLangOpts().CPlusPlus) {
227  // Check that there are no default arguments (C++ only).
229  }
230 
231  return BuildCXXNamedCast(OpLoc, Kind, TInfo, E,
232  SourceRange(LAngleBracketLoc, RAngleBracketLoc),
233  SourceRange(LParenLoc, RParenLoc));
234 }
235 
238  TypeSourceInfo *DestTInfo, Expr *E,
239  SourceRange AngleBrackets, SourceRange Parens) {
240  ExprResult Ex = E;
241  QualType DestType = DestTInfo->getType();
242 
243  // If the type is dependent, we won't do the semantic analysis now.
244  bool TypeDependent =
245  DestType->isDependentType() || Ex.get()->isTypeDependent();
246 
247  CastOperation Op(*this, DestType, E);
248  Op.OpRange = SourceRange(OpLoc, Parens.getEnd());
249  Op.DestRange = AngleBrackets;
250 
251  switch (Kind) {
252  default: llvm_unreachable("Unknown C++ cast!");
253 
254  case tok::kw_const_cast:
255  if (!TypeDependent) {
256  Op.CheckConstCast();
257  if (Op.SrcExpr.isInvalid())
258  return ExprError();
259  }
260  return Op.complete(CXXConstCastExpr::Create(Context, Op.ResultType,
261  Op.ValueKind, Op.SrcExpr.get(), DestTInfo,
262  OpLoc, Parens.getEnd(),
263  AngleBrackets));
264 
265  case tok::kw_dynamic_cast: {
266  if (!TypeDependent) {
267  Op.CheckDynamicCast();
268  if (Op.SrcExpr.isInvalid())
269  return ExprError();
270  }
271  return Op.complete(CXXDynamicCastExpr::Create(Context, Op.ResultType,
272  Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
273  &Op.BasePath, DestTInfo,
274  OpLoc, Parens.getEnd(),
275  AngleBrackets));
276  }
277  case tok::kw_reinterpret_cast: {
278  if (!TypeDependent) {
279  Op.CheckReinterpretCast();
280  if (Op.SrcExpr.isInvalid())
281  return ExprError();
282  }
283  return Op.complete(CXXReinterpretCastExpr::Create(Context, Op.ResultType,
284  Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
285  nullptr, DestTInfo, OpLoc,
286  Parens.getEnd(),
287  AngleBrackets));
288  }
289  case tok::kw_static_cast: {
290  if (!TypeDependent) {
291  Op.CheckStaticCast();
292  if (Op.SrcExpr.isInvalid())
293  return ExprError();
294  }
295 
296  return Op.complete(CXXStaticCastExpr::Create(Context, Op.ResultType,
297  Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
298  &Op.BasePath, DestTInfo,
299  OpLoc, Parens.getEnd(),
300  AngleBrackets));
301  }
302  }
303 }
304 
305 /// Try to diagnose a failed overloaded cast. Returns true if
306 /// diagnostics were emitted.
308  SourceRange range, Expr *src,
309  QualType destType,
310  bool listInitialization) {
311  switch (CT) {
312  // These cast kinds don't consider user-defined conversions.
313  case CT_Const:
314  case CT_Reinterpret:
315  case CT_Dynamic:
316  return false;
317 
318  // These do.
319  case CT_Static:
320  case CT_CStyle:
321  case CT_Functional:
322  break;
323  }
324 
325  QualType srcType = src->getType();
326  if (!destType->isRecordType() && !srcType->isRecordType())
327  return false;
328 
330  InitializationKind initKind
332  range, listInitialization)
334  listInitialization)
335  : InitializationKind::CreateCast(/*type range?*/ range);
336  InitializationSequence sequence(S, entity, initKind, src);
337 
338  assert(sequence.Failed() && "initialization succeeded on second try?");
339  switch (sequence.getFailureKind()) {
340  default: return false;
341 
344  break;
345  }
346 
347  OverloadCandidateSet &candidates = sequence.getFailedCandidateSet();
348 
349  unsigned msg = 0;
351 
352  switch (sequence.getFailedOverloadResult()) {
353  case OR_Success: llvm_unreachable("successful failed overload");
355  if (candidates.empty())
356  msg = diag::err_ovl_no_conversion_in_cast;
357  else
358  msg = diag::err_ovl_no_viable_conversion_in_cast;
359  howManyCandidates = OCD_AllCandidates;
360  break;
361 
362  case OR_Ambiguous:
363  msg = diag::err_ovl_ambiguous_conversion_in_cast;
364  howManyCandidates = OCD_ViableCandidates;
365  break;
366 
367  case OR_Deleted:
368  msg = diag::err_ovl_deleted_conversion_in_cast;
369  howManyCandidates = OCD_ViableCandidates;
370  break;
371  }
372 
373  S.Diag(range.getBegin(), msg)
374  << CT << srcType << destType
375  << range << src->getSourceRange();
376 
377  candidates.NoteCandidates(S, howManyCandidates, src);
378 
379  return true;
380 }
381 
382 /// Diagnose a failed cast.
383 static void diagnoseBadCast(Sema &S, unsigned msg, CastType castType,
384  SourceRange opRange, Expr *src, QualType destType,
385  bool listInitialization) {
386  if (msg == diag::err_bad_cxx_cast_generic &&
387  tryDiagnoseOverloadedCast(S, castType, opRange, src, destType,
388  listInitialization))
389  return;
390 
391  S.Diag(opRange.getBegin(), msg) << castType
392  << src->getType() << destType << opRange << src->getSourceRange();
393 
394  // Detect if both types are (ptr to) class, and note any incompleteness.
395  int DifferentPtrness = 0;
396  QualType From = destType;
397  if (auto Ptr = From->getAs<PointerType>()) {
398  From = Ptr->getPointeeType();
399  DifferentPtrness++;
400  }
401  QualType To = src->getType();
402  if (auto Ptr = To->getAs<PointerType>()) {
403  To = Ptr->getPointeeType();
404  DifferentPtrness--;
405  }
406  if (!DifferentPtrness) {
407  auto RecFrom = From->getAs<RecordType>();
408  auto RecTo = To->getAs<RecordType>();
409  if (RecFrom && RecTo) {
410  auto DeclFrom = RecFrom->getAsCXXRecordDecl();
411  if (!DeclFrom->isCompleteDefinition())
412  S.Diag(DeclFrom->getLocation(), diag::note_type_incomplete)
413  << DeclFrom->getDeclName();
414  auto DeclTo = RecTo->getAsCXXRecordDecl();
415  if (!DeclTo->isCompleteDefinition())
416  S.Diag(DeclTo->getLocation(), diag::note_type_incomplete)
417  << DeclTo->getDeclName();
418  }
419  }
420 }
421 
422 /// UnwrapDissimilarPointerTypes - Like Sema::UnwrapSimilarPointerTypes,
423 /// this removes one level of indirection from both types, provided that they're
424 /// the same kind of pointer (plain or to-member). Unlike the Sema function,
425 /// this one doesn't care if the two pointers-to-member don't point into the
426 /// same class. This is because CastsAwayConstness doesn't care.
428  const PointerType *T1PtrType = T1->getAs<PointerType>(),
429  *T2PtrType = T2->getAs<PointerType>();
430  if (T1PtrType && T2PtrType) {
431  T1 = T1PtrType->getPointeeType();
432  T2 = T2PtrType->getPointeeType();
433  return true;
434  }
435  const ObjCObjectPointerType *T1ObjCPtrType =
437  *T2ObjCPtrType =
439  if (T1ObjCPtrType) {
440  if (T2ObjCPtrType) {
441  T1 = T1ObjCPtrType->getPointeeType();
442  T2 = T2ObjCPtrType->getPointeeType();
443  return true;
444  }
445  else if (T2PtrType) {
446  T1 = T1ObjCPtrType->getPointeeType();
447  T2 = T2PtrType->getPointeeType();
448  return true;
449  }
450  }
451  else if (T2ObjCPtrType) {
452  if (T1PtrType) {
453  T2 = T2ObjCPtrType->getPointeeType();
454  T1 = T1PtrType->getPointeeType();
455  return true;
456  }
457  }
458 
459  const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(),
460  *T2MPType = T2->getAs<MemberPointerType>();
461  if (T1MPType && T2MPType) {
462  T1 = T1MPType->getPointeeType();
463  T2 = T2MPType->getPointeeType();
464  return true;
465  }
466 
467  const BlockPointerType *T1BPType = T1->getAs<BlockPointerType>(),
468  *T2BPType = T2->getAs<BlockPointerType>();
469  if (T1BPType && T2BPType) {
470  T1 = T1BPType->getPointeeType();
471  T2 = T2BPType->getPointeeType();
472  return true;
473  }
474 
475  return false;
476 }
477 
478 /// CastsAwayConstness - Check if the pointer conversion from SrcType to
479 /// DestType casts away constness as defined in C++ 5.2.11p8ff. This is used by
480 /// the cast checkers. Both arguments must denote pointer (possibly to member)
481 /// types.
482 ///
483 /// \param CheckCVR Whether to check for const/volatile/restrict qualifiers.
484 ///
485 /// \param CheckObjCLifetime Whether to check Objective-C lifetime qualifiers.
486 static bool
487 CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType,
488  bool CheckCVR, bool CheckObjCLifetime,
489  QualType *TheOffendingSrcType = nullptr,
490  QualType *TheOffendingDestType = nullptr,
491  Qualifiers *CastAwayQualifiers = nullptr) {
492  // If the only checking we care about is for Objective-C lifetime qualifiers,
493  // and we're not in ObjC mode, there's nothing to check.
494  if (!CheckCVR && CheckObjCLifetime &&
495  !Self.Context.getLangOpts().ObjC1)
496  return false;
497 
498  // Casting away constness is defined in C++ 5.2.11p8 with reference to
499  // C++ 4.4. We piggyback on Sema::IsQualificationConversion for this, since
500  // the rules are non-trivial. So first we construct Tcv *...cv* as described
501  // in C++ 5.2.11p8.
502  assert((SrcType->isAnyPointerType() || SrcType->isMemberPointerType() ||
503  SrcType->isBlockPointerType()) &&
504  "Source type is not pointer or pointer to member.");
505  assert((DestType->isAnyPointerType() || DestType->isMemberPointerType() ||
506  DestType->isBlockPointerType()) &&
507  "Destination type is not pointer or pointer to member.");
508 
509  QualType UnwrappedSrcType = Self.Context.getCanonicalType(SrcType),
510  UnwrappedDestType = Self.Context.getCanonicalType(DestType);
512 
513  // Find the qualifiers. We only care about cvr-qualifiers for the
514  // purpose of this check, because other qualifiers (address spaces,
515  // Objective-C GC, etc.) are part of the type's identity.
516  QualType PrevUnwrappedSrcType = UnwrappedSrcType;
517  QualType PrevUnwrappedDestType = UnwrappedDestType;
518  while (UnwrapDissimilarPointerTypes(UnwrappedSrcType, UnwrappedDestType)) {
519  // Determine the relevant qualifiers at this level.
520  Qualifiers SrcQuals, DestQuals;
521  Self.Context.getUnqualifiedArrayType(UnwrappedSrcType, SrcQuals);
522  Self.Context.getUnqualifiedArrayType(UnwrappedDestType, DestQuals);
523 
524  Qualifiers RetainedSrcQuals, RetainedDestQuals;
525  if (CheckCVR) {
526  RetainedSrcQuals.setCVRQualifiers(SrcQuals.getCVRQualifiers());
527  RetainedDestQuals.setCVRQualifiers(DestQuals.getCVRQualifiers());
528 
529  if (RetainedSrcQuals != RetainedDestQuals && TheOffendingSrcType &&
530  TheOffendingDestType && CastAwayQualifiers) {
531  *TheOffendingSrcType = PrevUnwrappedSrcType;
532  *TheOffendingDestType = PrevUnwrappedDestType;
533  *CastAwayQualifiers = RetainedSrcQuals - RetainedDestQuals;
534  }
535  }
536 
537  if (CheckObjCLifetime &&
538  !DestQuals.compatiblyIncludesObjCLifetime(SrcQuals))
539  return true;
540 
541  cv1.push_back(RetainedSrcQuals);
542  cv2.push_back(RetainedDestQuals);
543 
544  PrevUnwrappedSrcType = UnwrappedSrcType;
545  PrevUnwrappedDestType = UnwrappedDestType;
546  }
547  if (cv1.empty())
548  return false;
549 
550  // Construct void pointers with those qualifiers (in reverse order of
551  // unwrapping, of course).
552  QualType SrcConstruct = Self.Context.VoidTy;
553  QualType DestConstruct = Self.Context.VoidTy;
554  ASTContext &Context = Self.Context;
555  for (SmallVectorImpl<Qualifiers>::reverse_iterator i1 = cv1.rbegin(),
556  i2 = cv2.rbegin();
557  i1 != cv1.rend(); ++i1, ++i2) {
558  SrcConstruct
559  = Context.getPointerType(Context.getQualifiedType(SrcConstruct, *i1));
560  DestConstruct
561  = Context.getPointerType(Context.getQualifiedType(DestConstruct, *i2));
562  }
563 
564  // Test if they're compatible.
565  bool ObjCLifetimeConversion;
566  return SrcConstruct != DestConstruct &&
567  !Self.IsQualificationConversion(SrcConstruct, DestConstruct, false,
568  ObjCLifetimeConversion);
569 }
570 
571 /// CheckDynamicCast - Check that a dynamic_cast<DestType>(SrcExpr) is valid.
572 /// Refer to C++ 5.2.7 for details. Dynamic casts are used mostly for runtime-
573 /// checked downcasts in class hierarchies.
574 void CastOperation::CheckDynamicCast() {
575  if (ValueKind == VK_RValue)
576  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
577  else if (isPlaceholder())
578  SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get());
579  if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
580  return;
581 
582  QualType OrigSrcType = SrcExpr.get()->getType();
583  QualType DestType = Self.Context.getCanonicalType(this->DestType);
584 
585  // C++ 5.2.7p1: T shall be a pointer or reference to a complete class type,
586  // or "pointer to cv void".
587 
588  QualType DestPointee;
589  const PointerType *DestPointer = DestType->getAs<PointerType>();
590  const ReferenceType *DestReference = nullptr;
591  if (DestPointer) {
592  DestPointee = DestPointer->getPointeeType();
593  } else if ((DestReference = DestType->getAs<ReferenceType>())) {
594  DestPointee = DestReference->getPointeeType();
595  } else {
596  Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ref_or_ptr)
597  << this->DestType << DestRange;
598  SrcExpr = ExprError();
599  return;
600  }
601 
602  const RecordType *DestRecord = DestPointee->getAs<RecordType>();
603  if (DestPointee->isVoidType()) {
604  assert(DestPointer && "Reference to void is not possible");
605  } else if (DestRecord) {
606  if (Self.RequireCompleteType(OpRange.getBegin(), DestPointee,
607  diag::err_bad_dynamic_cast_incomplete,
608  DestRange)) {
609  SrcExpr = ExprError();
610  return;
611  }
612  } else {
613  Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)
614  << DestPointee.getUnqualifiedType() << DestRange;
615  SrcExpr = ExprError();
616  return;
617  }
618 
619  // C++0x 5.2.7p2: If T is a pointer type, v shall be an rvalue of a pointer to
620  // complete class type, [...]. If T is an lvalue reference type, v shall be
621  // an lvalue of a complete class type, [...]. If T is an rvalue reference
622  // type, v shall be an expression having a complete class type, [...]
623  QualType SrcType = Self.Context.getCanonicalType(OrigSrcType);
624  QualType SrcPointee;
625  if (DestPointer) {
626  if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) {
627  SrcPointee = SrcPointer->getPointeeType();
628  } else {
629  Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ptr)
630  << OrigSrcType << SrcExpr.get()->getSourceRange();
631  SrcExpr = ExprError();
632  return;
633  }
634  } else if (DestReference->isLValueReferenceType()) {
635  if (!SrcExpr.get()->isLValue()) {
636  Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_rvalue)
637  << CT_Dynamic << OrigSrcType << this->DestType << OpRange;
638  }
639  SrcPointee = SrcType;
640  } else {
641  // If we're dynamic_casting from a prvalue to an rvalue reference, we need
642  // to materialize the prvalue before we bind the reference to it.
643  if (SrcExpr.get()->isRValue())
644  SrcExpr = Self.CreateMaterializeTemporaryExpr(
645  SrcType, SrcExpr.get(), /*IsLValueReference*/ false);
646  SrcPointee = SrcType;
647  }
648 
649  const RecordType *SrcRecord = SrcPointee->getAs<RecordType>();
650  if (SrcRecord) {
651  if (Self.RequireCompleteType(OpRange.getBegin(), SrcPointee,
652  diag::err_bad_dynamic_cast_incomplete,
653  SrcExpr.get())) {
654  SrcExpr = ExprError();
655  return;
656  }
657  } else {
658  Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class)
659  << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange();
660  SrcExpr = ExprError();
661  return;
662  }
663 
664  assert((DestPointer || DestReference) &&
665  "Bad destination non-ptr/ref slipped through.");
666  assert((DestRecord || DestPointee->isVoidType()) &&
667  "Bad destination pointee slipped through.");
668  assert(SrcRecord && "Bad source pointee slipped through.");
669 
670  // C++ 5.2.7p1: The dynamic_cast operator shall not cast away constness.
671  if (!DestPointee.isAtLeastAsQualifiedAs(SrcPointee)) {
672  Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_qualifiers_away)
673  << CT_Dynamic << OrigSrcType << this->DestType << OpRange;
674  SrcExpr = ExprError();
675  return;
676  }
677 
678  // C++ 5.2.7p3: If the type of v is the same as the required result type,
679  // [except for cv].
680  if (DestRecord == SrcRecord) {
681  Kind = CK_NoOp;
682  return;
683  }
684 
685  // C++ 5.2.7p5
686  // Upcasts are resolved statically.
687  if (DestRecord &&
688  Self.IsDerivedFrom(OpRange.getBegin(), SrcPointee, DestPointee)) {
689  if (Self.CheckDerivedToBaseConversion(SrcPointee, DestPointee,
690  OpRange.getBegin(), OpRange,
691  &BasePath)) {
692  SrcExpr = ExprError();
693  return;
694  }
695 
696  Kind = CK_DerivedToBase;
697  return;
698  }
699 
700  // C++ 5.2.7p6: Otherwise, v shall be [polymorphic].
701  const RecordDecl *SrcDecl = SrcRecord->getDecl()->getDefinition();
702  assert(SrcDecl && "Definition missing");
703  if (!cast<CXXRecordDecl>(SrcDecl)->isPolymorphic()) {
704  Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_polymorphic)
705  << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange();
706  SrcExpr = ExprError();
707  }
708 
709  // dynamic_cast is not available with -fno-rtti.
710  // As an exception, dynamic_cast to void* is available because it doesn't
711  // use RTTI.
712  if (!Self.getLangOpts().RTTI && !DestPointee->isVoidType()) {
713  Self.Diag(OpRange.getBegin(), diag::err_no_dynamic_cast_with_fno_rtti);
714  SrcExpr = ExprError();
715  return;
716  }
717 
718  // Done. Everything else is run-time checks.
719  Kind = CK_Dynamic;
720 }
721 
722 /// CheckConstCast - Check that a const_cast<DestType>(SrcExpr) is valid.
723 /// Refer to C++ 5.2.11 for details. const_cast is typically used in code
724 /// like this:
725 /// const char *str = "literal";
726 /// legacy_function(const_cast<char*>(str));
727 void CastOperation::CheckConstCast() {
728  if (ValueKind == VK_RValue)
729  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
730  else if (isPlaceholder())
731  SrcExpr = Self.CheckPlaceholderExpr(SrcExpr.get());
732  if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
733  return;
734 
735  unsigned msg = diag::err_bad_cxx_cast_generic;
736  if (TryConstCast(Self, SrcExpr, DestType, /*CStyle*/false, msg) != TC_Success
737  && msg != 0) {
738  Self.Diag(OpRange.getBegin(), msg) << CT_Const
739  << SrcExpr.get()->getType() << DestType << OpRange;
740  SrcExpr = ExprError();
741  }
742 }
743 
744 /// Check that a reinterpret_cast<DestType>(SrcExpr) is not used as upcast
745 /// or downcast between respective pointers or references.
746 static void DiagnoseReinterpretUpDownCast(Sema &Self, const Expr *SrcExpr,
747  QualType DestType,
748  SourceRange OpRange) {
749  QualType SrcType = SrcExpr->getType();
750  // When casting from pointer or reference, get pointee type; use original
751  // type otherwise.
752  const CXXRecordDecl *SrcPointeeRD = SrcType->getPointeeCXXRecordDecl();
753  const CXXRecordDecl *SrcRD =
754  SrcPointeeRD ? SrcPointeeRD : SrcType->getAsCXXRecordDecl();
755 
756  // Examining subobjects for records is only possible if the complete and
757  // valid definition is available. Also, template instantiation is not
758  // allowed here.
759  if (!SrcRD || !SrcRD->isCompleteDefinition() || SrcRD->isInvalidDecl())
760  return;
761 
762  const CXXRecordDecl *DestRD = DestType->getPointeeCXXRecordDecl();
763 
764  if (!DestRD || !DestRD->isCompleteDefinition() || DestRD->isInvalidDecl())
765  return;
766 
767  enum {
768  ReinterpretUpcast,
769  ReinterpretDowncast
770  } ReinterpretKind;
771 
772  CXXBasePaths BasePaths;
773 
774  if (SrcRD->isDerivedFrom(DestRD, BasePaths))
775  ReinterpretKind = ReinterpretUpcast;
776  else if (DestRD->isDerivedFrom(SrcRD, BasePaths))
777  ReinterpretKind = ReinterpretDowncast;
778  else
779  return;
780 
781  bool VirtualBase = true;
782  bool NonZeroOffset = false;
783  for (CXXBasePaths::const_paths_iterator I = BasePaths.begin(),
784  E = BasePaths.end();
785  I != E; ++I) {
786  const CXXBasePath &Path = *I;
788  bool IsVirtual = false;
789  for (CXXBasePath::const_iterator IElem = Path.begin(), EElem = Path.end();
790  IElem != EElem; ++IElem) {
791  IsVirtual = IElem->Base->isVirtual();
792  if (IsVirtual)
793  break;
794  const CXXRecordDecl *BaseRD = IElem->Base->getType()->getAsCXXRecordDecl();
795  assert(BaseRD && "Base type should be a valid unqualified class type");
796  // Don't check if any base has invalid declaration or has no definition
797  // since it has no layout info.
798  const CXXRecordDecl *Class = IElem->Class,
799  *ClassDefinition = Class->getDefinition();
800  if (Class->isInvalidDecl() || !ClassDefinition ||
801  !ClassDefinition->isCompleteDefinition())
802  return;
803 
804  const ASTRecordLayout &DerivedLayout =
805  Self.Context.getASTRecordLayout(Class);
806  Offset += DerivedLayout.getBaseClassOffset(BaseRD);
807  }
808  if (!IsVirtual) {
809  // Don't warn if any path is a non-virtually derived base at offset zero.
810  if (Offset.isZero())
811  return;
812  // Offset makes sense only for non-virtual bases.
813  else
814  NonZeroOffset = true;
815  }
816  VirtualBase = VirtualBase && IsVirtual;
817  }
818 
819  (void) NonZeroOffset; // Silence set but not used warning.
820  assert((VirtualBase || NonZeroOffset) &&
821  "Should have returned if has non-virtual base with zero offset");
822 
823  QualType BaseType =
824  ReinterpretKind == ReinterpretUpcast? DestType : SrcType;
825  QualType DerivedType =
826  ReinterpretKind == ReinterpretUpcast? SrcType : DestType;
827 
828  SourceLocation BeginLoc = OpRange.getBegin();
829  Self.Diag(BeginLoc, diag::warn_reinterpret_different_from_static)
830  << DerivedType << BaseType << !VirtualBase << int(ReinterpretKind)
831  << OpRange;
832  Self.Diag(BeginLoc, diag::note_reinterpret_updowncast_use_static)
833  << int(ReinterpretKind)
834  << FixItHint::CreateReplacement(BeginLoc, "static_cast");
835 }
836 
837 /// CheckReinterpretCast - Check that a reinterpret_cast<DestType>(SrcExpr) is
838 /// valid.
839 /// Refer to C++ 5.2.10 for details. reinterpret_cast is typically used in code
840 /// like this:
841 /// char *bytes = reinterpret_cast<char*>(int_ptr);
842 void CastOperation::CheckReinterpretCast() {
843  if (ValueKind == VK_RValue && !isPlaceholder(BuiltinType::Overload))
844  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
845  else
846  checkNonOverloadPlaceholders();
847  if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
848  return;
849 
850  unsigned msg = diag::err_bad_cxx_cast_generic;
851  TryCastResult tcr =
852  TryReinterpretCast(Self, SrcExpr, DestType,
853  /*CStyle*/false, OpRange, msg, Kind);
854  if (tcr != TC_Success && msg != 0)
855  {
856  if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
857  return;
858  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
859  //FIXME: &f<int>; is overloaded and resolvable
860  Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_overload)
861  << OverloadExpr::find(SrcExpr.get()).Expression->getName()
862  << DestType << OpRange;
863  Self.NoteAllOverloadCandidates(SrcExpr.get());
864 
865  } else {
866  diagnoseBadCast(Self, msg, CT_Reinterpret, OpRange, SrcExpr.get(),
867  DestType, /*listInitialization=*/false);
868  }
869  SrcExpr = ExprError();
870  } else if (tcr == TC_Success) {
871  if (Self.getLangOpts().ObjCAutoRefCount)
872  checkObjCARCConversion(Sema::CCK_OtherCast);
873  DiagnoseReinterpretUpDownCast(Self, SrcExpr.get(), DestType, OpRange);
874  }
875 }
876 
877 
878 /// CheckStaticCast - Check that a static_cast<DestType>(SrcExpr) is valid.
879 /// Refer to C++ 5.2.9 for details. Static casts are mostly used for making
880 /// implicit conversions explicit and getting rid of data loss warnings.
881 void CastOperation::CheckStaticCast() {
882  if (isPlaceholder()) {
883  checkNonOverloadPlaceholders();
884  if (SrcExpr.isInvalid())
885  return;
886  }
887 
888  // This test is outside everything else because it's the only case where
889  // a non-lvalue-reference target type does not lead to decay.
890  // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
891  if (DestType->isVoidType()) {
892  Kind = CK_ToVoid;
893 
894  if (claimPlaceholder(BuiltinType::Overload)) {
895  Self.ResolveAndFixSingleFunctionTemplateSpecialization(SrcExpr,
896  false, // Decay Function to ptr
897  true, // Complain
898  OpRange, DestType, diag::err_bad_static_cast_overload);
899  if (SrcExpr.isInvalid())
900  return;
901  }
902 
903  SrcExpr = Self.IgnoredValueConversions(SrcExpr.get());
904  return;
905  }
906 
907  if (ValueKind == VK_RValue && !DestType->isRecordType() &&
908  !isPlaceholder(BuiltinType::Overload)) {
909  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
910  if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
911  return;
912  }
913 
914  unsigned msg = diag::err_bad_cxx_cast_generic;
915  TryCastResult tcr
916  = TryStaticCast(Self, SrcExpr, DestType, Sema::CCK_OtherCast, OpRange, msg,
917  Kind, BasePath, /*ListInitialization=*/false);
918  if (tcr != TC_Success && msg != 0) {
919  if (SrcExpr.isInvalid())
920  return;
921  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
922  OverloadExpr* oe = OverloadExpr::find(SrcExpr.get()).Expression;
923  Self.Diag(OpRange.getBegin(), diag::err_bad_static_cast_overload)
924  << oe->getName() << DestType << OpRange
925  << oe->getQualifierLoc().getSourceRange();
926  Self.NoteAllOverloadCandidates(SrcExpr.get());
927  } else {
928  diagnoseBadCast(Self, msg, CT_Static, OpRange, SrcExpr.get(), DestType,
929  /*listInitialization=*/false);
930  }
931  SrcExpr = ExprError();
932  } else if (tcr == TC_Success) {
933  if (Kind == CK_BitCast)
934  checkCastAlign();
935  if (Self.getLangOpts().ObjCAutoRefCount)
936  checkObjCARCConversion(Sema::CCK_OtherCast);
937  } else if (Kind == CK_BitCast) {
938  checkCastAlign();
939  }
940 }
941 
942 /// TryStaticCast - Check if a static cast can be performed, and do so if
943 /// possible. If @p CStyle, ignore access restrictions on hierarchy casting
944 /// and casting away constness.
946  QualType DestType,
948  SourceRange OpRange, unsigned &msg,
949  CastKind &Kind, CXXCastPath &BasePath,
950  bool ListInitialization) {
951  // Determine whether we have the semantics of a C-style cast.
952  bool CStyle
953  = (CCK == Sema::CCK_CStyleCast || CCK == Sema::CCK_FunctionalCast);
954 
955  // The order the tests is not entirely arbitrary. There is one conversion
956  // that can be handled in two different ways. Given:
957  // struct A {};
958  // struct B : public A {
959  // B(); B(const A&);
960  // };
961  // const A &a = B();
962  // the cast static_cast<const B&>(a) could be seen as either a static
963  // reference downcast, or an explicit invocation of the user-defined
964  // conversion using B's conversion constructor.
965  // DR 427 specifies that the downcast is to be applied here.
966 
967  // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
968  // Done outside this function.
969 
970  TryCastResult tcr;
971 
972  // C++ 5.2.9p5, reference downcast.
973  // See the function for details.
974  // DR 427 specifies that this is to be applied before paragraph 2.
975  tcr = TryStaticReferenceDowncast(Self, SrcExpr.get(), DestType, CStyle,
976  OpRange, msg, Kind, BasePath);
977  if (tcr != TC_NotApplicable)
978  return tcr;
979 
980  // C++11 [expr.static.cast]p3:
981  // A glvalue of type "cv1 T1" can be cast to type "rvalue reference to cv2
982  // T2" if "cv2 T2" is reference-compatible with "cv1 T1".
983  tcr = TryLValueToRValueCast(Self, SrcExpr.get(), DestType, CStyle, Kind,
984  BasePath, msg);
985  if (tcr != TC_NotApplicable)
986  return tcr;
987 
988  // C++ 5.2.9p2: An expression e can be explicitly converted to a type T
989  // [...] if the declaration "T t(e);" is well-formed, [...].
990  tcr = TryStaticImplicitCast(Self, SrcExpr, DestType, CCK, OpRange, msg,
991  Kind, ListInitialization);
992  if (SrcExpr.isInvalid())
993  return TC_Failed;
994  if (tcr != TC_NotApplicable)
995  return tcr;
996 
997  // C++ 5.2.9p6: May apply the reverse of any standard conversion, except
998  // lvalue-to-rvalue, array-to-pointer, function-to-pointer, and boolean
999  // conversions, subject to further restrictions.
1000  // Also, C++ 5.2.9p1 forbids casting away constness, which makes reversal
1001  // of qualification conversions impossible.
1002  // In the CStyle case, the earlier attempt to const_cast should have taken
1003  // care of reverse qualification conversions.
1004 
1005  QualType SrcType = Self.Context.getCanonicalType(SrcExpr.get()->getType());
1006 
1007  // C++0x 5.2.9p9: A value of a scoped enumeration type can be explicitly
1008  // converted to an integral type. [...] A value of a scoped enumeration type
1009  // can also be explicitly converted to a floating-point type [...].
1010  if (const EnumType *Enum = SrcType->getAs<EnumType>()) {
1011  if (Enum->getDecl()->isScoped()) {
1012  if (DestType->isBooleanType()) {
1013  Kind = CK_IntegralToBoolean;
1014  return TC_Success;
1015  } else if (DestType->isIntegralType(Self.Context)) {
1016  Kind = CK_IntegralCast;
1017  return TC_Success;
1018  } else if (DestType->isRealFloatingType()) {
1019  Kind = CK_IntegralToFloating;
1020  return TC_Success;
1021  }
1022  }
1023  }
1024 
1025  // Reverse integral promotion/conversion. All such conversions are themselves
1026  // again integral promotions or conversions and are thus already handled by
1027  // p2 (TryDirectInitialization above).
1028  // (Note: any data loss warnings should be suppressed.)
1029  // The exception is the reverse of enum->integer, i.e. integer->enum (and
1030  // enum->enum). See also C++ 5.2.9p7.
1031  // The same goes for reverse floating point promotion/conversion and
1032  // floating-integral conversions. Again, only floating->enum is relevant.
1033  if (DestType->isEnumeralType()) {
1034  if (SrcType->isIntegralOrEnumerationType()) {
1035  Kind = CK_IntegralCast;
1036  return TC_Success;
1037  } else if (SrcType->isRealFloatingType()) {
1038  Kind = CK_FloatingToIntegral;
1039  return TC_Success;
1040  }
1041  }
1042 
1043  // Reverse pointer upcast. C++ 4.10p3 specifies pointer upcast.
1044  // C++ 5.2.9p8 additionally disallows a cast path through virtual inheritance.
1045  tcr = TryStaticPointerDowncast(Self, SrcType, DestType, CStyle, OpRange, msg,
1046  Kind, BasePath);
1047  if (tcr != TC_NotApplicable)
1048  return tcr;
1049 
1050  // Reverse member pointer conversion. C++ 4.11 specifies member pointer
1051  // conversion. C++ 5.2.9p9 has additional information.
1052  // DR54's access restrictions apply here also.
1053  tcr = TryStaticMemberPointerUpcast(Self, SrcExpr, SrcType, DestType, CStyle,
1054  OpRange, msg, Kind, BasePath);
1055  if (tcr != TC_NotApplicable)
1056  return tcr;
1057 
1058  // Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to
1059  // void*. C++ 5.2.9p10 specifies additional restrictions, which really is
1060  // just the usual constness stuff.
1061  if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) {
1062  QualType SrcPointee = SrcPointer->getPointeeType();
1063  if (SrcPointee->isVoidType()) {
1064  if (const PointerType *DestPointer = DestType->getAs<PointerType>()) {
1065  QualType DestPointee = DestPointer->getPointeeType();
1066  if (DestPointee->isIncompleteOrObjectType()) {
1067  // This is definitely the intended conversion, but it might fail due
1068  // to a qualifier violation. Note that we permit Objective-C lifetime
1069  // and GC qualifier mismatches here.
1070  if (!CStyle) {
1071  Qualifiers DestPointeeQuals = DestPointee.getQualifiers();
1072  Qualifiers SrcPointeeQuals = SrcPointee.getQualifiers();
1073  DestPointeeQuals.removeObjCGCAttr();
1074  DestPointeeQuals.removeObjCLifetime();
1075  SrcPointeeQuals.removeObjCGCAttr();
1076  SrcPointeeQuals.removeObjCLifetime();
1077  if (DestPointeeQuals != SrcPointeeQuals &&
1078  !DestPointeeQuals.compatiblyIncludes(SrcPointeeQuals)) {
1079  msg = diag::err_bad_cxx_cast_qualifiers_away;
1080  return TC_Failed;
1081  }
1082  }
1083  Kind = CK_BitCast;
1084  return TC_Success;
1085  }
1086 
1087  // Microsoft permits static_cast from 'pointer-to-void' to
1088  // 'pointer-to-function'.
1089  if (!CStyle && Self.getLangOpts().MSVCCompat &&
1090  DestPointee->isFunctionType()) {
1091  Self.Diag(OpRange.getBegin(), diag::ext_ms_cast_fn_obj) << OpRange;
1092  Kind = CK_BitCast;
1093  return TC_Success;
1094  }
1095  }
1096  else if (DestType->isObjCObjectPointerType()) {
1097  // allow both c-style cast and static_cast of objective-c pointers as
1098  // they are pervasive.
1099  Kind = CK_CPointerToObjCPointerCast;
1100  return TC_Success;
1101  }
1102  else if (CStyle && DestType->isBlockPointerType()) {
1103  // allow c-style cast of void * to block pointers.
1104  Kind = CK_AnyPointerToBlockPointerCast;
1105  return TC_Success;
1106  }
1107  }
1108  }
1109  // Allow arbitray objective-c pointer conversion with static casts.
1110  if (SrcType->isObjCObjectPointerType() &&
1111  DestType->isObjCObjectPointerType()) {
1112  Kind = CK_BitCast;
1113  return TC_Success;
1114  }
1115  // Allow ns-pointer to cf-pointer conversion in either direction
1116  // with static casts.
1117  if (!CStyle &&
1118  Self.CheckTollFreeBridgeStaticCast(DestType, SrcExpr.get(), Kind))
1119  return TC_Success;
1120 
1121  // See if it looks like the user is trying to convert between
1122  // related record types, and select a better diagnostic if so.
1123  if (auto SrcPointer = SrcType->getAs<PointerType>())
1124  if (auto DestPointer = DestType->getAs<PointerType>())
1125  if (SrcPointer->getPointeeType()->getAs<RecordType>() &&
1126  DestPointer->getPointeeType()->getAs<RecordType>())
1127  msg = diag::err_bad_cxx_cast_unrelated_class;
1128 
1129  // We tried everything. Everything! Nothing works! :-(
1130  return TC_NotApplicable;
1131 }
1132 
1133 /// Tests whether a conversion according to N2844 is valid.
1135 TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, QualType DestType,
1136  bool CStyle, CastKind &Kind, CXXCastPath &BasePath,
1137  unsigned &msg) {
1138  // C++11 [expr.static.cast]p3:
1139  // A glvalue of type "cv1 T1" can be cast to type "rvalue reference to
1140  // cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1".
1141  const RValueReferenceType *R = DestType->getAs<RValueReferenceType>();
1142  if (!R)
1143  return TC_NotApplicable;
1144 
1145  if (!SrcExpr->isGLValue())
1146  return TC_NotApplicable;
1147 
1148  // Because we try the reference downcast before this function, from now on
1149  // this is the only cast possibility, so we issue an error if we fail now.
1150  // FIXME: Should allow casting away constness if CStyle.
1151  bool DerivedToBase;
1152  bool ObjCConversion;
1153  bool ObjCLifetimeConversion;
1154  QualType FromType = SrcExpr->getType();
1155  QualType ToType = R->getPointeeType();
1156  if (CStyle) {
1157  FromType = FromType.getUnqualifiedType();
1158  ToType = ToType.getUnqualifiedType();
1159  }
1160 
1161  if (Self.CompareReferenceRelationship(SrcExpr->getLocStart(),
1162  ToType, FromType,
1163  DerivedToBase, ObjCConversion,
1164  ObjCLifetimeConversion)
1166  if (CStyle)
1167  return TC_NotApplicable;
1168  msg = diag::err_bad_lvalue_to_rvalue_cast;
1169  return TC_Failed;
1170  }
1171 
1172  if (DerivedToBase) {
1173  Kind = CK_DerivedToBase;
1174  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1175  /*DetectVirtual=*/true);
1176  if (!Self.IsDerivedFrom(SrcExpr->getLocStart(), SrcExpr->getType(),
1177  R->getPointeeType(), Paths))
1178  return TC_NotApplicable;
1179 
1180  Self.BuildBasePathArray(Paths, BasePath);
1181  } else
1182  Kind = CK_NoOp;
1183 
1184  return TC_Success;
1185 }
1186 
1187 /// Tests whether a conversion according to C++ 5.2.9p5 is valid.
1189 TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType,
1190  bool CStyle, SourceRange OpRange,
1191  unsigned &msg, CastKind &Kind,
1192  CXXCastPath &BasePath) {
1193  // C++ 5.2.9p5: An lvalue of type "cv1 B", where B is a class type, can be
1194  // cast to type "reference to cv2 D", where D is a class derived from B,
1195  // if a valid standard conversion from "pointer to D" to "pointer to B"
1196  // exists, cv2 >= cv1, and B is not a virtual base class of D.
1197  // In addition, DR54 clarifies that the base must be accessible in the
1198  // current context. Although the wording of DR54 only applies to the pointer
1199  // variant of this rule, the intent is clearly for it to apply to the this
1200  // conversion as well.
1201 
1202  const ReferenceType *DestReference = DestType->getAs<ReferenceType>();
1203  if (!DestReference) {
1204  return TC_NotApplicable;
1205  }
1206  bool RValueRef = DestReference->isRValueReferenceType();
1207  if (!RValueRef && !SrcExpr->isLValue()) {
1208  // We know the left side is an lvalue reference, so we can suggest a reason.
1209  msg = diag::err_bad_cxx_cast_rvalue;
1210  return TC_NotApplicable;
1211  }
1212 
1213  QualType DestPointee = DestReference->getPointeeType();
1214 
1215  // FIXME: If the source is a prvalue, we should issue a warning (because the
1216  // cast always has undefined behavior), and for AST consistency, we should
1217  // materialize a temporary.
1218  return TryStaticDowncast(Self,
1219  Self.Context.getCanonicalType(SrcExpr->getType()),
1220  Self.Context.getCanonicalType(DestPointee), CStyle,
1221  OpRange, SrcExpr->getType(), DestType, msg, Kind,
1222  BasePath);
1223 }
1224 
1225 /// Tests whether a conversion according to C++ 5.2.9p8 is valid.
1228  bool CStyle, SourceRange OpRange,
1229  unsigned &msg, CastKind &Kind,
1230  CXXCastPath &BasePath) {
1231  // C++ 5.2.9p8: An rvalue of type "pointer to cv1 B", where B is a class
1232  // type, can be converted to an rvalue of type "pointer to cv2 D", where D
1233  // is a class derived from B, if a valid standard conversion from "pointer
1234  // to D" to "pointer to B" exists, cv2 >= cv1, and B is not a virtual base
1235  // class of D.
1236  // In addition, DR54 clarifies that the base must be accessible in the
1237  // current context.
1238 
1239  const PointerType *DestPointer = DestType->getAs<PointerType>();
1240  if (!DestPointer) {
1241  return TC_NotApplicable;
1242  }
1243 
1244  const PointerType *SrcPointer = SrcType->getAs<PointerType>();
1245  if (!SrcPointer) {
1246  msg = diag::err_bad_static_cast_pointer_nonpointer;
1247  return TC_NotApplicable;
1248  }
1249 
1250  return TryStaticDowncast(Self,
1251  Self.Context.getCanonicalType(SrcPointer->getPointeeType()),
1252  Self.Context.getCanonicalType(DestPointer->getPointeeType()),
1253  CStyle, OpRange, SrcType, DestType, msg, Kind,
1254  BasePath);
1255 }
1256 
1257 /// TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and
1258 /// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to
1259 /// DestType is possible and allowed.
1262  bool CStyle, SourceRange OpRange, QualType OrigSrcType,
1263  QualType OrigDestType, unsigned &msg,
1264  CastKind &Kind, CXXCastPath &BasePath) {
1265  // We can only work with complete types. But don't complain if it doesn't work
1266  if (!Self.isCompleteType(OpRange.getBegin(), SrcType) ||
1267  !Self.isCompleteType(OpRange.getBegin(), DestType))
1268  return TC_NotApplicable;
1269 
1270  // Downcast can only happen in class hierarchies, so we need classes.
1271  if (!DestType->getAs<RecordType>() || !SrcType->getAs<RecordType>()) {
1272  return TC_NotApplicable;
1273  }
1274 
1275  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1276  /*DetectVirtual=*/true);
1277  if (!Self.IsDerivedFrom(OpRange.getBegin(), DestType, SrcType, Paths)) {
1278  return TC_NotApplicable;
1279  }
1280 
1281  // Target type does derive from source type. Now we're serious. If an error
1282  // appears now, it's not ignored.
1283  // This may not be entirely in line with the standard. Take for example:
1284  // struct A {};
1285  // struct B : virtual A {
1286  // B(A&);
1287  // };
1288  //
1289  // void f()
1290  // {
1291  // (void)static_cast<const B&>(*((A*)0));
1292  // }
1293  // As far as the standard is concerned, p5 does not apply (A is virtual), so
1294  // p2 should be used instead - "const B& t(*((A*)0));" is perfectly valid.
1295  // However, both GCC and Comeau reject this example, and accepting it would
1296  // mean more complex code if we're to preserve the nice error message.
1297  // FIXME: Being 100% compliant here would be nice to have.
1298 
1299  // Must preserve cv, as always, unless we're in C-style mode.
1300  if (!CStyle && !DestType.isAtLeastAsQualifiedAs(SrcType)) {
1301  msg = diag::err_bad_cxx_cast_qualifiers_away;
1302  return TC_Failed;
1303  }
1304 
1305  if (Paths.isAmbiguous(SrcType.getUnqualifiedType())) {
1306  // This code is analoguous to that in CheckDerivedToBaseConversion, except
1307  // that it builds the paths in reverse order.
1308  // To sum up: record all paths to the base and build a nice string from
1309  // them. Use it to spice up the error message.
1310  if (!Paths.isRecordingPaths()) {
1311  Paths.clear();
1312  Paths.setRecordingPaths(true);
1313  Self.IsDerivedFrom(OpRange.getBegin(), DestType, SrcType, Paths);
1314  }
1315  std::string PathDisplayStr;
1316  std::set<unsigned> DisplayedPaths;
1317  for (clang::CXXBasePath &Path : Paths) {
1318  if (DisplayedPaths.insert(Path.back().SubobjectNumber).second) {
1319  // We haven't displayed a path to this particular base
1320  // class subobject yet.
1321  PathDisplayStr += "\n ";
1322  for (CXXBasePathElement &PE : llvm::reverse(Path))
1323  PathDisplayStr += PE.Base->getType().getAsString() + " -> ";
1324  PathDisplayStr += QualType(DestType).getAsString();
1325  }
1326  }
1327 
1328  Self.Diag(OpRange.getBegin(), diag::err_ambiguous_base_to_derived_cast)
1329  << QualType(SrcType).getUnqualifiedType()
1330  << QualType(DestType).getUnqualifiedType()
1331  << PathDisplayStr << OpRange;
1332  msg = 0;
1333  return TC_Failed;
1334  }
1335 
1336  if (Paths.getDetectedVirtual() != nullptr) {
1337  QualType VirtualBase(Paths.getDetectedVirtual(), 0);
1338  Self.Diag(OpRange.getBegin(), diag::err_static_downcast_via_virtual)
1339  << OrigSrcType << OrigDestType << VirtualBase << OpRange;
1340  msg = 0;
1341  return TC_Failed;
1342  }
1343 
1344  if (!CStyle) {
1345  switch (Self.CheckBaseClassAccess(OpRange.getBegin(),
1346  SrcType, DestType,
1347  Paths.front(),
1348  diag::err_downcast_from_inaccessible_base)) {
1349  case Sema::AR_accessible:
1350  case Sema::AR_delayed: // be optimistic
1351  case Sema::AR_dependent: // be optimistic
1352  break;
1353 
1354  case Sema::AR_inaccessible:
1355  msg = 0;
1356  return TC_Failed;
1357  }
1358  }
1359 
1360  Self.BuildBasePathArray(Paths, BasePath);
1361  Kind = CK_BaseToDerived;
1362  return TC_Success;
1363 }
1364 
1365 /// TryStaticMemberPointerUpcast - Tests whether a conversion according to
1366 /// C++ 5.2.9p9 is valid:
1367 ///
1368 /// An rvalue of type "pointer to member of D of type cv1 T" can be
1369 /// converted to an rvalue of type "pointer to member of B of type cv2 T",
1370 /// where B is a base class of D [...].
1371 ///
1374  QualType DestType, bool CStyle,
1375  SourceRange OpRange,
1376  unsigned &msg, CastKind &Kind,
1377  CXXCastPath &BasePath) {
1378  const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>();
1379  if (!DestMemPtr)
1380  return TC_NotApplicable;
1381 
1382  bool WasOverloadedFunction = false;
1383  DeclAccessPair FoundOverload;
1384  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
1385  if (FunctionDecl *Fn
1386  = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(), DestType, false,
1387  FoundOverload)) {
1388  CXXMethodDecl *M = cast<CXXMethodDecl>(Fn);
1389  SrcType = Self.Context.getMemberPointerType(Fn->getType(),
1390  Self.Context.getTypeDeclType(M->getParent()).getTypePtr());
1391  WasOverloadedFunction = true;
1392  }
1393  }
1394 
1395  const MemberPointerType *SrcMemPtr = SrcType->getAs<MemberPointerType>();
1396  if (!SrcMemPtr) {
1397  msg = diag::err_bad_static_cast_member_pointer_nonmp;
1398  return TC_NotApplicable;
1399  }
1400 
1401  // Lock down the inheritance model right now in MS ABI, whether or not the
1402  // pointee types are the same.
1403  if (Self.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1404  (void)Self.isCompleteType(OpRange.getBegin(), SrcType);
1405  (void)Self.isCompleteType(OpRange.getBegin(), DestType);
1406  }
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);
1481  Kind = CK_DerivedToBaseMemberPointer;
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 = Self.CreateMaterializeTemporaryExpr(SrcType, SrcExpr.get(),
1650  /*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 /// Diagnose casts that change the calling convention of a pointer to a function
1728 /// defined in the current TU.
1729 static void DiagnoseCallingConvCast(Sema &Self, const ExprResult &SrcExpr,
1730  QualType DstType, SourceRange OpRange) {
1731  // Check if this cast would change the calling convention of a function
1732  // pointer type.
1733  QualType SrcType = SrcExpr.get()->getType();
1734  if (Self.Context.hasSameType(SrcType, DstType) ||
1735  !SrcType->isFunctionPointerType() || !DstType->isFunctionPointerType())
1736  return;
1737  const auto *SrcFTy =
1738  SrcType->castAs<PointerType>()->getPointeeType()->castAs<FunctionType>();
1739  const auto *DstFTy =
1740  DstType->castAs<PointerType>()->getPointeeType()->castAs<FunctionType>();
1741  CallingConv SrcCC = SrcFTy->getCallConv();
1742  CallingConv DstCC = DstFTy->getCallConv();
1743  if (SrcCC == DstCC)
1744  return;
1745 
1746  // We have a calling convention cast. Check if the source is a pointer to a
1747  // known, specific function that has already been defined.
1748  Expr *Src = SrcExpr.get()->IgnoreParenImpCasts();
1749  if (auto *UO = dyn_cast<UnaryOperator>(Src))
1750  if (UO->getOpcode() == UO_AddrOf)
1751  Src = UO->getSubExpr()->IgnoreParenImpCasts();
1752  auto *DRE = dyn_cast<DeclRefExpr>(Src);
1753  if (!DRE)
1754  return;
1755  auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
1756  const FunctionDecl *Definition;
1757  if (!FD || !FD->hasBody(Definition))
1758  return;
1759 
1760  // Only warn if we are casting from the default convention to a non-default
1761  // convention. This can happen when the programmer forgot to apply the calling
1762  // convention to the function definition and then inserted this cast to
1763  // satisfy the type system.
1765  FD->isVariadic(), FD->isCXXInstanceMember());
1766  if (DstCC == DefaultCC || SrcCC != DefaultCC)
1767  return;
1768 
1769  // Diagnose this cast, as it is probably bad.
1770  StringRef SrcCCName = FunctionType::getNameForCallConv(SrcCC);
1771  StringRef DstCCName = FunctionType::getNameForCallConv(DstCC);
1772  Self.Diag(OpRange.getBegin(), diag::warn_cast_calling_conv)
1773  << SrcCCName << DstCCName << OpRange;
1774 
1775  // The checks above are cheaper than checking if the diagnostic is enabled.
1776  // However, it's worth checking if the warning is enabled before we construct
1777  // a fixit.
1778  if (Self.Diags.isIgnored(diag::warn_cast_calling_conv, OpRange.getBegin()))
1779  return;
1780 
1781  // Try to suggest a fixit to change the calling convention of the function
1782  // whose address was taken. Try to use the latest macro for the convention.
1783  // For example, users probably want to write "WINAPI" instead of "__stdcall"
1784  // to match the Windows header declarations.
1785  SourceLocation NameLoc = Definition->getNameInfo().getLoc();
1786  Preprocessor &PP = Self.getPreprocessor();
1787  SmallVector<TokenValue, 6> AttrTokens;
1788  SmallString<64> CCAttrText;
1789  llvm::raw_svector_ostream OS(CCAttrText);
1790  if (Self.getLangOpts().MicrosoftExt) {
1791  // __stdcall or __vectorcall
1792  OS << "__" << DstCCName;
1793  IdentifierInfo *II = PP.getIdentifierInfo(OS.str());
1794  AttrTokens.push_back(II->isKeyword(Self.getLangOpts())
1795  ? TokenValue(II->getTokenID())
1796  : TokenValue(II));
1797  } else {
1798  // __attribute__((stdcall)) or __attribute__((vectorcall))
1799  OS << "__attribute__((" << DstCCName << "))";
1800  AttrTokens.push_back(tok::kw___attribute);
1801  AttrTokens.push_back(tok::l_paren);
1802  AttrTokens.push_back(tok::l_paren);
1803  IdentifierInfo *II = PP.getIdentifierInfo(DstCCName);
1804  AttrTokens.push_back(II->isKeyword(Self.getLangOpts())
1805  ? TokenValue(II->getTokenID())
1806  : TokenValue(II));
1807  AttrTokens.push_back(tok::r_paren);
1808  AttrTokens.push_back(tok::r_paren);
1809  }
1810  StringRef AttrSpelling = PP.getLastMacroWithSpelling(NameLoc, AttrTokens);
1811  if (!AttrSpelling.empty())
1812  CCAttrText = AttrSpelling;
1813  OS << ' ';
1814  Self.Diag(NameLoc, diag::note_change_calling_conv_fixit)
1815  << FD << DstCCName << FixItHint::CreateInsertion(NameLoc, CCAttrText);
1816 }
1817 
1818 static void checkIntToPointerCast(bool CStyle, SourceLocation Loc,
1819  const Expr *SrcExpr, QualType DestType,
1820  Sema &Self) {
1821  QualType SrcType = SrcExpr->getType();
1822 
1823  // Not warning on reinterpret_cast, boolean, constant expressions, etc
1824  // are not explicit design choices, but consistent with GCC's behavior.
1825  // Feel free to modify them if you've reason/evidence for an alternative.
1826  if (CStyle && SrcType->isIntegralType(Self.Context)
1827  && !SrcType->isBooleanType()
1828  && !SrcType->isEnumeralType()
1829  && !SrcExpr->isIntegerConstantExpr(Self.Context)
1830  && Self.Context.getTypeSize(DestType) >
1831  Self.Context.getTypeSize(SrcType)) {
1832  // Separate between casts to void* and non-void* pointers.
1833  // Some APIs use (abuse) void* for something like a user context,
1834  // and often that value is an integer even if it isn't a pointer itself.
1835  // Having a separate warning flag allows users to control the warning
1836  // for their workflow.
1837  unsigned Diag = DestType->isVoidPointerType() ?
1838  diag::warn_int_to_void_pointer_cast
1839  : diag::warn_int_to_pointer_cast;
1840  Self.Diag(Loc, Diag) << SrcType << DestType;
1841  }
1842 }
1843 
1844 static bool fixOverloadedReinterpretCastExpr(Sema &Self, QualType DestType,
1845  ExprResult &Result) {
1846  // We can only fix an overloaded reinterpret_cast if
1847  // - it is a template with explicit arguments that resolves to an lvalue
1848  // unambiguously, or
1849  // - it is the only function in an overload set that may have its address
1850  // taken.
1851 
1852  Expr *E = Result.get();
1853  // TODO: what if this fails because of DiagnoseUseOfDecl or something
1854  // like it?
1856  Result,
1857  Expr::getValueKindForType(DestType) == VK_RValue // Convert Fun to Ptr
1858  ) &&
1859  Result.isUsable())
1860  return true;
1861 
1862  // No guarantees that ResolveAndFixSingleFunctionTemplateSpecialization
1863  // preserves Result.
1864  Result = E;
1866  return false;
1867  return Result.isUsable();
1868 }
1869 
1871  QualType DestType, bool CStyle,
1872  SourceRange OpRange,
1873  unsigned &msg,
1874  CastKind &Kind) {
1875  bool IsLValueCast = false;
1876 
1877  DestType = Self.Context.getCanonicalType(DestType);
1878  QualType SrcType = SrcExpr.get()->getType();
1879 
1880  // Is the source an overloaded name? (i.e. &foo)
1881  // If so, reinterpret_cast generally can not help us here (13.4, p1, bullet 5)
1882  if (SrcType == Self.Context.OverloadTy) {
1883  ExprResult FixedExpr = SrcExpr;
1884  if (!fixOverloadedReinterpretCastExpr(Self, DestType, FixedExpr))
1885  return TC_NotApplicable;
1886 
1887  assert(FixedExpr.isUsable() && "Invalid result fixing overloaded expr");
1888  SrcExpr = FixedExpr;
1889  SrcType = SrcExpr.get()->getType();
1890  }
1891 
1892  if (const ReferenceType *DestTypeTmp = DestType->getAs<ReferenceType>()) {
1893  if (!SrcExpr.get()->isGLValue()) {
1894  // Cannot cast non-glvalue to (lvalue or rvalue) reference type. See the
1895  // similar comment in const_cast.
1896  msg = diag::err_bad_cxx_cast_rvalue;
1897  return TC_NotApplicable;
1898  }
1899 
1900  if (!CStyle) {
1901  Self.CheckCompatibleReinterpretCast(SrcType, DestType,
1902  /*isDereference=*/false, OpRange);
1903  }
1904 
1905  // C++ 5.2.10p10: [...] a reference cast reinterpret_cast<T&>(x) has the
1906  // same effect as the conversion *reinterpret_cast<T*>(&x) with the
1907  // built-in & and * operators.
1908 
1909  const char *inappropriate = nullptr;
1910  switch (SrcExpr.get()->getObjectKind()) {
1911  case OK_Ordinary:
1912  break;
1913  case OK_BitField: inappropriate = "bit-field"; break;
1914  case OK_VectorComponent: inappropriate = "vector element"; break;
1915  case OK_ObjCProperty: inappropriate = "property expression"; break;
1916  case OK_ObjCSubscript: inappropriate = "container subscripting expression";
1917  break;
1918  }
1919  if (inappropriate) {
1920  Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_reference)
1921  << inappropriate << DestType
1922  << OpRange << SrcExpr.get()->getSourceRange();
1923  msg = 0; SrcExpr = ExprError();
1924  return TC_NotApplicable;
1925  }
1926 
1927  // This code does this transformation for the checked types.
1928  DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType());
1929  SrcType = Self.Context.getPointerType(SrcType);
1930 
1931  IsLValueCast = true;
1932  }
1933 
1934  // Canonicalize source for comparison.
1935  SrcType = Self.Context.getCanonicalType(SrcType);
1936 
1937  const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>(),
1938  *SrcMemPtr = SrcType->getAs<MemberPointerType>();
1939  if (DestMemPtr && SrcMemPtr) {
1940  // C++ 5.2.10p9: An rvalue of type "pointer to member of X of type T1"
1941  // can be explicitly converted to an rvalue of type "pointer to member
1942  // of Y of type T2" if T1 and T2 are both function types or both object
1943  // types.
1944  if (DestMemPtr->isMemberFunctionPointer() !=
1945  SrcMemPtr->isMemberFunctionPointer())
1946  return TC_NotApplicable;
1947 
1948  // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away
1949  // constness.
1950  // A reinterpret_cast followed by a const_cast can, though, so in C-style,
1951  // we accept it.
1952  if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle,
1953  /*CheckObjCLifetime=*/CStyle)) {
1954  msg = diag::err_bad_cxx_cast_qualifiers_away;
1955  return TC_Failed;
1956  }
1957 
1958  if (Self.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1959  // We need to determine the inheritance model that the class will use if
1960  // haven't yet.
1961  (void)Self.isCompleteType(OpRange.getBegin(), SrcType);
1962  (void)Self.isCompleteType(OpRange.getBegin(), DestType);
1963  }
1964 
1965  // Don't allow casting between member pointers of different sizes.
1966  if (Self.Context.getTypeSize(DestMemPtr) !=
1967  Self.Context.getTypeSize(SrcMemPtr)) {
1968  msg = diag::err_bad_cxx_cast_member_pointer_size;
1969  return TC_Failed;
1970  }
1971 
1972  // A valid member pointer cast.
1973  assert(!IsLValueCast);
1974  Kind = CK_ReinterpretMemberPointer;
1975  return TC_Success;
1976  }
1977 
1978  // See below for the enumeral issue.
1979  if (SrcType->isNullPtrType() && DestType->isIntegralType(Self.Context)) {
1980  // C++0x 5.2.10p4: A pointer can be explicitly converted to any integral
1981  // type large enough to hold it. A value of std::nullptr_t can be
1982  // converted to an integral type; the conversion has the same meaning
1983  // and validity as a conversion of (void*)0 to the integral type.
1984  if (Self.Context.getTypeSize(SrcType) >
1985  Self.Context.getTypeSize(DestType)) {
1986  msg = diag::err_bad_reinterpret_cast_small_int;
1987  return TC_Failed;
1988  }
1989  Kind = CK_PointerToIntegral;
1990  return TC_Success;
1991  }
1992 
1993  // Allow reinterpret_casts between vectors of the same size and
1994  // between vectors and integers of the same size.
1995  bool destIsVector = DestType->isVectorType();
1996  bool srcIsVector = SrcType->isVectorType();
1997  if (srcIsVector || destIsVector) {
1998  // The non-vector type, if any, must have integral type. This is
1999  // the same rule that C vector casts use; note, however, that enum
2000  // types are not integral in C++.
2001  if ((!destIsVector && !DestType->isIntegralType(Self.Context)) ||
2002  (!srcIsVector && !SrcType->isIntegralType(Self.Context)))
2003  return TC_NotApplicable;
2004 
2005  // The size we want to consider is eltCount * eltSize.
2006  // That's exactly what the lax-conversion rules will check.
2007  if (Self.areLaxCompatibleVectorTypes(SrcType, DestType)) {
2008  Kind = CK_BitCast;
2009  return TC_Success;
2010  }
2011 
2012  // Otherwise, pick a reasonable diagnostic.
2013  if (!destIsVector)
2014  msg = diag::err_bad_cxx_cast_vector_to_scalar_different_size;
2015  else if (!srcIsVector)
2016  msg = diag::err_bad_cxx_cast_scalar_to_vector_different_size;
2017  else
2018  msg = diag::err_bad_cxx_cast_vector_to_vector_different_size;
2019 
2020  return TC_Failed;
2021  }
2022 
2023  if (SrcType == DestType) {
2024  // C++ 5.2.10p2 has a note that mentions that, subject to all other
2025  // restrictions, a cast to the same type is allowed so long as it does not
2026  // cast away constness. In C++98, the intent was not entirely clear here,
2027  // since all other paragraphs explicitly forbid casts to the same type.
2028  // C++11 clarifies this case with p2.
2029  //
2030  // The only allowed types are: integral, enumeration, pointer, or
2031  // pointer-to-member types. We also won't restrict Obj-C pointers either.
2032  Kind = CK_NoOp;
2034  if (SrcType->isIntegralOrEnumerationType() ||
2035  SrcType->isAnyPointerType() ||
2036  SrcType->isMemberPointerType() ||
2037  SrcType->isBlockPointerType()) {
2038  Result = TC_Success;
2039  }
2040  return Result;
2041  }
2042 
2043  bool destIsPtr = DestType->isAnyPointerType() ||
2044  DestType->isBlockPointerType();
2045  bool srcIsPtr = SrcType->isAnyPointerType() ||
2046  SrcType->isBlockPointerType();
2047  if (!destIsPtr && !srcIsPtr) {
2048  // Except for std::nullptr_t->integer and lvalue->reference, which are
2049  // handled above, at least one of the two arguments must be a pointer.
2050  return TC_NotApplicable;
2051  }
2052 
2053  if (DestType->isIntegralType(Self.Context)) {
2054  assert(srcIsPtr && "One type must be a pointer");
2055  // C++ 5.2.10p4: A pointer can be explicitly converted to any integral
2056  // type large enough to hold it; except in Microsoft mode, where the
2057  // integral type size doesn't matter (except we don't allow bool).
2058  bool MicrosoftException = Self.getLangOpts().MicrosoftExt &&
2059  !DestType->isBooleanType();
2060  if ((Self.Context.getTypeSize(SrcType) >
2061  Self.Context.getTypeSize(DestType)) &&
2062  !MicrosoftException) {
2063  msg = diag::err_bad_reinterpret_cast_small_int;
2064  return TC_Failed;
2065  }
2066  Kind = CK_PointerToIntegral;
2067  return TC_Success;
2068  }
2069 
2070  if (SrcType->isIntegralOrEnumerationType()) {
2071  assert(destIsPtr && "One type must be a pointer");
2072  checkIntToPointerCast(CStyle, OpRange.getBegin(), SrcExpr.get(), DestType,
2073  Self);
2074  // C++ 5.2.10p5: A value of integral or enumeration type can be explicitly
2075  // converted to a pointer.
2076  // C++ 5.2.10p9: [Note: ...a null pointer constant of integral type is not
2077  // necessarily converted to a null pointer value.]
2078  Kind = CK_IntegralToPointer;
2079  return TC_Success;
2080  }
2081 
2082  if (!destIsPtr || !srcIsPtr) {
2083  // With the valid non-pointer conversions out of the way, we can be even
2084  // more stringent.
2085  return TC_NotApplicable;
2086  }
2087 
2088  // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away constness.
2089  // The C-style cast operator can.
2090  if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle,
2091  /*CheckObjCLifetime=*/CStyle)) {
2092  msg = diag::err_bad_cxx_cast_qualifiers_away;
2093  return TC_Failed;
2094  }
2095 
2096  // Cannot convert between block pointers and Objective-C object pointers.
2097  if ((SrcType->isBlockPointerType() && DestType->isObjCObjectPointerType()) ||
2098  (DestType->isBlockPointerType() && SrcType->isObjCObjectPointerType()))
2099  return TC_NotApplicable;
2100 
2101  if (IsLValueCast) {
2102  Kind = CK_LValueBitCast;
2103  } else if (DestType->isObjCObjectPointerType()) {
2104  Kind = Self.PrepareCastToObjCObjectPointer(SrcExpr);
2105  } else if (DestType->isBlockPointerType()) {
2106  if (!SrcType->isBlockPointerType()) {
2107  Kind = CK_AnyPointerToBlockPointerCast;
2108  } else {
2109  Kind = CK_BitCast;
2110  }
2111  } else {
2112  Kind = CK_BitCast;
2113  }
2114 
2115  // Any pointer can be cast to an Objective-C pointer type with a C-style
2116  // cast.
2117  if (CStyle && DestType->isObjCObjectPointerType()) {
2118  return TC_Success;
2119  }
2120  if (CStyle)
2121  DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType);
2122 
2123  DiagnoseCallingConvCast(Self, SrcExpr, DestType, OpRange);
2124 
2125  // Not casting away constness, so the only remaining check is for compatible
2126  // pointer categories.
2127 
2128  if (SrcType->isFunctionPointerType()) {
2129  if (DestType->isFunctionPointerType()) {
2130  // C++ 5.2.10p6: A pointer to a function can be explicitly converted to
2131  // a pointer to a function of a different type.
2132  return TC_Success;
2133  }
2134 
2135  // C++0x 5.2.10p8: Converting a pointer to a function into a pointer to
2136  // an object type or vice versa is conditionally-supported.
2137  // Compilers support it in C++03 too, though, because it's necessary for
2138  // casting the return value of dlsym() and GetProcAddress().
2139  // FIXME: Conditionally-supported behavior should be configurable in the
2140  // TargetInfo or similar.
2141  Self.Diag(OpRange.getBegin(),
2142  Self.getLangOpts().CPlusPlus11 ?
2143  diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj)
2144  << OpRange;
2145  return TC_Success;
2146  }
2147 
2148  if (DestType->isFunctionPointerType()) {
2149  // See above.
2150  Self.Diag(OpRange.getBegin(),
2151  Self.getLangOpts().CPlusPlus11 ?
2152  diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj)
2153  << OpRange;
2154  return TC_Success;
2155  }
2156 
2157  // C++ 5.2.10p7: A pointer to an object can be explicitly converted to
2158  // a pointer to an object of different type.
2159  // Void pointers are not specified, but supported by every compiler out there.
2160  // So we finish by allowing everything that remains - it's got to be two
2161  // object pointers.
2162  return TC_Success;
2163 }
2164 
2165 void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
2166  bool ListInitialization) {
2167  // Handle placeholders.
2168  if (isPlaceholder()) {
2169  // C-style casts can resolve __unknown_any types.
2170  if (claimPlaceholder(BuiltinType::UnknownAny)) {
2171  SrcExpr = Self.checkUnknownAnyCast(DestRange, DestType,
2172  SrcExpr.get(), Kind,
2173  ValueKind, BasePath);
2174  return;
2175  }
2176 
2177  checkNonOverloadPlaceholders();
2178  if (SrcExpr.isInvalid())
2179  return;
2180  }
2181 
2182  // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
2183  // This test is outside everything else because it's the only case where
2184  // a non-lvalue-reference target type does not lead to decay.
2185  if (DestType->isVoidType()) {
2186  Kind = CK_ToVoid;
2187 
2188  if (claimPlaceholder(BuiltinType::Overload)) {
2189  Self.ResolveAndFixSingleFunctionTemplateSpecialization(
2190  SrcExpr, /* Decay Function to ptr */ false,
2191  /* Complain */ true, DestRange, DestType,
2192  diag::err_bad_cstyle_cast_overload);
2193  if (SrcExpr.isInvalid())
2194  return;
2195  }
2196 
2197  SrcExpr = Self.IgnoredValueConversions(SrcExpr.get());
2198  return;
2199  }
2200 
2201  // If the type is dependent, we won't do any other semantic analysis now.
2202  if (DestType->isDependentType() || SrcExpr.get()->isTypeDependent() ||
2203  SrcExpr.get()->isValueDependent()) {
2204  assert(Kind == CK_Dependent);
2205  return;
2206  }
2207 
2208  if (ValueKind == VK_RValue && !DestType->isRecordType() &&
2209  !isPlaceholder(BuiltinType::Overload)) {
2210  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
2211  if (SrcExpr.isInvalid())
2212  return;
2213  }
2214 
2215  // AltiVec vector initialization with a single literal.
2216  if (const VectorType *vecTy = DestType->getAs<VectorType>())
2217  if (vecTy->getVectorKind() == VectorType::AltiVecVector
2218  && (SrcExpr.get()->getType()->isIntegerType()
2219  || SrcExpr.get()->getType()->isFloatingType())) {
2220  Kind = CK_VectorSplat;
2221  SrcExpr = Self.prepareVectorSplat(DestType, SrcExpr.get());
2222  return;
2223  }
2224 
2225  // C++ [expr.cast]p5: The conversions performed by
2226  // - a const_cast,
2227  // - a static_cast,
2228  // - a static_cast followed by a const_cast,
2229  // - a reinterpret_cast, or
2230  // - a reinterpret_cast followed by a const_cast,
2231  // can be performed using the cast notation of explicit type conversion.
2232  // [...] If a conversion can be interpreted in more than one of the ways
2233  // listed above, the interpretation that appears first in the list is used,
2234  // even if a cast resulting from that interpretation is ill-formed.
2235  // In plain language, this means trying a const_cast ...
2236  unsigned msg = diag::err_bad_cxx_cast_generic;
2237  TryCastResult tcr = TryConstCast(Self, SrcExpr, DestType,
2238  /*CStyle*/true, msg);
2239  if (SrcExpr.isInvalid())
2240  return;
2241  if (tcr == TC_Success)
2242  Kind = CK_NoOp;
2243 
2245  = FunctionalStyle? Sema::CCK_FunctionalCast
2247  if (tcr == TC_NotApplicable) {
2248  // ... or if that is not possible, a static_cast, ignoring const, ...
2249  tcr = TryStaticCast(Self, SrcExpr, DestType, CCK, OpRange,
2250  msg, Kind, BasePath, ListInitialization);
2251  if (SrcExpr.isInvalid())
2252  return;
2253 
2254  if (tcr == TC_NotApplicable) {
2255  // ... and finally a reinterpret_cast, ignoring const.
2256  tcr = TryReinterpretCast(Self, SrcExpr, DestType, /*CStyle*/true,
2257  OpRange, msg, Kind);
2258  if (SrcExpr.isInvalid())
2259  return;
2260  }
2261  }
2262 
2263  if (Self.getLangOpts().ObjCAutoRefCount && tcr == TC_Success)
2264  checkObjCARCConversion(CCK);
2265 
2266  if (tcr != TC_Success && msg != 0) {
2267  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
2268  DeclAccessPair Found;
2269  FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(),
2270  DestType,
2271  /*Complain*/ true,
2272  Found);
2273  if (Fn) {
2274  // If DestType is a function type (not to be confused with the function
2275  // pointer type), it will be possible to resolve the function address,
2276  // but the type cast should be considered as failure.
2277  OverloadExpr *OE = OverloadExpr::find(SrcExpr.get()).Expression;
2278  Self.Diag(OpRange.getBegin(), diag::err_bad_cstyle_cast_overload)
2279  << OE->getName() << DestType << OpRange
2280  << OE->getQualifierLoc().getSourceRange();
2281  Self.NoteAllOverloadCandidates(SrcExpr.get());
2282  }
2283  } else {
2284  diagnoseBadCast(Self, msg, (FunctionalStyle ? CT_Functional : CT_CStyle),
2285  OpRange, SrcExpr.get(), DestType, ListInitialization);
2286  }
2287  } else if (Kind == CK_BitCast) {
2288  checkCastAlign();
2289  }
2290 
2291  // Clear out SrcExpr if there was a fatal error.
2292  if (tcr != TC_Success)
2293  SrcExpr = ExprError();
2294 }
2295 
2296 /// DiagnoseBadFunctionCast - Warn whenever a function call is cast to a
2297 /// non-matching type. Such as enum function call to int, int call to
2298 /// pointer; etc. Cast to 'void' is an exception.
2299 static void DiagnoseBadFunctionCast(Sema &Self, const ExprResult &SrcExpr,
2300  QualType DestType) {
2301  if (Self.Diags.isIgnored(diag::warn_bad_function_cast,
2302  SrcExpr.get()->getExprLoc()))
2303  return;
2304 
2305  if (!isa<CallExpr>(SrcExpr.get()))
2306  return;
2307 
2308  QualType SrcType = SrcExpr.get()->getType();
2309  if (DestType.getUnqualifiedType()->isVoidType())
2310  return;
2311  if ((SrcType->isAnyPointerType() || SrcType->isBlockPointerType())
2312  && (DestType->isAnyPointerType() || DestType->isBlockPointerType()))
2313  return;
2314  if (SrcType->isIntegerType() && DestType->isIntegerType() &&
2315  (SrcType->isBooleanType() == DestType->isBooleanType()) &&
2316  (SrcType->isEnumeralType() == DestType->isEnumeralType()))
2317  return;
2318  if (SrcType->isRealFloatingType() && DestType->isRealFloatingType())
2319  return;
2320  if (SrcType->isEnumeralType() && DestType->isEnumeralType())
2321  return;
2322  if (SrcType->isComplexType() && DestType->isComplexType())
2323  return;
2324  if (SrcType->isComplexIntegerType() && DestType->isComplexIntegerType())
2325  return;
2326 
2327  Self.Diag(SrcExpr.get()->getExprLoc(),
2328  diag::warn_bad_function_cast)
2329  << SrcType << DestType << SrcExpr.get()->getSourceRange();
2330 }
2331 
2332 /// Check the semantics of a C-style cast operation, in C.
2333 void CastOperation::CheckCStyleCast() {
2334  assert(!Self.getLangOpts().CPlusPlus);
2335 
2336  // C-style casts can resolve __unknown_any types.
2337  if (claimPlaceholder(BuiltinType::UnknownAny)) {
2338  SrcExpr = Self.checkUnknownAnyCast(DestRange, DestType,
2339  SrcExpr.get(), Kind,
2340  ValueKind, BasePath);
2341  return;
2342  }
2343 
2344  // C99 6.5.4p2: the cast type needs to be void or scalar and the expression
2345  // type needs to be scalar.
2346  if (DestType->isVoidType()) {
2347  // We don't necessarily do lvalue-to-rvalue conversions on this.
2348  SrcExpr = Self.IgnoredValueConversions(SrcExpr.get());
2349  if (SrcExpr.isInvalid())
2350  return;
2351 
2352  // Cast to void allows any expr type.
2353  Kind = CK_ToVoid;
2354  return;
2355  }
2356 
2357  // Overloads are allowed with C extensions, so we need to support them.
2358  if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
2359  DeclAccessPair DAP;
2360  if (FunctionDecl *FD = Self.ResolveAddressOfOverloadedFunction(
2361  SrcExpr.get(), DestType, /*Complain=*/true, DAP))
2362  SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr.get(), DAP, FD);
2363  else
2364  return;
2365  assert(SrcExpr.isUsable());
2366  }
2367  SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
2368  if (SrcExpr.isInvalid())
2369  return;
2370  QualType SrcType = SrcExpr.get()->getType();
2371 
2372  assert(!SrcType->isPlaceholderType());
2373 
2374  // OpenCL v1 s6.5: Casting a pointer to address space A to a pointer to
2375  // address space B is illegal.
2376  if (Self.getLangOpts().OpenCL && DestType->isPointerType() &&
2377  SrcType->isPointerType()) {
2378  const PointerType *DestPtr = DestType->getAs<PointerType>();
2379  if (!DestPtr->isAddressSpaceOverlapping(*SrcType->getAs<PointerType>())) {
2380  Self.Diag(OpRange.getBegin(),
2381  diag::err_typecheck_incompatible_address_space)
2382  << SrcType << DestType << Sema::AA_Casting
2383  << SrcExpr.get()->getSourceRange();
2384  SrcExpr = ExprError();
2385  return;
2386  }
2387  }
2388 
2389  if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
2390  diag::err_typecheck_cast_to_incomplete)) {
2391  SrcExpr = ExprError();
2392  return;
2393  }
2394 
2395  if (!DestType->isScalarType() && !DestType->isVectorType()) {
2396  const RecordType *DestRecordTy = DestType->getAs<RecordType>();
2397 
2398  if (DestRecordTy && Self.Context.hasSameUnqualifiedType(DestType, SrcType)){
2399  // GCC struct/union extension: allow cast to self.
2400  Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_nonscalar)
2401  << DestType << SrcExpr.get()->getSourceRange();
2402  Kind = CK_NoOp;
2403  return;
2404  }
2405 
2406  // GCC's cast to union extension.
2407  if (DestRecordTy && DestRecordTy->getDecl()->isUnion()) {
2408  RecordDecl *RD = DestRecordTy->getDecl();
2410  for (Field = RD->field_begin(), FieldEnd = RD->field_end();
2411  Field != FieldEnd; ++Field) {
2412  if (Self.Context.hasSameUnqualifiedType(Field->getType(), SrcType) &&
2413  !Field->isUnnamedBitfield()) {
2414  Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_to_union)
2415  << SrcExpr.get()->getSourceRange();
2416  break;
2417  }
2418  }
2419  if (Field == FieldEnd) {
2420  Self.Diag(OpRange.getBegin(), diag::err_typecheck_cast_to_union_no_type)
2421  << SrcType << SrcExpr.get()->getSourceRange();
2422  SrcExpr = ExprError();
2423  return;
2424  }
2425  Kind = CK_ToUnion;
2426  return;
2427  }
2428 
2429  // OpenCL v2.0 s6.13.10 - Allow casts from '0' to event_t type.
2430  if (Self.getLangOpts().OpenCL && DestType->isEventT()) {
2431  llvm::APSInt CastInt;
2432  if (SrcExpr.get()->EvaluateAsInt(CastInt, Self.Context)) {
2433  if (0 == CastInt) {
2434  Kind = CK_ZeroToOCLEvent;
2435  return;
2436  }
2437  Self.Diag(OpRange.getBegin(),
2438  diag::error_opencl_cast_non_zero_to_event_t)
2439  << CastInt.toString(10) << SrcExpr.get()->getSourceRange();
2440  SrcExpr = ExprError();
2441  return;
2442  }
2443  }
2444 
2445  // Reject any other conversions to non-scalar types.
2446  Self.Diag(OpRange.getBegin(), diag::err_typecheck_cond_expect_scalar)
2447  << DestType << SrcExpr.get()->getSourceRange();
2448  SrcExpr = ExprError();
2449  return;
2450  }
2451 
2452  // The type we're casting to is known to be a scalar or vector.
2453 
2454  // Require the operand to be a scalar or vector.
2455  if (!SrcType->isScalarType() && !SrcType->isVectorType()) {
2456  Self.Diag(SrcExpr.get()->getExprLoc(),
2457  diag::err_typecheck_expect_scalar_operand)
2458  << SrcType << SrcExpr.get()->getSourceRange();
2459  SrcExpr = ExprError();
2460  return;
2461  }
2462 
2463  if (DestType->isExtVectorType()) {
2464  SrcExpr = Self.CheckExtVectorCast(OpRange, DestType, SrcExpr.get(), Kind);
2465  return;
2466  }
2467 
2468  if (const VectorType *DestVecTy = DestType->getAs<VectorType>()) {
2469  if (DestVecTy->getVectorKind() == VectorType::AltiVecVector &&
2470  (SrcType->isIntegerType() || SrcType->isFloatingType())) {
2471  Kind = CK_VectorSplat;
2472  SrcExpr = Self.prepareVectorSplat(DestType, SrcExpr.get());
2473  } else if (Self.CheckVectorCast(OpRange, DestType, SrcType, Kind)) {
2474  SrcExpr = ExprError();
2475  }
2476  return;
2477  }
2478 
2479  if (SrcType->isVectorType()) {
2480  if (Self.CheckVectorCast(OpRange, SrcType, DestType, Kind))
2481  SrcExpr = ExprError();
2482  return;
2483  }
2484 
2485  // The source and target types are both scalars, i.e.
2486  // - arithmetic types (fundamental, enum, and complex)
2487  // - all kinds of pointers
2488  // Note that member pointers were filtered out with C++, above.
2489 
2490  if (isa<ObjCSelectorExpr>(SrcExpr.get())) {
2491  Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_selector_expr);
2492  SrcExpr = ExprError();
2493  return;
2494  }
2495 
2496  // If either type is a pointer, the other type has to be either an
2497  // integer or a pointer.
2498  if (!DestType->isArithmeticType()) {
2499  if (!SrcType->isIntegralType(Self.Context) && SrcType->isArithmeticType()) {
2500  Self.Diag(SrcExpr.get()->getExprLoc(),
2501  diag::err_cast_pointer_from_non_pointer_int)
2502  << SrcType << SrcExpr.get()->getSourceRange();
2503  SrcExpr = ExprError();
2504  return;
2505  }
2506  checkIntToPointerCast(/* CStyle */ true, OpRange.getBegin(), SrcExpr.get(),
2507  DestType, Self);
2508  } else if (!SrcType->isArithmeticType()) {
2509  if (!DestType->isIntegralType(Self.Context) &&
2510  DestType->isArithmeticType()) {
2511  Self.Diag(SrcExpr.get()->getLocStart(),
2512  diag::err_cast_pointer_to_non_pointer_int)
2513  << DestType << SrcExpr.get()->getSourceRange();
2514  SrcExpr = ExprError();
2515  return;
2516  }
2517  }
2518 
2519  if (Self.getLangOpts().OpenCL && !Self.getOpenCLOptions().cl_khr_fp16) {
2520  if (DestType->isHalfType()) {
2521  Self.Diag(SrcExpr.get()->getLocStart(), diag::err_opencl_cast_to_half)
2522  << DestType << SrcExpr.get()->getSourceRange();
2523  SrcExpr = ExprError();
2524  return;
2525  }
2526  }
2527 
2528  // ARC imposes extra restrictions on casts.
2529  if (Self.getLangOpts().ObjCAutoRefCount) {
2530  checkObjCARCConversion(Sema::CCK_CStyleCast);
2531  if (SrcExpr.isInvalid())
2532  return;
2533 
2534  if (const PointerType *CastPtr = DestType->getAs<PointerType>()) {
2535  if (const PointerType *ExprPtr = SrcType->getAs<PointerType>()) {
2536  Qualifiers CastQuals = CastPtr->getPointeeType().getQualifiers();
2537  Qualifiers ExprQuals = ExprPtr->getPointeeType().getQualifiers();
2538  if (CastPtr->getPointeeType()->isObjCLifetimeType() &&
2539  ExprPtr->getPointeeType()->isObjCLifetimeType() &&
2540  !CastQuals.compatiblyIncludesObjCLifetime(ExprQuals)) {
2541  Self.Diag(SrcExpr.get()->getLocStart(),
2542  diag::err_typecheck_incompatible_ownership)
2543  << SrcType << DestType << Sema::AA_Casting
2544  << SrcExpr.get()->getSourceRange();
2545  return;
2546  }
2547  }
2548  }
2549  else if (!Self.CheckObjCARCUnavailableWeakConversion(DestType, SrcType)) {
2550  Self.Diag(SrcExpr.get()->getLocStart(),
2551  diag::err_arc_convesion_of_weak_unavailable)
2552  << 1 << SrcType << DestType << SrcExpr.get()->getSourceRange();
2553  SrcExpr = ExprError();
2554  return;
2555  }
2556  }
2557 
2558  DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType);
2559  DiagnoseCallingConvCast(Self, SrcExpr, DestType, OpRange);
2560  DiagnoseBadFunctionCast(Self, SrcExpr, DestType);
2561  Kind = Self.PrepareScalarCast(SrcExpr, DestType);
2562  if (SrcExpr.isInvalid())
2563  return;
2564 
2565  if (Kind == CK_BitCast)
2566  checkCastAlign();
2567 
2568  // -Wcast-qual
2569  QualType TheOffendingSrcType, TheOffendingDestType;
2570  Qualifiers CastAwayQualifiers;
2571  if (SrcType->isAnyPointerType() && DestType->isAnyPointerType() &&
2572  CastsAwayConstness(Self, SrcType, DestType, true, false,
2573  &TheOffendingSrcType, &TheOffendingDestType,
2574  &CastAwayQualifiers)) {
2575  int qualifiers = -1;
2576  if (CastAwayQualifiers.hasConst() && CastAwayQualifiers.hasVolatile()) {
2577  qualifiers = 0;
2578  } else if (CastAwayQualifiers.hasConst()) {
2579  qualifiers = 1;
2580  } else if (CastAwayQualifiers.hasVolatile()) {
2581  qualifiers = 2;
2582  }
2583  // This is a variant of int **x; const int **y = (const int **)x;
2584  if (qualifiers == -1)
2585  Self.Diag(SrcExpr.get()->getLocStart(), diag::warn_cast_qual2) <<
2586  SrcType << DestType;
2587  else
2588  Self.Diag(SrcExpr.get()->getLocStart(), diag::warn_cast_qual) <<
2589  TheOffendingSrcType << TheOffendingDestType << qualifiers;
2590  }
2591 }
2592 
2594  TypeSourceInfo *CastTypeInfo,
2595  SourceLocation RPLoc,
2596  Expr *CastExpr) {
2597  CastOperation Op(*this, CastTypeInfo->getType(), CastExpr);
2598  Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
2599  Op.OpRange = SourceRange(LPLoc, CastExpr->getLocEnd());
2600 
2601  if (getLangOpts().CPlusPlus) {
2602  Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ false,
2603  isa<InitListExpr>(CastExpr));
2604  } else {
2605  Op.CheckCStyleCast();
2606  }
2607 
2608  if (Op.SrcExpr.isInvalid())
2609  return ExprError();
2610 
2611  return Op.complete(CStyleCastExpr::Create(Context, Op.ResultType,
2612  Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
2613  &Op.BasePath, CastTypeInfo, LPLoc, RPLoc));
2614 }
2615 
2617  SourceLocation LPLoc,
2618  Expr *CastExpr,
2619  SourceLocation RPLoc) {
2620  assert(LPLoc.isValid() && "List-initialization shouldn't get here.");
2621  CastOperation Op(*this, CastTypeInfo->getType(), CastExpr);
2622  Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
2623  Op.OpRange = SourceRange(Op.DestRange.getBegin(), CastExpr->getLocEnd());
2624 
2625  Op.CheckCXXCStyleCast(/*FunctionalStyle=*/true, /*ListInit=*/false);
2626  if (Op.SrcExpr.isInvalid())
2627  return ExprError();
2628 
2629  auto *SubExpr = Op.SrcExpr.get();
2630  if (auto *BindExpr = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
2631  SubExpr = BindExpr->getSubExpr();
2632  if (auto *ConstructExpr = dyn_cast<CXXConstructExpr>(SubExpr))
2633  ConstructExpr->setParenOrBraceRange(SourceRange(LPLoc, RPLoc));
2634 
2635  return Op.complete(CXXFunctionalCastExpr::Create(Context, Op.ResultType,
2636  Op.ValueKind, CastTypeInfo, Op.Kind,
2637  Op.SrcExpr.get(), &Op.BasePath, LPLoc, RPLoc));
2638 }
StringRef getLastMacroWithSpelling(SourceLocation Loc, ArrayRef< TokenValue > Tokens) const
Return the name of the macro defined before Loc that has spelling Tokens.
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Definition: Type.h:466
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:1561
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:5693
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2179
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:5413
A (possibly-)qualified type.
Definition: Type.h:598
bool isInvalid() const
Definition: Ownership.h:160
A cast other than a C-style cast.
Definition: Sema.h:8507
bool isMemberPointerType() const
Definition: Type.h:5506
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:2615
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1693
const LangOptions & getLangOpts() const
Definition: Sema.h:1062
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1686
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2879
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:535
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
Definition: Preprocessor.h:934
bool isRecordType() const
Definition: Type.h:5539
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1139
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:945
The cast method is appropriate and successful.
Definition: SemaCast.cpp:35
bool isVoidPointerType() const
Definition: Type.cpp:385
bool isEnumeralType() const
Definition: Type.h:5542
std::string getAsString() const
Definition: Type.h:924
PtrTy get() const
Definition: Ownership.h:164
QualType getPointeeType() const
Definition: Type.h:2420
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Definition: Expr.h:391
Overloading for a user-defined conversion failed.
Ambiguous candidates found.
Definition: Overload.h:43
bool isBooleanType() const
Definition: Type.h:5743
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
Definition: Type.h:445
A container of type source information.
Definition: Decl.h:62
bool isBlockPointerType() const
Definition: Type.h:5488
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:631
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
static_cast
Definition: SemaCast.cpp:42
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
An Objective-C array/dictionary subscripting which reads an object or writes at the subscripted array...
Definition: Specifiers.h:136
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1624
void removeObjCLifetime()
Definition: Type.h:314
DiagnosticsEngine & Diags
Definition: Sema.h:301
static void DiagnoseCallingConvCast(Sema &Self, const ExprResult &SrcExpr, QualType DstType, SourceRange OpRange)
Diagnose casts that change the calling convention of a pointer to a function defined in the current T...
Definition: SemaCast.cpp:1729
void clear()
Clear the base-paths results.
CallingConv getCallConv() const
Definition: Type.h:3017
field_iterator field_begin() const
Definition: Decl.cpp:3767
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1813
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isVoidType() const
Definition: Type.h:5680
The collection of all-type qualifiers we support.
Definition: Type.h:117
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:3253
One of these records is kept for each identifier that is lexed.
bool isScalarType() const
Definition: Type.h:5715
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:127
(Type)expr
Definition: SemaCast.cpp:45
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:92
The cast method is not applicable.
Definition: SemaCast.cpp:34
A C-style cast.
Definition: Sema.h:8503
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:5491
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2871
TryCastResult
Definition: SemaCast.cpp:33
bool isAnyPointerType() const
Definition: Type.h:5485
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:1513
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:678
unsigned getCVRQualifiers() const
Definition: Type.h:258
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1982
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:1199
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2007
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.
OverloadCandidateDisplayKind
Definition: Overload.h:47
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:105
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1452
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2383
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:588
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:604
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:1838
tok::TokenKind getTokenID() const
If this is a source-language token (e.g.
RecordDecl * getDecl() const
Definition: Type.h:3716
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:8499
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:1746
static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind)
Definition: SemaCast.cpp:1870
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:6208
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:2632
bool hasConst() const
Definition: Type.h:236
An ordinary object is located at an address in memory.
Definition: Specifiers.h:121
static bool UnwrapDissimilarPointerTypes(QualType &T1, QualType &T2)
UnwrapDissimilarPointerTypes - Like Sema::UnwrapSimilarPointerTypes, this removes one level of indire...
Definition: SemaCast.cpp:427
bool isExtVectorType() const
Definition: Type.h:5551
detail::InMemoryDirectory::const_iterator I
bool isMemberFunctionPointer() const
Returns true if the member type (i.e.
Definition: Type.h:2424
field_iterator field_end() const
Definition: Decl.h:3385
bool isUnion() const
Definition: Decl.h:2939
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:263
A functional-style cast.
Definition: Sema.h:8505
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:1652
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:5500
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1799
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:34
bool hasVolatile() const
Definition: Type.h:243
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:131
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:155
QualType getPointeeType() const
Definition: Type.h:2300
Expr - This represents one expression.
Definition: Expr.h:105
static void diagnoseBadCast(Sema &S, unsigned msg, CastType castType, SourceRange opRange, Expr *src, QualType destType, bool listInitialization)
Diagnose a failed cast.
Definition: SemaCast.cpp:383
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:102
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:2599
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:2545
Defines the clang::Preprocessor interface.
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:510
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:219
Overload resolution succeeded.
Definition: Overload.h:41
bool isFloatingType() const
Definition: Type.cpp:1783
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
Definition: SemaCast.cpp:237
Stores token information for comparing actual tokens with predefined values.
Definition: Preprocessor.h:65
bool resolveAndFixAddressOfOnlyViableOverloadCandidate(ExprResult &SrcExpr)
Given an overloaded function, tries to turn it into a non-overloaded function reference using resolve...
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:6826
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:1774
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:1373
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:46
Represents a GCC generic vector type.
Definition: Type.h:2756
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:1189
FailureKind getFailureKind() const
Determine why initialization failed.
bool isGLValue() const
Definition: Expr.h:250
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:3372
void removeCVRQualifiers(unsigned mask)
Definition: Type.h:263
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:231
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
Definition: SemaType.cpp:4698
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
Definition: SemaCast.cpp:2593
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:5813
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:1261
CanQualType OverloadTy
Definition: ASTContext.h:909
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:617
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2483
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5730
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:146
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:3733
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Prepare a conversion of the given expression to an ObjC object pointer type.
Definition: SemaExpr.cpp:5606
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:1227
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.
ASTContext & getASTContext() const
Definition: Sema.h:1069
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1736
paths_iterator begin()
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:214
bool isKeyword(const LangOptions &LangOpts)
Return true if this token is a keyword in the specified language.
std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)
Builds a string representing ambiguous paths from a specific derived class to different subobjects of...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1625
Ref_Compatible_With_Added_Qualification - The two types are reference-compatible with added qualifica...
Definition: Sema.h:8865
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:893
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:41
Overloading for initialization by constructor failed.
is AltiVec vector
Definition: Type.h:2760
SourceLocation getBegin() const
Requests that all candidates be shown.
Definition: Overload.h:50
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5849
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:165
bool isVectorType() const
Definition: Type.h:5548
bool isMemberFunctionPointerType() const
Definition: Type.h:5509
void removeObjCGCAttr()
Definition: Type.h:291
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:701
reinterpret_cast
Definition: SemaCast.cpp:43
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:652
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
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:594
QualType getPointeeType() const
Definition: Type.h:2193
A POD class for pairing a NamedDecl* with an access specifier.
dynamic_cast
Definition: SemaCast.cpp:44
Represents an element in a path from a derived class to a base class.
QualType getType() const
Definition: Expr.h:126
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
void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, bool IsDereference, SourceRange Range)
Definition: SemaCast.cpp:1660
The cast method is appropriate, but failed.
Definition: SemaCast.cpp:36
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:247
static void checkIntToPointerCast(bool CStyle, SourceLocation Loc, const Expr *SrcExpr, QualType DestType, Sema &Self)
Definition: SemaCast.cpp:1818
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:2401
ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, SourceLocation LParenLoc, Expr *CastExpr, SourceLocation RParenLoc)
Definition: SemaCast.cpp:2616
bool isHalfType() const
Definition: Type.h:5686
void setCVRQualifiers(unsigned mask)
Definition: Type.h:259
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:1966
static void DiagnoseCastOfObjCSEL(Sema &Self, const ExprResult &SrcExpr, QualType DestType)
Definition: SemaCast.cpp:1710
static bool fixOverloadedReinterpretCastExpr(Sema &Self, QualType DestType, ExprResult &Result)
Definition: SemaCast.cpp:1844
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:1473
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2413
bool isRValueReferenceType() const
Definition: Type.h:5497
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5006
Represents a pointer to an Objective C object.
Definition: Type.h:4991
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:127
Pointer to a block type.
Definition: Type.h:2286
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3707
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:307
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
bool isAddressSpaceOverlapping(const PointerType &other) const
Returns true if address spaces of pointers overlap.
Definition: Type.h:2203
QualType getCanonicalType() const
Definition: Type.h:5298
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:1673
bool isFunctionType() const
Definition: Type.h:5479
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:6192
CXXBasePath & front()
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2319
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1528
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:487
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:1135
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
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:124
bool isUsable() const
Definition: Ownership.h:161
QualType getPointeeType() const
Definition: Type.h:2340
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:2434
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang's AST.
Definition: ASTMatchers.h:1920
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:5339
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
bool isObjCObjectPointerType() const
Definition: Type.h:5554
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:5654
CallingConv getDefaultCallingConvention(bool isVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
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.
bool isEventT() const
Definition: Type.h:5607
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:2039
Defines the clang::TargetInfo interface.
DeclarationName getName() const
Gets the name looked up.
Definition: ExprCXX.h:2587
ExprResult ExprError()
Definition: Ownership.h:268
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:2299
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:932
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:401
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:3115
static StringRef getNameForCallConv(CallingConv CC)
Definition: Type.cpp:2631
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:299
paths_iterator end()
bool isInvalidType() const
Definition: DeclSpec.h:2222
bool isArithmeticType() const
Definition: Type.cpp:1814
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:1706
Describes an entity that is being initialized.
Preprocessor & getPreprocessor() const
Definition: Sema.h:1068
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
CastType
Definition: SemaCast.cpp:40
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:746
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:5702
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:97
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5286
bool isPointerType() const
Definition: Type.h:5482
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1583