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