Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 1 | //===--- SemaNamedCast.cpp - Semantic Analysis for Named Casts ------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements semantic analysis for C++ named casts. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
John McCall | 2d88708 | 2010-08-25 22:03:47 +0000 | [diff] [blame] | 14 | #include "clang/Sema/SemaInternal.h" |
Douglas Gregor | e737f50 | 2010-08-12 20:07:10 +0000 | [diff] [blame] | 15 | #include "clang/Sema/Initialization.h" |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 16 | #include "clang/AST/ExprCXX.h" |
| 17 | #include "clang/AST/ASTContext.h" |
Douglas Gregor | a8f32e0 | 2009-10-06 17:59:45 +0000 | [diff] [blame] | 18 | #include "clang/AST/CXXInheritance.h" |
Anders Carlsson | b790661 | 2009-08-26 23:45:07 +0000 | [diff] [blame] | 19 | #include "clang/Basic/PartialDiagnostic.h" |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 20 | #include "llvm/ADT/SmallVector.h" |
Sebastian Redl | e3dc28a | 2008-11-07 23:29:29 +0000 | [diff] [blame] | 21 | #include <set> |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 22 | using namespace clang; |
| 23 | |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 24 | |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 25 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 26 | enum TryCastResult { |
| 27 | TC_NotApplicable, ///< The cast method is not applicable. |
| 28 | TC_Success, ///< The cast method is appropriate and successful. |
| 29 | TC_Failed ///< The cast method is appropriate, but failed. A |
| 30 | ///< diagnostic has been emitted. |
| 31 | }; |
| 32 | |
| 33 | enum CastType { |
| 34 | CT_Const, ///< const_cast |
| 35 | CT_Static, ///< static_cast |
| 36 | CT_Reinterpret, ///< reinterpret_cast |
| 37 | CT_Dynamic, ///< dynamic_cast |
| 38 | CT_CStyle, ///< (Type)expr |
| 39 | CT_Functional ///< Type(expr) |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 40 | }; |
| 41 | |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 42 | |
| 43 | |
| 44 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 45 | static void CheckConstCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 46 | ExprValueKind &VK, |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 47 | const SourceRange &OpRange, |
| 48 | const SourceRange &DestRange); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 49 | static void CheckReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 50 | ExprValueKind &VK, |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 51 | const SourceRange &OpRange, |
Anders Carlsson | 7f9e646 | 2009-09-15 04:48:33 +0000 | [diff] [blame] | 52 | const SourceRange &DestRange, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 53 | CastKind &Kind); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 54 | static void CheckStaticCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 55 | ExprValueKind &VK, |
Anders Carlsson | cdb6197 | 2009-08-07 22:21:05 +0000 | [diff] [blame] | 56 | const SourceRange &OpRange, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 57 | CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 58 | CXXCastPath &BasePath); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 59 | static void CheckDynamicCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 60 | ExprValueKind &VK, |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 61 | const SourceRange &OpRange, |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 62 | const SourceRange &DestRange, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 63 | CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 64 | CXXCastPath &BasePath); |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 65 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 66 | static bool CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType, |
| 67 | bool CheckCVR, bool CheckObjCLifetime); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 68 | |
| 69 | // The Try functions attempt a specific way of casting. If they succeed, they |
| 70 | // return TC_Success. If their way of casting is not appropriate for the given |
| 71 | // arguments, they return TC_NotApplicable and *may* set diag to a diagnostic |
| 72 | // to emit if no other way succeeds. If their way of casting is appropriate but |
| 73 | // fails, they return TC_Failed and *must* set diag; they can set it to 0 if |
| 74 | // they emit a specialized diagnostic. |
| 75 | // All diagnostics returned by these functions must expect the same three |
| 76 | // arguments: |
| 77 | // %0: Cast Type (a value from the CastType enumeration) |
| 78 | // %1: Source Type |
| 79 | // %2: Destination Type |
| 80 | static TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, |
Douglas Gregor | 8ec14e6 | 2011-01-26 21:04:06 +0000 | [diff] [blame] | 81 | QualType DestType, bool CStyle, |
| 82 | CastKind &Kind, |
Douglas Gregor | 88b22a4 | 2011-01-25 16:13:26 +0000 | [diff] [blame] | 83 | CXXCastPath &BasePath, |
| 84 | unsigned &msg); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 85 | static TryCastResult TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, |
Anders Carlsson | f9d68e1 | 2010-04-24 19:36:51 +0000 | [diff] [blame] | 86 | QualType DestType, bool CStyle, |
| 87 | const SourceRange &OpRange, |
| 88 | unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 89 | CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 90 | CXXCastPath &BasePath); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 91 | static TryCastResult TryStaticPointerDowncast(Sema &Self, QualType SrcType, |
| 92 | QualType DestType, bool CStyle, |
| 93 | const SourceRange &OpRange, |
Anders Carlsson | 95c5d8a | 2009-11-12 16:53:16 +0000 | [diff] [blame] | 94 | unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 95 | CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 96 | CXXCastPath &BasePath); |
Douglas Gregor | ab15d0e | 2009-11-15 09:20:52 +0000 | [diff] [blame] | 97 | static TryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType, |
| 98 | CanQualType DestType, bool CStyle, |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 99 | const SourceRange &OpRange, |
| 100 | QualType OrigSrcType, |
Anders Carlsson | 95c5d8a | 2009-11-12 16:53:16 +0000 | [diff] [blame] | 101 | QualType OrigDestType, unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 102 | CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 103 | CXXCastPath &BasePath); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 104 | static TryCastResult TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, |
Anders Carlsson | cee2242 | 2010-04-24 19:22:20 +0000 | [diff] [blame] | 105 | QualType SrcType, |
| 106 | QualType DestType,bool CStyle, |
| 107 | const SourceRange &OpRange, |
| 108 | unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 109 | CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 110 | CXXCastPath &BasePath); |
Anders Carlsson | cee2242 | 2010-04-24 19:22:20 +0000 | [diff] [blame] | 111 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 112 | static TryCastResult TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 113 | QualType DestType, |
| 114 | Sema::CheckedConversionKind CCK, |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 115 | const SourceRange &OpRange, |
Fariborz Jahanian | e9f4208 | 2009-08-26 18:55:36 +0000 | [diff] [blame] | 116 | unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 117 | CastKind &Kind); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 118 | static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr, |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 119 | QualType DestType, |
| 120 | Sema::CheckedConversionKind CCK, |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 121 | const SourceRange &OpRange, |
Anders Carlsson | cb3c308 | 2009-09-01 20:52:42 +0000 | [diff] [blame] | 122 | unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 123 | CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 124 | CXXCastPath &BasePath); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 125 | static TryCastResult TryConstCast(Sema &Self, Expr *SrcExpr, QualType DestType, |
| 126 | bool CStyle, unsigned &msg); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 127 | static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 128 | QualType DestType, bool CStyle, |
| 129 | const SourceRange &OpRange, |
Anders Carlsson | 3c31a39 | 2009-09-26 00:12:34 +0000 | [diff] [blame] | 130 | unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 131 | CastKind &Kind); |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 132 | |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 133 | |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 134 | /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's. |
John McCall | 60d7b3a | 2010-08-24 06:29:42 +0000 | [diff] [blame] | 135 | ExprResult |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 136 | Sema::ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, |
Argyrios Kyrtzidis | 31862ba | 2011-07-01 22:22:50 +0000 | [diff] [blame] | 137 | SourceLocation LAngleBracketLoc, Declarator &D, |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 138 | SourceLocation RAngleBracketLoc, |
John McCall | f312b1e | 2010-08-26 23:41:50 +0000 | [diff] [blame] | 139 | SourceLocation LParenLoc, Expr *E, |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 140 | SourceLocation RParenLoc) { |
John McCall | c89724c | 2010-01-15 19:13:16 +0000 | [diff] [blame] | 141 | |
Argyrios Kyrtzidis | 31862ba | 2011-07-01 22:22:50 +0000 | [diff] [blame] | 142 | assert(!D.isInvalidType()); |
| 143 | |
| 144 | TypeSourceInfo *TInfo = GetTypeForDeclaratorCast(D, E->getType()); |
| 145 | if (D.isInvalidType()) |
| 146 | return ExprError(); |
| 147 | |
| 148 | if (getLangOptions().CPlusPlus) { |
| 149 | // Check that there are no default arguments (C++ only). |
| 150 | CheckExtraCXXDefaultArguments(D); |
| 151 | } |
| 152 | |
| 153 | return BuildCXXNamedCast(OpLoc, Kind, TInfo, move(E), |
John McCall | c89724c | 2010-01-15 19:13:16 +0000 | [diff] [blame] | 154 | SourceRange(LAngleBracketLoc, RAngleBracketLoc), |
| 155 | SourceRange(LParenLoc, RParenLoc)); |
| 156 | } |
| 157 | |
John McCall | 60d7b3a | 2010-08-24 06:29:42 +0000 | [diff] [blame] | 158 | ExprResult |
John McCall | c89724c | 2010-01-15 19:13:16 +0000 | [diff] [blame] | 159 | Sema::BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 160 | TypeSourceInfo *DestTInfo, Expr *E, |
John McCall | c89724c | 2010-01-15 19:13:16 +0000 | [diff] [blame] | 161 | SourceRange AngleBrackets, SourceRange Parens) { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 162 | ExprResult Ex = Owned(E); |
John McCall | c89724c | 2010-01-15 19:13:16 +0000 | [diff] [blame] | 163 | QualType DestType = DestTInfo->getType(); |
| 164 | |
| 165 | SourceRange OpRange(OpLoc, Parens.getEnd()); |
| 166 | SourceRange DestRange = AngleBrackets; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 167 | |
Douglas Gregor | 9103bb2 | 2008-12-17 22:52:20 +0000 | [diff] [blame] | 168 | // If the type is dependent, we won't do the semantic analysis now. |
| 169 | // FIXME: should we check this in a more fine-grained manner? |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 170 | bool TypeDependent = DestType->isDependentType() || Ex.get()->isTypeDependent(); |
Douglas Gregor | 9103bb2 | 2008-12-17 22:52:20 +0000 | [diff] [blame] | 171 | |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 172 | ExprValueKind VK = VK_RValue; |
John McCall | a21e06c | 2010-11-26 10:57:22 +0000 | [diff] [blame] | 173 | if (TypeDependent) |
| 174 | VK = Expr::getValueKindForType(DestType); |
| 175 | |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 176 | switch (Kind) { |
John McCall | daa8e4e | 2010-11-15 09:13:47 +0000 | [diff] [blame] | 177 | default: llvm_unreachable("Unknown C++ cast!"); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 178 | |
| 179 | case tok::kw_const_cast: |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 180 | if (!TypeDependent) { |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 181 | CheckConstCast(*this, Ex, DestType, VK, OpRange, DestRange); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 182 | if (Ex.isInvalid()) |
| 183 | return ExprError(); |
| 184 | } |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 185 | return Owned(CXXConstCastExpr::Create(Context, |
Douglas Gregor | 6398235 | 2010-07-13 18:40:04 +0000 | [diff] [blame] | 186 | DestType.getNonLValueExprType(Context), |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 187 | VK, Ex.take(), DestTInfo, OpLoc, |
Douglas Gregor | 1d5d0b9 | 2011-01-12 22:41:29 +0000 | [diff] [blame] | 188 | Parens.getEnd())); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 189 | |
Anders Carlsson | 714179b | 2009-08-02 19:07:59 +0000 | [diff] [blame] | 190 | case tok::kw_dynamic_cast: { |
John McCall | daa8e4e | 2010-11-15 09:13:47 +0000 | [diff] [blame] | 191 | CastKind Kind = CK_Dependent; |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 192 | CXXCastPath BasePath; |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 193 | if (!TypeDependent) { |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 194 | CheckDynamicCast(*this, Ex, DestType, VK, OpRange, DestRange, |
| 195 | Kind, BasePath); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 196 | if (Ex.isInvalid()) |
| 197 | return ExprError(); |
| 198 | } |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 199 | return Owned(CXXDynamicCastExpr::Create(Context, |
Douglas Gregor | 6398235 | 2010-07-13 18:40:04 +0000 | [diff] [blame] | 200 | DestType.getNonLValueExprType(Context), |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 201 | VK, Kind, Ex.take(), &BasePath, DestTInfo, |
Douglas Gregor | 1d5d0b9 | 2011-01-12 22:41:29 +0000 | [diff] [blame] | 202 | OpLoc, Parens.getEnd())); |
Anders Carlsson | 714179b | 2009-08-02 19:07:59 +0000 | [diff] [blame] | 203 | } |
Anders Carlsson | 7f9e646 | 2009-09-15 04:48:33 +0000 | [diff] [blame] | 204 | case tok::kw_reinterpret_cast: { |
John McCall | daa8e4e | 2010-11-15 09:13:47 +0000 | [diff] [blame] | 205 | CastKind Kind = CK_Dependent; |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 206 | if (!TypeDependent) { |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 207 | CheckReinterpretCast(*this, Ex, DestType, VK, OpRange, DestRange, Kind); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 208 | if (Ex.isInvalid()) |
| 209 | return ExprError(); |
| 210 | } |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 211 | return Owned(CXXReinterpretCastExpr::Create(Context, |
Douglas Gregor | 6398235 | 2010-07-13 18:40:04 +0000 | [diff] [blame] | 212 | DestType.getNonLValueExprType(Context), |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 213 | VK, Kind, Ex.take(), 0, |
Douglas Gregor | 1d5d0b9 | 2011-01-12 22:41:29 +0000 | [diff] [blame] | 214 | DestTInfo, OpLoc, Parens.getEnd())); |
Anders Carlsson | 7f9e646 | 2009-09-15 04:48:33 +0000 | [diff] [blame] | 215 | } |
Anders Carlsson | cdb6197 | 2009-08-07 22:21:05 +0000 | [diff] [blame] | 216 | case tok::kw_static_cast: { |
John McCall | daa8e4e | 2010-11-15 09:13:47 +0000 | [diff] [blame] | 217 | CastKind Kind = CK_Dependent; |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 218 | CXXCastPath BasePath; |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 219 | if (!TypeDependent) { |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 220 | CheckStaticCast(*this, Ex, DestType, VK, OpRange, Kind, BasePath); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 221 | if (Ex.isInvalid()) |
| 222 | return ExprError(); |
| 223 | } |
Anders Carlsson | 0aebc81 | 2009-09-09 21:33:21 +0000 | [diff] [blame] | 224 | |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 225 | return Owned(CXXStaticCastExpr::Create(Context, |
Douglas Gregor | 6398235 | 2010-07-13 18:40:04 +0000 | [diff] [blame] | 226 | DestType.getNonLValueExprType(Context), |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 227 | VK, Kind, Ex.take(), &BasePath, |
Douglas Gregor | 1d5d0b9 | 2011-01-12 22:41:29 +0000 | [diff] [blame] | 228 | DestTInfo, OpLoc, Parens.getEnd())); |
Anders Carlsson | cdb6197 | 2009-08-07 22:21:05 +0000 | [diff] [blame] | 229 | } |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 230 | } |
| 231 | |
Sebastian Redl | f53597f | 2009-03-15 17:47:39 +0000 | [diff] [blame] | 232 | return ExprError(); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 233 | } |
| 234 | |
John McCall | 79ab2c8 | 2011-02-14 18:34:10 +0000 | [diff] [blame] | 235 | /// Try to diagnose a failed overloaded cast. Returns true if |
| 236 | /// diagnostics were emitted. |
| 237 | static bool tryDiagnoseOverloadedCast(Sema &S, CastType CT, |
| 238 | SourceRange range, Expr *src, |
| 239 | QualType destType) { |
| 240 | switch (CT) { |
| 241 | // These cast kinds don't consider user-defined conversions. |
| 242 | case CT_Const: |
| 243 | case CT_Reinterpret: |
| 244 | case CT_Dynamic: |
| 245 | return false; |
| 246 | |
| 247 | // These do. |
| 248 | case CT_Static: |
| 249 | case CT_CStyle: |
| 250 | case CT_Functional: |
| 251 | break; |
| 252 | } |
| 253 | |
| 254 | QualType srcType = src->getType(); |
| 255 | if (!destType->isRecordType() && !srcType->isRecordType()) |
| 256 | return false; |
| 257 | |
| 258 | InitializedEntity entity = InitializedEntity::InitializeTemporary(destType); |
| 259 | InitializationKind initKind |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 260 | = (CT == CT_CStyle)? InitializationKind::CreateCStyleCast(range.getBegin(), |
| 261 | range) |
| 262 | : (CT == CT_Functional)? InitializationKind::CreateFunctionalCast(range) |
| 263 | : InitializationKind::CreateCast(/*type range?*/ range); |
John McCall | 79ab2c8 | 2011-02-14 18:34:10 +0000 | [diff] [blame] | 264 | InitializationSequence sequence(S, entity, initKind, &src, 1); |
| 265 | |
Sebastian Redl | 383616c | 2011-06-05 12:23:28 +0000 | [diff] [blame] | 266 | assert(sequence.Failed() && "initialization succeeded on second try?"); |
John McCall | 79ab2c8 | 2011-02-14 18:34:10 +0000 | [diff] [blame] | 267 | switch (sequence.getFailureKind()) { |
| 268 | default: return false; |
| 269 | |
| 270 | case InitializationSequence::FK_ConstructorOverloadFailed: |
| 271 | case InitializationSequence::FK_UserConversionOverloadFailed: |
| 272 | break; |
| 273 | } |
| 274 | |
| 275 | OverloadCandidateSet &candidates = sequence.getFailedCandidateSet(); |
| 276 | |
| 277 | unsigned msg = 0; |
| 278 | OverloadCandidateDisplayKind howManyCandidates = OCD_AllCandidates; |
| 279 | |
| 280 | switch (sequence.getFailedOverloadResult()) { |
| 281 | case OR_Success: llvm_unreachable("successful failed overload"); |
| 282 | return false; |
| 283 | case OR_No_Viable_Function: |
| 284 | if (candidates.empty()) |
| 285 | msg = diag::err_ovl_no_conversion_in_cast; |
| 286 | else |
| 287 | msg = diag::err_ovl_no_viable_conversion_in_cast; |
| 288 | howManyCandidates = OCD_AllCandidates; |
| 289 | break; |
| 290 | |
| 291 | case OR_Ambiguous: |
| 292 | msg = diag::err_ovl_ambiguous_conversion_in_cast; |
| 293 | howManyCandidates = OCD_ViableCandidates; |
| 294 | break; |
| 295 | |
| 296 | case OR_Deleted: |
| 297 | msg = diag::err_ovl_deleted_conversion_in_cast; |
| 298 | howManyCandidates = OCD_ViableCandidates; |
| 299 | break; |
| 300 | } |
| 301 | |
| 302 | S.Diag(range.getBegin(), msg) |
| 303 | << CT << srcType << destType |
| 304 | << range << src->getSourceRange(); |
| 305 | |
| 306 | candidates.NoteCandidates(S, howManyCandidates, &src, 1); |
| 307 | |
| 308 | return true; |
| 309 | } |
| 310 | |
| 311 | /// Diagnose a failed cast. |
| 312 | static void diagnoseBadCast(Sema &S, unsigned msg, CastType castType, |
| 313 | SourceRange opRange, Expr *src, QualType destType) { |
John McCall | 864c041 | 2011-04-26 20:42:42 +0000 | [diff] [blame] | 314 | if (src->getType() == S.Context.BoundMemberTy) { |
| 315 | (void) S.CheckPlaceholderExpr(src); // will always fail |
| 316 | return; |
| 317 | } |
| 318 | |
John McCall | 79ab2c8 | 2011-02-14 18:34:10 +0000 | [diff] [blame] | 319 | if (msg == diag::err_bad_cxx_cast_generic && |
| 320 | tryDiagnoseOverloadedCast(S, castType, opRange, src, destType)) |
| 321 | return; |
| 322 | |
| 323 | S.Diag(opRange.getBegin(), msg) << castType |
| 324 | << src->getType() << destType << opRange << src->getSourceRange(); |
| 325 | } |
| 326 | |
Sebastian Redl | 76d69bb | 2009-11-18 18:10:53 +0000 | [diff] [blame] | 327 | /// UnwrapDissimilarPointerTypes - Like Sema::UnwrapSimilarPointerTypes, |
| 328 | /// this removes one level of indirection from both types, provided that they're |
| 329 | /// the same kind of pointer (plain or to-member). Unlike the Sema function, |
| 330 | /// this one doesn't care if the two pointers-to-member don't point into the |
| 331 | /// same class. This is because CastsAwayConstness doesn't care. |
Dan Gohman | 3c46e8d | 2010-07-26 21:25:24 +0000 | [diff] [blame] | 332 | static bool UnwrapDissimilarPointerTypes(QualType& T1, QualType& T2) { |
Sebastian Redl | 76d69bb | 2009-11-18 18:10:53 +0000 | [diff] [blame] | 333 | const PointerType *T1PtrType = T1->getAs<PointerType>(), |
| 334 | *T2PtrType = T2->getAs<PointerType>(); |
| 335 | if (T1PtrType && T2PtrType) { |
| 336 | T1 = T1PtrType->getPointeeType(); |
| 337 | T2 = T2PtrType->getPointeeType(); |
| 338 | return true; |
| 339 | } |
Fariborz Jahanian | 72a8659 | 2010-02-03 20:32:31 +0000 | [diff] [blame] | 340 | const ObjCObjectPointerType *T1ObjCPtrType = |
| 341 | T1->getAs<ObjCObjectPointerType>(), |
| 342 | *T2ObjCPtrType = |
| 343 | T2->getAs<ObjCObjectPointerType>(); |
| 344 | if (T1ObjCPtrType) { |
| 345 | if (T2ObjCPtrType) { |
| 346 | T1 = T1ObjCPtrType->getPointeeType(); |
| 347 | T2 = T2ObjCPtrType->getPointeeType(); |
| 348 | return true; |
| 349 | } |
| 350 | else if (T2PtrType) { |
| 351 | T1 = T1ObjCPtrType->getPointeeType(); |
| 352 | T2 = T2PtrType->getPointeeType(); |
| 353 | return true; |
| 354 | } |
| 355 | } |
| 356 | else if (T2ObjCPtrType) { |
| 357 | if (T1PtrType) { |
| 358 | T2 = T2ObjCPtrType->getPointeeType(); |
| 359 | T1 = T1PtrType->getPointeeType(); |
| 360 | return true; |
| 361 | } |
| 362 | } |
| 363 | |
Sebastian Redl | 76d69bb | 2009-11-18 18:10:53 +0000 | [diff] [blame] | 364 | const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), |
| 365 | *T2MPType = T2->getAs<MemberPointerType>(); |
| 366 | if (T1MPType && T2MPType) { |
| 367 | T1 = T1MPType->getPointeeType(); |
| 368 | T2 = T2MPType->getPointeeType(); |
| 369 | return true; |
| 370 | } |
Douglas Gregor | bf9fb88 | 2010-07-08 20:27:32 +0000 | [diff] [blame] | 371 | |
| 372 | const BlockPointerType *T1BPType = T1->getAs<BlockPointerType>(), |
| 373 | *T2BPType = T2->getAs<BlockPointerType>(); |
| 374 | if (T1BPType && T2BPType) { |
| 375 | T1 = T1BPType->getPointeeType(); |
| 376 | T2 = T2BPType->getPointeeType(); |
| 377 | return true; |
| 378 | } |
| 379 | |
Sebastian Redl | 76d69bb | 2009-11-18 18:10:53 +0000 | [diff] [blame] | 380 | return false; |
| 381 | } |
| 382 | |
Sebastian Redl | db64728 | 2009-01-27 23:18:31 +0000 | [diff] [blame] | 383 | /// CastsAwayConstness - Check if the pointer conversion from SrcType to |
| 384 | /// DestType casts away constness as defined in C++ 5.2.11p8ff. This is used by |
| 385 | /// the cast checkers. Both arguments must denote pointer (possibly to member) |
| 386 | /// types. |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 387 | /// |
| 388 | /// \param CheckCVR Whether to check for const/volatile/restrict qualifiers. |
| 389 | /// |
| 390 | /// \param CheckObjCLifetime Whether to check Objective-C lifetime qualifiers. |
Sebastian Redl | 5ed66f7 | 2009-10-22 15:07:22 +0000 | [diff] [blame] | 391 | static bool |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 392 | CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType, |
| 393 | bool CheckCVR, bool CheckObjCLifetime) { |
| 394 | // If the only checking we care about is for Objective-C lifetime qualifiers, |
| 395 | // and we're not in ARC mode, there's nothing to check. |
| 396 | if (!CheckCVR && CheckObjCLifetime && |
| 397 | !Self.Context.getLangOptions().ObjCAutoRefCount) |
| 398 | return false; |
| 399 | |
Sebastian Redl | db64728 | 2009-01-27 23:18:31 +0000 | [diff] [blame] | 400 | // Casting away constness is defined in C++ 5.2.11p8 with reference to |
| 401 | // C++ 4.4. We piggyback on Sema::IsQualificationConversion for this, since |
| 402 | // the rules are non-trivial. So first we construct Tcv *...cv* as described |
| 403 | // in C++ 5.2.11p8. |
Douglas Gregor | bf9fb88 | 2010-07-08 20:27:32 +0000 | [diff] [blame] | 404 | assert((SrcType->isAnyPointerType() || SrcType->isMemberPointerType() || |
| 405 | SrcType->isBlockPointerType()) && |
Sebastian Redl | db64728 | 2009-01-27 23:18:31 +0000 | [diff] [blame] | 406 | "Source type is not pointer or pointer to member."); |
Douglas Gregor | bf9fb88 | 2010-07-08 20:27:32 +0000 | [diff] [blame] | 407 | assert((DestType->isAnyPointerType() || DestType->isMemberPointerType() || |
| 408 | DestType->isBlockPointerType()) && |
Sebastian Redl | db64728 | 2009-01-27 23:18:31 +0000 | [diff] [blame] | 409 | "Destination type is not pointer or pointer to member."); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 410 | |
Douglas Gregor | ab15d0e | 2009-11-15 09:20:52 +0000 | [diff] [blame] | 411 | QualType UnwrappedSrcType = Self.Context.getCanonicalType(SrcType), |
| 412 | UnwrappedDestType = Self.Context.getCanonicalType(DestType); |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame^] | 413 | SmallVector<Qualifiers, 8> cv1, cv2; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 414 | |
Douglas Gregor | d4c5f84 | 2011-04-15 17:59:54 +0000 | [diff] [blame] | 415 | // Find the qualifiers. We only care about cvr-qualifiers for the |
| 416 | // purpose of this check, because other qualifiers (address spaces, |
| 417 | // Objective-C GC, etc.) are part of the type's identity. |
Sebastian Redl | 76d69bb | 2009-11-18 18:10:53 +0000 | [diff] [blame] | 418 | while (UnwrapDissimilarPointerTypes(UnwrappedSrcType, UnwrappedDestType)) { |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 419 | // Determine the relevant qualifiers at this level. |
| 420 | Qualifiers SrcQuals, DestQuals; |
Anders Carlsson | 52647c6 | 2010-06-04 22:47:55 +0000 | [diff] [blame] | 421 | Self.Context.getUnqualifiedArrayType(UnwrappedSrcType, SrcQuals); |
Anders Carlsson | 52647c6 | 2010-06-04 22:47:55 +0000 | [diff] [blame] | 422 | Self.Context.getUnqualifiedArrayType(UnwrappedDestType, DestQuals); |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 423 | |
| 424 | Qualifiers RetainedSrcQuals, RetainedDestQuals; |
| 425 | if (CheckCVR) { |
| 426 | RetainedSrcQuals.setCVRQualifiers(SrcQuals.getCVRQualifiers()); |
| 427 | RetainedDestQuals.setCVRQualifiers(DestQuals.getCVRQualifiers()); |
| 428 | } |
| 429 | |
| 430 | if (CheckObjCLifetime && |
| 431 | !DestQuals.compatiblyIncludesObjCLifetime(SrcQuals)) |
| 432 | return true; |
| 433 | |
| 434 | cv1.push_back(RetainedSrcQuals); |
| 435 | cv2.push_back(RetainedDestQuals); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 436 | } |
Douglas Gregor | bf9fb88 | 2010-07-08 20:27:32 +0000 | [diff] [blame] | 437 | if (cv1.empty()) |
| 438 | return false; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 439 | |
| 440 | // Construct void pointers with those qualifiers (in reverse order of |
| 441 | // unwrapping, of course). |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 442 | QualType SrcConstruct = Self.Context.VoidTy; |
| 443 | QualType DestConstruct = Self.Context.VoidTy; |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 444 | ASTContext &Context = Self.Context; |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame^] | 445 | for (SmallVector<Qualifiers, 8>::reverse_iterator i1 = cv1.rbegin(), |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 446 | i2 = cv2.rbegin(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 447 | i1 != cv1.rend(); ++i1, ++i2) { |
John McCall | 0953e76 | 2009-09-24 19:53:00 +0000 | [diff] [blame] | 448 | SrcConstruct |
| 449 | = Context.getPointerType(Context.getQualifiedType(SrcConstruct, *i1)); |
| 450 | DestConstruct |
| 451 | = Context.getPointerType(Context.getQualifiedType(DestConstruct, *i2)); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 452 | } |
| 453 | |
| 454 | // Test if they're compatible. |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 455 | bool ObjCLifetimeConversion; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 456 | return SrcConstruct != DestConstruct && |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 457 | !Self.IsQualificationConversion(SrcConstruct, DestConstruct, false, |
| 458 | ObjCLifetimeConversion); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 459 | } |
| 460 | |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 461 | /// CheckDynamicCast - Check that a dynamic_cast\<DestType\>(SrcExpr) is valid. |
| 462 | /// Refer to C++ 5.2.7 for details. Dynamic casts are used mostly for runtime- |
| 463 | /// checked downcasts in class hierarchies. |
Anders Carlsson | 714179b | 2009-08-02 19:07:59 +0000 | [diff] [blame] | 464 | static void |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 465 | CheckDynamicCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 466 | ExprValueKind &VK, const SourceRange &OpRange, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 467 | const SourceRange &DestRange, CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 468 | CXXCastPath &BasePath) { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 469 | QualType OrigDestType = DestType, OrigSrcType = SrcExpr.get()->getType(); |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 470 | DestType = Self.Context.getCanonicalType(DestType); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 471 | |
| 472 | // C++ 5.2.7p1: T shall be a pointer or reference to a complete class type, |
| 473 | // or "pointer to cv void". |
| 474 | |
| 475 | QualType DestPointee; |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 476 | const PointerType *DestPointer = DestType->getAs<PointerType>(); |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 477 | const ReferenceType *DestReference = 0; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 478 | if (DestPointer) { |
| 479 | DestPointee = DestPointer->getPointeeType(); |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 480 | } else if ((DestReference = DestType->getAs<ReferenceType>())) { |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 481 | DestPointee = DestReference->getPointeeType(); |
Douglas Gregor | dc843f2 | 2011-01-22 00:06:57 +0000 | [diff] [blame] | 482 | VK = isa<LValueReferenceType>(DestReference) ? VK_LValue |
| 483 | : isa<RValueReferenceType>(DestReference) ? VK_XValue |
| 484 | : VK_RValue; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 485 | } else { |
Chris Lattner | c9c7c4e | 2008-11-18 22:52:51 +0000 | [diff] [blame] | 486 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ref_or_ptr) |
Chris Lattner | d162584 | 2008-11-24 06:25:27 +0000 | [diff] [blame] | 487 | << OrigDestType << DestRange; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 488 | return; |
| 489 | } |
| 490 | |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 491 | const RecordType *DestRecord = DestPointee->getAs<RecordType>(); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 492 | if (DestPointee->isVoidType()) { |
| 493 | assert(DestPointer && "Reference to void is not possible"); |
| 494 | } else if (DestRecord) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 495 | if (Self.RequireCompleteType(OpRange.getBegin(), DestPointee, |
Douglas Gregor | fe6b2d4 | 2010-03-29 23:34:08 +0000 | [diff] [blame] | 496 | Self.PDiag(diag::err_bad_dynamic_cast_incomplete) |
Anders Carlsson | b790661 | 2009-08-26 23:45:07 +0000 | [diff] [blame] | 497 | << DestRange)) |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 498 | return; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 499 | } else { |
Chris Lattner | c9c7c4e | 2008-11-18 22:52:51 +0000 | [diff] [blame] | 500 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class) |
Chris Lattner | d162584 | 2008-11-24 06:25:27 +0000 | [diff] [blame] | 501 | << DestPointee.getUnqualifiedType() << DestRange; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 502 | return; |
| 503 | } |
| 504 | |
Sebastian Redl | 7c80bd6 | 2009-03-16 23:22:08 +0000 | [diff] [blame] | 505 | // C++0x 5.2.7p2: If T is a pointer type, v shall be an rvalue of a pointer to |
| 506 | // complete class type, [...]. If T is an lvalue reference type, v shall be |
Douglas Gregor | dc843f2 | 2011-01-22 00:06:57 +0000 | [diff] [blame] | 507 | // an lvalue of a complete class type, [...]. If T is an rvalue reference |
| 508 | // type, v shall be an expression having a complete class type, [...] |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 509 | QualType SrcType = Self.Context.getCanonicalType(OrigSrcType); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 510 | QualType SrcPointee; |
| 511 | if (DestPointer) { |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 512 | if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) { |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 513 | SrcPointee = SrcPointer->getPointeeType(); |
| 514 | } else { |
Chris Lattner | c9c7c4e | 2008-11-18 22:52:51 +0000 | [diff] [blame] | 515 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ptr) |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 516 | << OrigSrcType << SrcExpr.get()->getSourceRange(); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 517 | return; |
| 518 | } |
Sebastian Redl | 7c80bd6 | 2009-03-16 23:22:08 +0000 | [diff] [blame] | 519 | } else if (DestReference->isLValueReferenceType()) { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 520 | if (!SrcExpr.get()->isLValue()) { |
Chris Lattner | c9c7c4e | 2008-11-18 22:52:51 +0000 | [diff] [blame] | 521 | Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_rvalue) |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 522 | << CT_Dynamic << OrigSrcType << OrigDestType << OpRange; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 523 | } |
| 524 | SrcPointee = SrcType; |
Sebastian Redl | 7c80bd6 | 2009-03-16 23:22:08 +0000 | [diff] [blame] | 525 | } else { |
| 526 | SrcPointee = SrcType; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 527 | } |
| 528 | |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 529 | const RecordType *SrcRecord = SrcPointee->getAs<RecordType>(); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 530 | if (SrcRecord) { |
Douglas Gregor | 86447ec | 2009-03-09 16:13:40 +0000 | [diff] [blame] | 531 | if (Self.RequireCompleteType(OpRange.getBegin(), SrcPointee, |
Douglas Gregor | fe6b2d4 | 2010-03-29 23:34:08 +0000 | [diff] [blame] | 532 | Self.PDiag(diag::err_bad_dynamic_cast_incomplete) |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 533 | << SrcExpr.get()->getSourceRange())) |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 534 | return; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 535 | } else { |
Chris Lattner | d3a94e2 | 2008-11-20 06:06:08 +0000 | [diff] [blame] | 536 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class) |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 537 | << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange(); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 538 | return; |
| 539 | } |
| 540 | |
| 541 | assert((DestPointer || DestReference) && |
| 542 | "Bad destination non-ptr/ref slipped through."); |
| 543 | assert((DestRecord || DestPointee->isVoidType()) && |
| 544 | "Bad destination pointee slipped through."); |
| 545 | assert(SrcRecord && "Bad source pointee slipped through."); |
| 546 | |
| 547 | // C++ 5.2.7p1: The dynamic_cast operator shall not cast away constness. |
| 548 | if (!DestPointee.isAtLeastAsQualifiedAs(SrcPointee)) { |
Douglas Gregor | d4c5f84 | 2011-04-15 17:59:54 +0000 | [diff] [blame] | 549 | Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_qualifiers_away) |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 550 | << CT_Dynamic << OrigSrcType << OrigDestType << OpRange; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 551 | return; |
| 552 | } |
| 553 | |
| 554 | // C++ 5.2.7p3: If the type of v is the same as the required result type, |
| 555 | // [except for cv]. |
| 556 | if (DestRecord == SrcRecord) { |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 557 | Kind = CK_NoOp; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 558 | return; |
| 559 | } |
| 560 | |
| 561 | // C++ 5.2.7p5 |
| 562 | // Upcasts are resolved statically. |
Sebastian Redl | 37d6de3 | 2008-11-08 13:00:26 +0000 | [diff] [blame] | 563 | if (DestRecord && Self.IsDerivedFrom(SrcPointee, DestPointee)) { |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 564 | if (Self.CheckDerivedToBaseConversion(SrcPointee, DestPointee, |
| 565 | OpRange.getBegin(), OpRange, |
| 566 | &BasePath)) |
| 567 | return; |
| 568 | |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 569 | Kind = CK_DerivedToBase; |
Douglas Gregor | 6fb745b | 2010-05-13 16:44:06 +0000 | [diff] [blame] | 570 | |
| 571 | // If we are casting to or through a virtual base class, we need a |
| 572 | // vtable. |
| 573 | if (Self.BasePathInvolvesVirtualBase(BasePath)) |
| 574 | Self.MarkVTableUsed(OpRange.getBegin(), |
| 575 | cast<CXXRecordDecl>(SrcRecord->getDecl())); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 576 | return; |
| 577 | } |
| 578 | |
| 579 | // C++ 5.2.7p6: Otherwise, v shall be [polymorphic]. |
Douglas Gregor | 952b017 | 2010-02-11 01:04:33 +0000 | [diff] [blame] | 580 | const RecordDecl *SrcDecl = SrcRecord->getDecl()->getDefinition(); |
Sebastian Redl | d93f0dd | 2008-11-06 15:59:35 +0000 | [diff] [blame] | 581 | assert(SrcDecl && "Definition missing"); |
| 582 | if (!cast<CXXRecordDecl>(SrcDecl)->isPolymorphic()) { |
Chris Lattner | d3a94e2 | 2008-11-20 06:06:08 +0000 | [diff] [blame] | 583 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_polymorphic) |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 584 | << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange(); |
Sebastian Redl | d93f0dd | 2008-11-06 15:59:35 +0000 | [diff] [blame] | 585 | } |
Douglas Gregor | 6fb745b | 2010-05-13 16:44:06 +0000 | [diff] [blame] | 586 | Self.MarkVTableUsed(OpRange.getBegin(), |
| 587 | cast<CXXRecordDecl>(SrcRecord->getDecl())); |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 588 | |
| 589 | // Done. Everything else is run-time checks. |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 590 | Kind = CK_Dynamic; |
Sebastian Redl | 26d85b1 | 2008-11-05 21:50:06 +0000 | [diff] [blame] | 591 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 592 | |
| 593 | /// CheckConstCast - Check that a const_cast\<DestType\>(SrcExpr) is valid. |
| 594 | /// Refer to C++ 5.2.11 for details. const_cast is typically used in code |
| 595 | /// like this: |
| 596 | /// const char *str = "literal"; |
| 597 | /// legacy_function(const_cast\<char*\>(str)); |
| 598 | void |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 599 | CheckConstCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, ExprValueKind &VK, |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 600 | const SourceRange &OpRange, const SourceRange &DestRange) { |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 601 | VK = Expr::getValueKindForType(DestType); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 602 | if (VK == VK_RValue) { |
| 603 | SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take()); |
| 604 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
| 605 | return; |
| 606 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 607 | |
| 608 | unsigned msg = diag::err_bad_cxx_cast_generic; |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 609 | if (TryConstCast(Self, SrcExpr.get(), DestType, /*CStyle*/false, msg) != TC_Success |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 610 | && msg != 0) |
| 611 | Self.Diag(OpRange.getBegin(), msg) << CT_Const |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 612 | << SrcExpr.get()->getType() << DestType << OpRange; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 613 | } |
| 614 | |
| 615 | /// CheckReinterpretCast - Check that a reinterpret_cast\<DestType\>(SrcExpr) is |
| 616 | /// valid. |
| 617 | /// Refer to C++ 5.2.10 for details. reinterpret_cast is typically used in code |
| 618 | /// like this: |
| 619 | /// char *bytes = reinterpret_cast\<char*\>(int_ptr); |
| 620 | void |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 621 | CheckReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 622 | ExprValueKind &VK, const SourceRange &OpRange, |
| 623 | const SourceRange &DestRange, CastKind &Kind) { |
| 624 | VK = Expr::getValueKindForType(DestType); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 625 | if (VK == VK_RValue) { |
| 626 | SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take()); |
| 627 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
| 628 | return; |
| 629 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 630 | |
| 631 | unsigned msg = diag::err_bad_cxx_cast_generic; |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 632 | TryCastResult tcr = |
| 633 | TryReinterpretCast(Self, SrcExpr, DestType, |
| 634 | /*CStyle*/false, OpRange, msg, Kind); |
| 635 | if (tcr != TC_Success && msg != 0) |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 636 | { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 637 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
| 638 | return; |
| 639 | if (SrcExpr.get()->getType() == Self.Context.OverloadTy) { |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 640 | //FIXME: &f<int>; is overloaded and resolvable |
| 641 | Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_overload) |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 642 | << OverloadExpr::find(SrcExpr.get()).Expression->getName() |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 643 | << DestType << OpRange; |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 644 | Self.NoteAllOverloadCandidates(SrcExpr.get()); |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 645 | |
John McCall | 79ab2c8 | 2011-02-14 18:34:10 +0000 | [diff] [blame] | 646 | } else { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 647 | diagnoseBadCast(Self, msg, CT_Reinterpret, OpRange, SrcExpr.get(), DestType); |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 648 | } |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 649 | } else if (tcr == TC_Success && Self.getLangOptions().ObjCAutoRefCount) { |
Fariborz Jahanian | af97517 | 2011-06-21 17:38:29 +0000 | [diff] [blame] | 650 | Expr *Exp = SrcExpr.get(); |
Fariborz Jahanian | 0626942 | 2011-06-21 18:21:32 +0000 | [diff] [blame] | 651 | // Note that Exp does not change with CCK_OtherCast cast type |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 652 | Self.CheckObjCARCConversion(OpRange, DestType, |
Fariborz Jahanian | af97517 | 2011-06-21 17:38:29 +0000 | [diff] [blame] | 653 | Exp, Sema::CCK_OtherCast); |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 654 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 655 | } |
| 656 | |
| 657 | |
| 658 | /// CheckStaticCast - Check that a static_cast\<DestType\>(SrcExpr) is valid. |
| 659 | /// Refer to C++ 5.2.9 for details. Static casts are mostly used for making |
| 660 | /// implicit conversions explicit and getting rid of data loss warnings. |
| 661 | void |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 662 | CheckStaticCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 663 | ExprValueKind &VK, const SourceRange &OpRange, |
| 664 | CastKind &Kind, CXXCastPath &BasePath) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 665 | // This test is outside everything else because it's the only case where |
| 666 | // a non-lvalue-reference target type does not lead to decay. |
| 667 | // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void". |
Eli Friedman | 05d9d7a | 2009-11-16 05:44:20 +0000 | [diff] [blame] | 668 | if (DestType->isVoidType()) { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 669 | SrcExpr = Self.IgnoredValueConversions(SrcExpr.take()); |
| 670 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
| 671 | return; |
| 672 | if (SrcExpr.get()->getType() == Self.Context.OverloadTy) { |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 673 | ExprResult SingleFunctionExpression = |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 674 | Self.ResolveAndFixSingleFunctionTemplateSpecialization(SrcExpr.get(), |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 675 | false, // Decay Function to ptr |
| 676 | true, // Complain |
| 677 | OpRange, DestType, diag::err_bad_static_cast_overload); |
| 678 | if (SingleFunctionExpression.isUsable()) |
| 679 | { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 680 | SrcExpr = SingleFunctionExpression; |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 681 | Kind = CK_ToVoid; |
| 682 | } |
| 683 | } |
| 684 | else |
| 685 | Kind = CK_ToVoid; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 686 | return; |
Eli Friedman | 05d9d7a | 2009-11-16 05:44:20 +0000 | [diff] [blame] | 687 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 688 | |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 689 | VK = Expr::getValueKindForType(DestType); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 690 | if (VK == VK_RValue && !DestType->isRecordType()) { |
| 691 | SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.take()); |
| 692 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
| 693 | return; |
| 694 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 695 | |
| 696 | unsigned msg = diag::err_bad_cxx_cast_generic; |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 697 | TryCastResult tcr |
| 698 | = TryStaticCast(Self, SrcExpr, DestType, Sema::CCK_OtherCast, OpRange, msg, |
| 699 | Kind, BasePath); |
| 700 | if (tcr != TC_Success && msg != 0) { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 701 | if (SrcExpr.isInvalid()) |
| 702 | return; |
| 703 | if (SrcExpr.get()->getType() == Self.Context.OverloadTy) { |
| 704 | OverloadExpr* oe = OverloadExpr::find(SrcExpr.get()).Expression; |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 705 | Self.Diag(OpRange.getBegin(), diag::err_bad_static_cast_overload) |
Douglas Gregor | 4c9be89 | 2011-02-28 20:01:57 +0000 | [diff] [blame] | 706 | << oe->getName() << DestType << OpRange |
| 707 | << oe->getQualifierLoc().getSourceRange(); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 708 | Self.NoteAllOverloadCandidates(SrcExpr.get()); |
John McCall | 79ab2c8 | 2011-02-14 18:34:10 +0000 | [diff] [blame] | 709 | } else { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 710 | diagnoseBadCast(Self, msg, CT_Static, OpRange, SrcExpr.get(), DestType); |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 711 | } |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 712 | } else if (tcr == TC_Success) { |
| 713 | if (Kind == CK_BitCast) |
| 714 | Self.CheckCastAlign(SrcExpr.get(), DestType, OpRange); |
Fariborz Jahanian | af97517 | 2011-06-21 17:38:29 +0000 | [diff] [blame] | 715 | if (Self.getLangOptions().ObjCAutoRefCount) { |
| 716 | Expr *Exp = SrcExpr.get(); |
Fariborz Jahanian | 0626942 | 2011-06-21 18:21:32 +0000 | [diff] [blame] | 717 | // Note that Exp does not change with CCK_OtherCast cast type |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 718 | Self.CheckObjCARCConversion(OpRange, DestType, |
Fariborz Jahanian | af97517 | 2011-06-21 17:38:29 +0000 | [diff] [blame] | 719 | Exp, Sema::CCK_OtherCast); |
| 720 | } |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 721 | } |
John McCall | e2b7688 | 2010-11-16 05:46:29 +0000 | [diff] [blame] | 722 | else if (Kind == CK_BitCast) |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 723 | Self.CheckCastAlign(SrcExpr.get(), DestType, OpRange); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 724 | } |
| 725 | |
| 726 | /// TryStaticCast - Check if a static cast can be performed, and do so if |
| 727 | /// possible. If @p CStyle, ignore access restrictions on hierarchy casting |
| 728 | /// and casting away constness. |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 729 | static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr, |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 730 | QualType DestType, |
| 731 | Sema::CheckedConversionKind CCK, |
Anders Carlsson | cb3c308 | 2009-09-01 20:52:42 +0000 | [diff] [blame] | 732 | const SourceRange &OpRange, unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 733 | CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 734 | CXXCastPath &BasePath) { |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 735 | // Determine whether we have the semantics of a C-style cast. |
| 736 | bool CStyle |
| 737 | = (CCK == Sema::CCK_CStyleCast || CCK == Sema::CCK_FunctionalCast); |
| 738 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 739 | // The order the tests is not entirely arbitrary. There is one conversion |
| 740 | // that can be handled in two different ways. Given: |
| 741 | // struct A {}; |
| 742 | // struct B : public A { |
| 743 | // B(); B(const A&); |
| 744 | // }; |
| 745 | // const A &a = B(); |
| 746 | // the cast static_cast<const B&>(a) could be seen as either a static |
| 747 | // reference downcast, or an explicit invocation of the user-defined |
| 748 | // conversion using B's conversion constructor. |
| 749 | // DR 427 specifies that the downcast is to be applied here. |
| 750 | |
| 751 | // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void". |
| 752 | // Done outside this function. |
| 753 | |
| 754 | TryCastResult tcr; |
| 755 | |
| 756 | // C++ 5.2.9p5, reference downcast. |
| 757 | // See the function for details. |
| 758 | // DR 427 specifies that this is to be applied before paragraph 2. |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 759 | tcr = TryStaticReferenceDowncast(Self, SrcExpr.get(), DestType, CStyle, OpRange, |
Anders Carlsson | f9d68e1 | 2010-04-24 19:36:51 +0000 | [diff] [blame] | 760 | msg, Kind, BasePath); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 761 | if (tcr != TC_NotApplicable) |
| 762 | return tcr; |
| 763 | |
Douglas Gregor | dc843f2 | 2011-01-22 00:06:57 +0000 | [diff] [blame] | 764 | // C++0x [expr.static.cast]p3: |
| 765 | // A glvalue of type "cv1 T1" can be cast to type "rvalue reference to cv2 |
| 766 | // T2" if "cv2 T2" is reference-compatible with "cv1 T1". |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 767 | tcr = TryLValueToRValueCast(Self, SrcExpr.get(), DestType, CStyle, Kind, BasePath, |
Douglas Gregor | 8ec14e6 | 2011-01-26 21:04:06 +0000 | [diff] [blame] | 768 | msg); |
Douglas Gregor | 88b22a4 | 2011-01-25 16:13:26 +0000 | [diff] [blame] | 769 | if (tcr != TC_NotApplicable) |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 770 | return tcr; |
| 771 | |
| 772 | // C++ 5.2.9p2: An expression e can be explicitly converted to a type T |
| 773 | // [...] if the declaration "T t(e);" is well-formed, [...]. |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 774 | tcr = TryStaticImplicitCast(Self, SrcExpr, DestType, CCK, OpRange, msg, |
Douglas Gregor | d6e44a3 | 2010-04-16 22:09:46 +0000 | [diff] [blame] | 775 | Kind); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 776 | if (SrcExpr.isInvalid()) |
| 777 | return TC_Failed; |
Anders Carlsson | 3c31a39 | 2009-09-26 00:12:34 +0000 | [diff] [blame] | 778 | if (tcr != TC_NotApplicable) |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 779 | return tcr; |
Anders Carlsson | 0aebc81 | 2009-09-09 21:33:21 +0000 | [diff] [blame] | 780 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 781 | // C++ 5.2.9p6: May apply the reverse of any standard conversion, except |
| 782 | // lvalue-to-rvalue, array-to-pointer, function-to-pointer, and boolean |
| 783 | // conversions, subject to further restrictions. |
| 784 | // Also, C++ 5.2.9p1 forbids casting away constness, which makes reversal |
| 785 | // of qualification conversions impossible. |
| 786 | // In the CStyle case, the earlier attempt to const_cast should have taken |
| 787 | // care of reverse qualification conversions. |
| 788 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 789 | QualType SrcType = Self.Context.getCanonicalType(SrcExpr.get()->getType()); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 790 | |
Douglas Gregor | 1274ccd | 2010-10-08 23:50:27 +0000 | [diff] [blame] | 791 | // C++0x 5.2.9p9: A value of a scoped enumeration type can be explicitly |
Douglas Gregor | 1e856d9 | 2011-02-18 03:01:41 +0000 | [diff] [blame] | 792 | // converted to an integral type. [...] A value of a scoped enumeration type |
| 793 | // can also be explicitly converted to a floating-point type [...]. |
| 794 | if (const EnumType *Enum = SrcType->getAs<EnumType>()) { |
| 795 | if (Enum->getDecl()->isScoped()) { |
| 796 | if (DestType->isBooleanType()) { |
| 797 | Kind = CK_IntegralToBoolean; |
| 798 | return TC_Success; |
| 799 | } else if (DestType->isIntegralType(Self.Context)) { |
| 800 | Kind = CK_IntegralCast; |
| 801 | return TC_Success; |
| 802 | } else if (DestType->isRealFloatingType()) { |
| 803 | Kind = CK_IntegralToFloating; |
| 804 | return TC_Success; |
| 805 | } |
Douglas Gregor | 1274ccd | 2010-10-08 23:50:27 +0000 | [diff] [blame] | 806 | } |
| 807 | } |
Douglas Gregor | 1e856d9 | 2011-02-18 03:01:41 +0000 | [diff] [blame] | 808 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 809 | // Reverse integral promotion/conversion. All such conversions are themselves |
| 810 | // again integral promotions or conversions and are thus already handled by |
| 811 | // p2 (TryDirectInitialization above). |
| 812 | // (Note: any data loss warnings should be suppressed.) |
| 813 | // The exception is the reverse of enum->integer, i.e. integer->enum (and |
| 814 | // enum->enum). See also C++ 5.2.9p7. |
| 815 | // The same goes for reverse floating point promotion/conversion and |
| 816 | // floating-integral conversions. Again, only floating->enum is relevant. |
| 817 | if (DestType->isEnumeralType()) { |
| 818 | if (SrcType->isComplexType() || SrcType->isVectorType()) { |
| 819 | // Fall through - these cannot be converted. |
Eli Friedman | 05d9d7a | 2009-11-16 05:44:20 +0000 | [diff] [blame] | 820 | } else if (SrcType->isArithmeticType() || SrcType->isEnumeralType()) { |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 821 | Kind = CK_IntegralCast; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 822 | return TC_Success; |
Eli Friedman | 05d9d7a | 2009-11-16 05:44:20 +0000 | [diff] [blame] | 823 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 824 | } |
| 825 | |
| 826 | // Reverse pointer upcast. C++ 4.10p3 specifies pointer upcast. |
| 827 | // C++ 5.2.9p8 additionally disallows a cast path through virtual inheritance. |
Anders Carlsson | 95c5d8a | 2009-11-12 16:53:16 +0000 | [diff] [blame] | 828 | tcr = TryStaticPointerDowncast(Self, SrcType, DestType, CStyle, OpRange, msg, |
Anders Carlsson | f9d68e1 | 2010-04-24 19:36:51 +0000 | [diff] [blame] | 829 | Kind, BasePath); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 830 | if (tcr != TC_NotApplicable) |
| 831 | return tcr; |
| 832 | |
| 833 | // Reverse member pointer conversion. C++ 4.11 specifies member pointer |
| 834 | // conversion. C++ 5.2.9p9 has additional information. |
| 835 | // DR54's access restrictions apply here also. |
Douglas Gregor | 4ce46c2 | 2010-03-07 23:24:59 +0000 | [diff] [blame] | 836 | tcr = TryStaticMemberPointerUpcast(Self, SrcExpr, SrcType, DestType, CStyle, |
Anders Carlsson | cee2242 | 2010-04-24 19:22:20 +0000 | [diff] [blame] | 837 | OpRange, msg, Kind, BasePath); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 838 | if (tcr != TC_NotApplicable) |
| 839 | return tcr; |
| 840 | |
| 841 | // Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to |
| 842 | // void*. C++ 5.2.9p10 specifies additional restrictions, which really is |
| 843 | // just the usual constness stuff. |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 844 | if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 845 | QualType SrcPointee = SrcPointer->getPointeeType(); |
| 846 | if (SrcPointee->isVoidType()) { |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 847 | if (const PointerType *DestPointer = DestType->getAs<PointerType>()) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 848 | QualType DestPointee = DestPointer->getPointeeType(); |
| 849 | if (DestPointee->isIncompleteOrObjectType()) { |
| 850 | // This is definitely the intended conversion, but it might fail due |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 851 | // to a qualifier violation. Note that we permit Objective-C lifetime |
| 852 | // and GC qualifier mismatches here. |
| 853 | if (!CStyle) { |
| 854 | Qualifiers DestPointeeQuals = DestPointee.getQualifiers(); |
| 855 | Qualifiers SrcPointeeQuals = SrcPointee.getQualifiers(); |
| 856 | DestPointeeQuals.removeObjCGCAttr(); |
| 857 | DestPointeeQuals.removeObjCLifetime(); |
| 858 | SrcPointeeQuals.removeObjCGCAttr(); |
| 859 | SrcPointeeQuals.removeObjCLifetime(); |
| 860 | if (DestPointeeQuals != SrcPointeeQuals && |
| 861 | !DestPointeeQuals.compatiblyIncludes(SrcPointeeQuals)) { |
| 862 | msg = diag::err_bad_cxx_cast_qualifiers_away; |
| 863 | return TC_Failed; |
| 864 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 865 | } |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 866 | Kind = CK_BitCast; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 867 | return TC_Success; |
| 868 | } |
| 869 | } |
Fariborz Jahanian | 2f6c550 | 2010-05-10 23:46:53 +0000 | [diff] [blame] | 870 | else if (DestType->isObjCObjectPointerType()) { |
| 871 | // allow both c-style cast and static_cast of objective-c pointers as |
| 872 | // they are pervasive. |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 873 | Kind = CK_AnyPointerToObjCPointerCast; |
Fariborz Jahanian | 92ef5d7 | 2009-12-08 23:09:15 +0000 | [diff] [blame] | 874 | return TC_Success; |
| 875 | } |
Fariborz Jahanian | 3b27f1a | 2009-12-11 22:40:48 +0000 | [diff] [blame] | 876 | else if (CStyle && DestType->isBlockPointerType()) { |
| 877 | // allow c-style cast of void * to block pointers. |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 878 | Kind = CK_AnyPointerToBlockPointerCast; |
Fariborz Jahanian | 3b27f1a | 2009-12-11 22:40:48 +0000 | [diff] [blame] | 879 | return TC_Success; |
| 880 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 881 | } |
| 882 | } |
Fariborz Jahanian | 65267b2 | 2010-05-12 18:16:59 +0000 | [diff] [blame] | 883 | // Allow arbitray objective-c pointer conversion with static casts. |
| 884 | if (SrcType->isObjCObjectPointerType() && |
John McCall | daa8e4e | 2010-11-15 09:13:47 +0000 | [diff] [blame] | 885 | DestType->isObjCObjectPointerType()) { |
| 886 | Kind = CK_BitCast; |
Fariborz Jahanian | 65267b2 | 2010-05-12 18:16:59 +0000 | [diff] [blame] | 887 | return TC_Success; |
John McCall | daa8e4e | 2010-11-15 09:13:47 +0000 | [diff] [blame] | 888 | } |
Fariborz Jahanian | 65267b2 | 2010-05-12 18:16:59 +0000 | [diff] [blame] | 889 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 890 | // We tried everything. Everything! Nothing works! :-( |
| 891 | return TC_NotApplicable; |
| 892 | } |
| 893 | |
| 894 | /// Tests whether a conversion according to N2844 is valid. |
| 895 | TryCastResult |
| 896 | TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, QualType DestType, |
Douglas Gregor | 8ec14e6 | 2011-01-26 21:04:06 +0000 | [diff] [blame] | 897 | bool CStyle, CastKind &Kind, CXXCastPath &BasePath, |
| 898 | unsigned &msg) { |
Douglas Gregor | dc843f2 | 2011-01-22 00:06:57 +0000 | [diff] [blame] | 899 | // C++0x [expr.static.cast]p3: |
| 900 | // A glvalue of type "cv1 T1" can be cast to type "rvalue reference to |
| 901 | // cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1". |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 902 | const RValueReferenceType *R = DestType->getAs<RValueReferenceType>(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 903 | if (!R) |
| 904 | return TC_NotApplicable; |
| 905 | |
Douglas Gregor | dc843f2 | 2011-01-22 00:06:57 +0000 | [diff] [blame] | 906 | if (!SrcExpr->isGLValue()) |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 907 | return TC_NotApplicable; |
| 908 | |
| 909 | // Because we try the reference downcast before this function, from now on |
| 910 | // this is the only cast possibility, so we issue an error if we fail now. |
| 911 | // FIXME: Should allow casting away constness if CStyle. |
| 912 | bool DerivedToBase; |
Douglas Gregor | 569c316 | 2010-08-07 11:51:51 +0000 | [diff] [blame] | 913 | bool ObjCConversion; |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 914 | bool ObjCLifetimeConversion; |
Douglas Gregor | 8ec14e6 | 2011-01-26 21:04:06 +0000 | [diff] [blame] | 915 | QualType FromType = SrcExpr->getType(); |
| 916 | QualType ToType = R->getPointeeType(); |
| 917 | if (CStyle) { |
| 918 | FromType = FromType.getUnqualifiedType(); |
| 919 | ToType = ToType.getUnqualifiedType(); |
| 920 | } |
| 921 | |
Douglas Gregor | 393896f | 2009-11-05 13:06:35 +0000 | [diff] [blame] | 922 | if (Self.CompareReferenceRelationship(SrcExpr->getLocStart(), |
Douglas Gregor | 8ec14e6 | 2011-01-26 21:04:06 +0000 | [diff] [blame] | 923 | ToType, FromType, |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 924 | DerivedToBase, ObjCConversion, |
| 925 | ObjCLifetimeConversion) |
| 926 | < Sema::Ref_Compatible_With_Added_Qualification) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 927 | msg = diag::err_bad_lvalue_to_rvalue_cast; |
| 928 | return TC_Failed; |
| 929 | } |
| 930 | |
Douglas Gregor | 88b22a4 | 2011-01-25 16:13:26 +0000 | [diff] [blame] | 931 | if (DerivedToBase) { |
| 932 | Kind = CK_DerivedToBase; |
| 933 | CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, |
| 934 | /*DetectVirtual=*/true); |
| 935 | if (!Self.IsDerivedFrom(SrcExpr->getType(), R->getPointeeType(), Paths)) |
| 936 | return TC_NotApplicable; |
| 937 | |
| 938 | Self.BuildBasePathArray(Paths, BasePath); |
| 939 | } else |
| 940 | Kind = CK_NoOp; |
| 941 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 942 | return TC_Success; |
| 943 | } |
| 944 | |
| 945 | /// Tests whether a conversion according to C++ 5.2.9p5 is valid. |
| 946 | TryCastResult |
| 947 | TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType, |
| 948 | bool CStyle, const SourceRange &OpRange, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 949 | unsigned &msg, CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 950 | CXXCastPath &BasePath) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 951 | // C++ 5.2.9p5: An lvalue of type "cv1 B", where B is a class type, can be |
| 952 | // cast to type "reference to cv2 D", where D is a class derived from B, |
| 953 | // if a valid standard conversion from "pointer to D" to "pointer to B" |
| 954 | // exists, cv2 >= cv1, and B is not a virtual base class of D. |
| 955 | // In addition, DR54 clarifies that the base must be accessible in the |
| 956 | // current context. Although the wording of DR54 only applies to the pointer |
| 957 | // variant of this rule, the intent is clearly for it to apply to the this |
| 958 | // conversion as well. |
| 959 | |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 960 | const ReferenceType *DestReference = DestType->getAs<ReferenceType>(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 961 | if (!DestReference) { |
| 962 | return TC_NotApplicable; |
| 963 | } |
| 964 | bool RValueRef = DestReference->isRValueReferenceType(); |
John McCall | 7eb0a9e | 2010-11-24 05:12:34 +0000 | [diff] [blame] | 965 | if (!RValueRef && !SrcExpr->isLValue()) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 966 | // We know the left side is an lvalue reference, so we can suggest a reason. |
| 967 | msg = diag::err_bad_cxx_cast_rvalue; |
| 968 | return TC_NotApplicable; |
| 969 | } |
| 970 | |
| 971 | QualType DestPointee = DestReference->getPointeeType(); |
| 972 | |
Douglas Gregor | ab15d0e | 2009-11-15 09:20:52 +0000 | [diff] [blame] | 973 | return TryStaticDowncast(Self, |
| 974 | Self.Context.getCanonicalType(SrcExpr->getType()), |
| 975 | Self.Context.getCanonicalType(DestPointee), CStyle, |
Anders Carlsson | f9d68e1 | 2010-04-24 19:36:51 +0000 | [diff] [blame] | 976 | OpRange, SrcExpr->getType(), DestType, msg, Kind, |
| 977 | BasePath); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 978 | } |
| 979 | |
| 980 | /// Tests whether a conversion according to C++ 5.2.9p8 is valid. |
| 981 | TryCastResult |
| 982 | TryStaticPointerDowncast(Sema &Self, QualType SrcType, QualType DestType, |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 983 | bool CStyle, const SourceRange &OpRange, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 984 | unsigned &msg, CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 985 | CXXCastPath &BasePath) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 986 | // C++ 5.2.9p8: An rvalue of type "pointer to cv1 B", where B is a class |
| 987 | // type, can be converted to an rvalue of type "pointer to cv2 D", where D |
| 988 | // is a class derived from B, if a valid standard conversion from "pointer |
| 989 | // to D" to "pointer to B" exists, cv2 >= cv1, and B is not a virtual base |
| 990 | // class of D. |
| 991 | // In addition, DR54 clarifies that the base must be accessible in the |
| 992 | // current context. |
| 993 | |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 994 | const PointerType *DestPointer = DestType->getAs<PointerType>(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 995 | if (!DestPointer) { |
| 996 | return TC_NotApplicable; |
| 997 | } |
| 998 | |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 999 | const PointerType *SrcPointer = SrcType->getAs<PointerType>(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1000 | if (!SrcPointer) { |
| 1001 | msg = diag::err_bad_static_cast_pointer_nonpointer; |
| 1002 | return TC_NotApplicable; |
| 1003 | } |
| 1004 | |
Douglas Gregor | ab15d0e | 2009-11-15 09:20:52 +0000 | [diff] [blame] | 1005 | return TryStaticDowncast(Self, |
| 1006 | Self.Context.getCanonicalType(SrcPointer->getPointeeType()), |
| 1007 | Self.Context.getCanonicalType(DestPointer->getPointeeType()), |
Anders Carlsson | f9d68e1 | 2010-04-24 19:36:51 +0000 | [diff] [blame] | 1008 | CStyle, OpRange, SrcType, DestType, msg, Kind, |
| 1009 | BasePath); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1010 | } |
| 1011 | |
| 1012 | /// TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and |
| 1013 | /// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to |
Douglas Gregor | ab15d0e | 2009-11-15 09:20:52 +0000 | [diff] [blame] | 1014 | /// DestType is possible and allowed. |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1015 | TryCastResult |
Douglas Gregor | ab15d0e | 2009-11-15 09:20:52 +0000 | [diff] [blame] | 1016 | TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType, |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1017 | bool CStyle, const SourceRange &OpRange, QualType OrigSrcType, |
Anders Carlsson | 95c5d8a | 2009-11-12 16:53:16 +0000 | [diff] [blame] | 1018 | QualType OrigDestType, unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1019 | CastKind &Kind, CXXCastPath &BasePath) { |
Sebastian Redl | 5ed66f7 | 2009-10-22 15:07:22 +0000 | [diff] [blame] | 1020 | // We can only work with complete types. But don't complain if it doesn't work |
Douglas Gregor | fe6b2d4 | 2010-03-29 23:34:08 +0000 | [diff] [blame] | 1021 | if (Self.RequireCompleteType(OpRange.getBegin(), SrcType, Self.PDiag(0)) || |
| 1022 | Self.RequireCompleteType(OpRange.getBegin(), DestType, Self.PDiag(0))) |
Sebastian Redl | 5ed66f7 | 2009-10-22 15:07:22 +0000 | [diff] [blame] | 1023 | return TC_NotApplicable; |
| 1024 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1025 | // Downcast can only happen in class hierarchies, so we need classes. |
Douglas Gregor | ab15d0e | 2009-11-15 09:20:52 +0000 | [diff] [blame] | 1026 | if (!DestType->getAs<RecordType>() || !SrcType->getAs<RecordType>()) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1027 | return TC_NotApplicable; |
| 1028 | } |
| 1029 | |
Anders Carlsson | f9d68e1 | 2010-04-24 19:36:51 +0000 | [diff] [blame] | 1030 | CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, |
Douglas Gregor | a8f32e0 | 2009-10-06 17:59:45 +0000 | [diff] [blame] | 1031 | /*DetectVirtual=*/true); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1032 | if (!Self.IsDerivedFrom(DestType, SrcType, Paths)) { |
| 1033 | return TC_NotApplicable; |
| 1034 | } |
| 1035 | |
| 1036 | // Target type does derive from source type. Now we're serious. If an error |
| 1037 | // appears now, it's not ignored. |
| 1038 | // This may not be entirely in line with the standard. Take for example: |
| 1039 | // struct A {}; |
| 1040 | // struct B : virtual A { |
| 1041 | // B(A&); |
| 1042 | // }; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1043 | // |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1044 | // void f() |
| 1045 | // { |
| 1046 | // (void)static_cast<const B&>(*((A*)0)); |
| 1047 | // } |
| 1048 | // As far as the standard is concerned, p5 does not apply (A is virtual), so |
| 1049 | // p2 should be used instead - "const B& t(*((A*)0));" is perfectly valid. |
| 1050 | // However, both GCC and Comeau reject this example, and accepting it would |
| 1051 | // mean more complex code if we're to preserve the nice error message. |
| 1052 | // FIXME: Being 100% compliant here would be nice to have. |
| 1053 | |
| 1054 | // Must preserve cv, as always, unless we're in C-style mode. |
| 1055 | if (!CStyle && !DestType.isAtLeastAsQualifiedAs(SrcType)) { |
Douglas Gregor | d4c5f84 | 2011-04-15 17:59:54 +0000 | [diff] [blame] | 1056 | msg = diag::err_bad_cxx_cast_qualifiers_away; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1057 | return TC_Failed; |
| 1058 | } |
| 1059 | |
| 1060 | if (Paths.isAmbiguous(SrcType.getUnqualifiedType())) { |
| 1061 | // This code is analoguous to that in CheckDerivedToBaseConversion, except |
| 1062 | // that it builds the paths in reverse order. |
| 1063 | // To sum up: record all paths to the base and build a nice string from |
| 1064 | // them. Use it to spice up the error message. |
| 1065 | if (!Paths.isRecordingPaths()) { |
| 1066 | Paths.clear(); |
| 1067 | Paths.setRecordingPaths(true); |
| 1068 | Self.IsDerivedFrom(DestType, SrcType, Paths); |
| 1069 | } |
| 1070 | std::string PathDisplayStr; |
| 1071 | std::set<unsigned> DisplayedPaths; |
Douglas Gregor | a8f32e0 | 2009-10-06 17:59:45 +0000 | [diff] [blame] | 1072 | for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1073 | PI != PE; ++PI) { |
| 1074 | if (DisplayedPaths.insert(PI->back().SubobjectNumber).second) { |
| 1075 | // We haven't displayed a path to this particular base |
| 1076 | // class subobject yet. |
| 1077 | PathDisplayStr += "\n "; |
Douglas Gregor | a8f32e0 | 2009-10-06 17:59:45 +0000 | [diff] [blame] | 1078 | for (CXXBasePath::const_reverse_iterator EI = PI->rbegin(), |
| 1079 | EE = PI->rend(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1080 | EI != EE; ++EI) |
| 1081 | PathDisplayStr += EI->Base->getType().getAsString() + " -> "; |
Douglas Gregor | ab15d0e | 2009-11-15 09:20:52 +0000 | [diff] [blame] | 1082 | PathDisplayStr += QualType(DestType).getAsString(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1083 | } |
| 1084 | } |
| 1085 | |
| 1086 | Self.Diag(OpRange.getBegin(), diag::err_ambiguous_base_to_derived_cast) |
Douglas Gregor | ab15d0e | 2009-11-15 09:20:52 +0000 | [diff] [blame] | 1087 | << QualType(SrcType).getUnqualifiedType() |
| 1088 | << QualType(DestType).getUnqualifiedType() |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1089 | << PathDisplayStr << OpRange; |
| 1090 | msg = 0; |
| 1091 | return TC_Failed; |
| 1092 | } |
| 1093 | |
| 1094 | if (Paths.getDetectedVirtual() != 0) { |
| 1095 | QualType VirtualBase(Paths.getDetectedVirtual(), 0); |
| 1096 | Self.Diag(OpRange.getBegin(), diag::err_static_downcast_via_virtual) |
| 1097 | << OrigSrcType << OrigDestType << VirtualBase << OpRange; |
| 1098 | msg = 0; |
| 1099 | return TC_Failed; |
| 1100 | } |
| 1101 | |
John McCall | 417d39f | 2011-02-14 23:21:33 +0000 | [diff] [blame] | 1102 | if (!CStyle) { |
| 1103 | switch (Self.CheckBaseClassAccess(OpRange.getBegin(), |
| 1104 | SrcType, DestType, |
| 1105 | Paths.front(), |
John McCall | 58e6f34 | 2010-03-16 05:22:47 +0000 | [diff] [blame] | 1106 | diag::err_downcast_from_inaccessible_base)) { |
John McCall | 417d39f | 2011-02-14 23:21:33 +0000 | [diff] [blame] | 1107 | case Sema::AR_accessible: |
| 1108 | case Sema::AR_delayed: // be optimistic |
| 1109 | case Sema::AR_dependent: // be optimistic |
| 1110 | break; |
| 1111 | |
| 1112 | case Sema::AR_inaccessible: |
| 1113 | msg = 0; |
| 1114 | return TC_Failed; |
| 1115 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1116 | } |
| 1117 | |
Anders Carlsson | f9d68e1 | 2010-04-24 19:36:51 +0000 | [diff] [blame] | 1118 | Self.BuildBasePathArray(Paths, BasePath); |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1119 | Kind = CK_BaseToDerived; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1120 | return TC_Success; |
| 1121 | } |
| 1122 | |
| 1123 | /// TryStaticMemberPointerUpcast - Tests whether a conversion according to |
| 1124 | /// C++ 5.2.9p9 is valid: |
| 1125 | /// |
| 1126 | /// An rvalue of type "pointer to member of D of type cv1 T" can be |
| 1127 | /// converted to an rvalue of type "pointer to member of B of type cv2 T", |
| 1128 | /// where B is a base class of D [...]. |
| 1129 | /// |
| 1130 | TryCastResult |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1131 | TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType, |
Douglas Gregor | 4ce46c2 | 2010-03-07 23:24:59 +0000 | [diff] [blame] | 1132 | QualType DestType, bool CStyle, |
| 1133 | const SourceRange &OpRange, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1134 | unsigned &msg, CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 1135 | CXXCastPath &BasePath) { |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 1136 | const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1137 | if (!DestMemPtr) |
| 1138 | return TC_NotApplicable; |
Douglas Gregor | 4ce46c2 | 2010-03-07 23:24:59 +0000 | [diff] [blame] | 1139 | |
| 1140 | bool WasOverloadedFunction = false; |
John McCall | 6bb8017 | 2010-03-30 21:47:33 +0000 | [diff] [blame] | 1141 | DeclAccessPair FoundOverload; |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1142 | if (SrcExpr.get()->getType() == Self.Context.OverloadTy) { |
Douglas Gregor | 1a8cf73 | 2010-04-14 23:11:21 +0000 | [diff] [blame] | 1143 | if (FunctionDecl *Fn |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1144 | = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(), DestType, false, |
Douglas Gregor | 1a8cf73 | 2010-04-14 23:11:21 +0000 | [diff] [blame] | 1145 | FoundOverload)) { |
| 1146 | CXXMethodDecl *M = cast<CXXMethodDecl>(Fn); |
| 1147 | SrcType = Self.Context.getMemberPointerType(Fn->getType(), |
| 1148 | Self.Context.getTypeDeclType(M->getParent()).getTypePtr()); |
| 1149 | WasOverloadedFunction = true; |
| 1150 | } |
Douglas Gregor | 4ce46c2 | 2010-03-07 23:24:59 +0000 | [diff] [blame] | 1151 | } |
Douglas Gregor | 1a8cf73 | 2010-04-14 23:11:21 +0000 | [diff] [blame] | 1152 | |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 1153 | const MemberPointerType *SrcMemPtr = SrcType->getAs<MemberPointerType>(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1154 | if (!SrcMemPtr) { |
| 1155 | msg = diag::err_bad_static_cast_member_pointer_nonmp; |
| 1156 | return TC_NotApplicable; |
| 1157 | } |
| 1158 | |
| 1159 | // T == T, modulo cv |
Douglas Gregor | a4923eb | 2009-11-16 21:35:15 +0000 | [diff] [blame] | 1160 | if (!Self.Context.hasSameUnqualifiedType(SrcMemPtr->getPointeeType(), |
| 1161 | DestMemPtr->getPointeeType())) |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1162 | return TC_NotApplicable; |
| 1163 | |
| 1164 | // B base of D |
| 1165 | QualType SrcClass(SrcMemPtr->getClass(), 0); |
| 1166 | QualType DestClass(DestMemPtr->getClass(), 0); |
Anders Carlsson | cee2242 | 2010-04-24 19:22:20 +0000 | [diff] [blame] | 1167 | CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1168 | /*DetectVirtual=*/true); |
| 1169 | if (!Self.IsDerivedFrom(SrcClass, DestClass, Paths)) { |
| 1170 | return TC_NotApplicable; |
| 1171 | } |
| 1172 | |
| 1173 | // B is a base of D. But is it an allowed base? If not, it's a hard error. |
Douglas Gregor | e0d5fe2 | 2010-05-21 20:29:55 +0000 | [diff] [blame] | 1174 | if (Paths.isAmbiguous(Self.Context.getCanonicalType(DestClass))) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1175 | Paths.clear(); |
| 1176 | Paths.setRecordingPaths(true); |
| 1177 | bool StillOkay = Self.IsDerivedFrom(SrcClass, DestClass, Paths); |
| 1178 | assert(StillOkay); |
Jeffrey Yasskin | c6ed729 | 2010-12-23 01:01:28 +0000 | [diff] [blame] | 1179 | (void)StillOkay; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1180 | std::string PathDisplayStr = Self.getAmbiguousPathsDisplayString(Paths); |
| 1181 | Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv) |
| 1182 | << 1 << SrcClass << DestClass << PathDisplayStr << OpRange; |
| 1183 | msg = 0; |
| 1184 | return TC_Failed; |
| 1185 | } |
| 1186 | |
| 1187 | if (const RecordType *VBase = Paths.getDetectedVirtual()) { |
| 1188 | Self.Diag(OpRange.getBegin(), diag::err_memptr_conv_via_virtual) |
| 1189 | << SrcClass << DestClass << QualType(VBase, 0) << OpRange; |
| 1190 | msg = 0; |
| 1191 | return TC_Failed; |
| 1192 | } |
| 1193 | |
John McCall | 417d39f | 2011-02-14 23:21:33 +0000 | [diff] [blame] | 1194 | if (!CStyle) { |
| 1195 | switch (Self.CheckBaseClassAccess(OpRange.getBegin(), |
| 1196 | DestClass, SrcClass, |
| 1197 | Paths.front(), |
| 1198 | diag::err_upcast_to_inaccessible_base)) { |
| 1199 | case Sema::AR_accessible: |
| 1200 | case Sema::AR_delayed: |
| 1201 | case Sema::AR_dependent: |
| 1202 | // Optimistically assume that the delayed and dependent cases |
| 1203 | // will work out. |
| 1204 | break; |
| 1205 | |
| 1206 | case Sema::AR_inaccessible: |
| 1207 | msg = 0; |
| 1208 | return TC_Failed; |
| 1209 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1210 | } |
| 1211 | |
Douglas Gregor | 4ce46c2 | 2010-03-07 23:24:59 +0000 | [diff] [blame] | 1212 | if (WasOverloadedFunction) { |
| 1213 | // Resolve the address of the overloaded function again, this time |
| 1214 | // allowing complaints if something goes wrong. |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1215 | FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(), |
Douglas Gregor | 4ce46c2 | 2010-03-07 23:24:59 +0000 | [diff] [blame] | 1216 | DestType, |
John McCall | 6bb8017 | 2010-03-30 21:47:33 +0000 | [diff] [blame] | 1217 | true, |
| 1218 | FoundOverload); |
Douglas Gregor | 4ce46c2 | 2010-03-07 23:24:59 +0000 | [diff] [blame] | 1219 | if (!Fn) { |
| 1220 | msg = 0; |
| 1221 | return TC_Failed; |
| 1222 | } |
| 1223 | |
John McCall | 6bb8017 | 2010-03-30 21:47:33 +0000 | [diff] [blame] | 1224 | SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr, FoundOverload, Fn); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1225 | if (!SrcExpr.isUsable()) { |
Douglas Gregor | 4ce46c2 | 2010-03-07 23:24:59 +0000 | [diff] [blame] | 1226 | msg = 0; |
| 1227 | return TC_Failed; |
| 1228 | } |
| 1229 | } |
| 1230 | |
Anders Carlsson | cee2242 | 2010-04-24 19:22:20 +0000 | [diff] [blame] | 1231 | Self.BuildBasePathArray(Paths, BasePath); |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1232 | Kind = CK_DerivedToBaseMemberPointer; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1233 | return TC_Success; |
| 1234 | } |
| 1235 | |
| 1236 | /// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2 |
| 1237 | /// is valid: |
| 1238 | /// |
| 1239 | /// An expression e can be explicitly converted to a type T using a |
| 1240 | /// @c static_cast if the declaration "T t(e);" is well-formed [...]. |
| 1241 | TryCastResult |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1242 | TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 1243 | Sema::CheckedConversionKind CCK, |
| 1244 | const SourceRange &OpRange, unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1245 | CastKind &Kind) { |
Anders Carlsson | d851b37 | 2009-09-07 18:25:47 +0000 | [diff] [blame] | 1246 | if (DestType->isRecordType()) { |
| 1247 | if (Self.RequireCompleteType(OpRange.getBegin(), DestType, |
| 1248 | diag::err_bad_dynamic_cast_incomplete)) { |
| 1249 | msg = 0; |
| 1250 | return TC_Failed; |
| 1251 | } |
| 1252 | } |
Douglas Gregor | d6e44a3 | 2010-04-16 22:09:46 +0000 | [diff] [blame] | 1253 | |
Douglas Gregor | f0e43e5 | 2010-04-16 19:30:02 +0000 | [diff] [blame] | 1254 | InitializedEntity Entity = InitializedEntity::InitializeTemporary(DestType); |
| 1255 | InitializationKind InitKind |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 1256 | = (CCK == Sema::CCK_CStyleCast) |
| 1257 | ? InitializationKind::CreateCStyleCast(OpRange.getBegin(), OpRange) |
| 1258 | : (CCK == Sema::CCK_FunctionalCast) |
| 1259 | ? InitializationKind::CreateFunctionalCast(OpRange) |
| 1260 | : InitializationKind::CreateCast(OpRange); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1261 | Expr *SrcExprRaw = SrcExpr.get(); |
| 1262 | InitializationSequence InitSeq(Self, Entity, InitKind, &SrcExprRaw, 1); |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 1263 | |
| 1264 | // At this point of CheckStaticCast, if the destination is a reference, |
| 1265 | // or the expression is an overload expression this has to work. |
| 1266 | // There is no other way that works. |
| 1267 | // On the other hand, if we're checking a C-style cast, we've still got |
| 1268 | // the reinterpret_cast way. |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 1269 | bool CStyle |
| 1270 | = (CCK == Sema::CCK_CStyleCast || CCK == Sema::CCK_FunctionalCast); |
Sebastian Redl | 383616c | 2011-06-05 12:23:28 +0000 | [diff] [blame] | 1271 | if (InitSeq.Failed() && (CStyle || !DestType->isReferenceType())) |
Anders Carlsson | 3c31a39 | 2009-09-26 00:12:34 +0000 | [diff] [blame] | 1272 | return TC_NotApplicable; |
Douglas Gregor | d6e44a3 | 2010-04-16 22:09:46 +0000 | [diff] [blame] | 1273 | |
John McCall | 60d7b3a | 2010-08-24 06:29:42 +0000 | [diff] [blame] | 1274 | ExprResult Result |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1275 | = InitSeq.Perform(Self, Entity, InitKind, MultiExprArg(Self, &SrcExprRaw, 1)); |
Douglas Gregor | f0e43e5 | 2010-04-16 19:30:02 +0000 | [diff] [blame] | 1276 | if (Result.isInvalid()) { |
| 1277 | msg = 0; |
| 1278 | return TC_Failed; |
| 1279 | } |
| 1280 | |
Douglas Gregor | d6e44a3 | 2010-04-16 22:09:46 +0000 | [diff] [blame] | 1281 | if (InitSeq.isConstructorInitialization()) |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1282 | Kind = CK_ConstructorConversion; |
Douglas Gregor | d6e44a3 | 2010-04-16 22:09:46 +0000 | [diff] [blame] | 1283 | else |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1284 | Kind = CK_NoOp; |
Douglas Gregor | d6e44a3 | 2010-04-16 22:09:46 +0000 | [diff] [blame] | 1285 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1286 | SrcExpr = move(Result); |
Douglas Gregor | f0e43e5 | 2010-04-16 19:30:02 +0000 | [diff] [blame] | 1287 | return TC_Success; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1288 | } |
| 1289 | |
| 1290 | /// TryConstCast - See if a const_cast from source to destination is allowed, |
| 1291 | /// and perform it if it is. |
| 1292 | static TryCastResult TryConstCast(Sema &Self, Expr *SrcExpr, QualType DestType, |
| 1293 | bool CStyle, unsigned &msg) { |
| 1294 | DestType = Self.Context.getCanonicalType(DestType); |
| 1295 | QualType SrcType = SrcExpr->getType(); |
Douglas Gregor | 575d2a3 | 2011-01-22 00:19:52 +0000 | [diff] [blame] | 1296 | if (const ReferenceType *DestTypeTmp =DestType->getAs<ReferenceType>()) { |
| 1297 | if (DestTypeTmp->isLValueReferenceType() && !SrcExpr->isLValue()) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1298 | // Cannot const_cast non-lvalue to lvalue reference type. But if this |
| 1299 | // is C-style, static_cast might find a way, so we simply suggest a |
| 1300 | // message and tell the parent to keep searching. |
| 1301 | msg = diag::err_bad_cxx_cast_rvalue; |
| 1302 | return TC_NotApplicable; |
| 1303 | } |
| 1304 | |
| 1305 | // C++ 5.2.11p4: An lvalue of type T1 can be [cast] to an lvalue of type T2 |
| 1306 | // [...] if a pointer to T1 can be [cast] to the type pointer to T2. |
| 1307 | DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType()); |
| 1308 | SrcType = Self.Context.getPointerType(SrcType); |
| 1309 | } |
| 1310 | |
| 1311 | // C++ 5.2.11p5: For a const_cast involving pointers to data members [...] |
| 1312 | // the rules for const_cast are the same as those used for pointers. |
| 1313 | |
John McCall | d425d2b | 2010-05-18 09:35:29 +0000 | [diff] [blame] | 1314 | if (!DestType->isPointerType() && |
| 1315 | !DestType->isMemberPointerType() && |
| 1316 | !DestType->isObjCObjectPointerType()) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1317 | // Cannot cast to non-pointer, non-reference type. Note that, if DestType |
| 1318 | // was a reference type, we converted it to a pointer above. |
| 1319 | // The status of rvalue references isn't entirely clear, but it looks like |
| 1320 | // conversion to them is simply invalid. |
| 1321 | // C++ 5.2.11p3: For two pointer types [...] |
| 1322 | if (!CStyle) |
| 1323 | msg = diag::err_bad_const_cast_dest; |
| 1324 | return TC_NotApplicable; |
| 1325 | } |
| 1326 | if (DestType->isFunctionPointerType() || |
| 1327 | DestType->isMemberFunctionPointerType()) { |
| 1328 | // Cannot cast direct function pointers. |
| 1329 | // C++ 5.2.11p2: [...] where T is any object type or the void type [...] |
| 1330 | // T is the ultimate pointee of source and target type. |
| 1331 | if (!CStyle) |
| 1332 | msg = diag::err_bad_const_cast_dest; |
| 1333 | return TC_NotApplicable; |
| 1334 | } |
| 1335 | SrcType = Self.Context.getCanonicalType(SrcType); |
| 1336 | |
| 1337 | // Unwrap the pointers. Ignore qualifiers. Terminate early if the types are |
| 1338 | // completely equal. |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1339 | // C++ 5.2.11p3 describes the core semantics of const_cast. All cv specifiers |
| 1340 | // in multi-level pointers may change, but the level count must be the same, |
| 1341 | // as must be the final pointee type. |
| 1342 | while (SrcType != DestType && |
Douglas Gregor | 5a57efd | 2010-06-09 03:53:18 +0000 | [diff] [blame] | 1343 | Self.Context.UnwrapSimilarPointerTypes(SrcType, DestType)) { |
Douglas Gregor | d4c5f84 | 2011-04-15 17:59:54 +0000 | [diff] [blame] | 1344 | Qualifiers SrcQuals, DestQuals; |
| 1345 | SrcType = Self.Context.getUnqualifiedArrayType(SrcType, SrcQuals); |
| 1346 | DestType = Self.Context.getUnqualifiedArrayType(DestType, DestQuals); |
| 1347 | |
| 1348 | // const_cast is permitted to strip cvr-qualifiers, only. Make sure that |
| 1349 | // the other qualifiers (e.g., address spaces) are identical. |
| 1350 | SrcQuals.removeCVRQualifiers(); |
| 1351 | DestQuals.removeCVRQualifiers(); |
| 1352 | if (SrcQuals != DestQuals) |
| 1353 | return TC_NotApplicable; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1354 | } |
| 1355 | |
| 1356 | // Since we're dealing in canonical types, the remainder must be the same. |
| 1357 | if (SrcType != DestType) |
| 1358 | return TC_NotApplicable; |
| 1359 | |
| 1360 | return TC_Success; |
| 1361 | } |
| 1362 | |
Argyrios Kyrtzidis | f4bbbf0 | 2011-05-02 18:21:19 +0000 | [diff] [blame] | 1363 | // Checks for undefined behavior in reinterpret_cast. |
| 1364 | // The cases that is checked for is: |
| 1365 | // *reinterpret_cast<T*>(&a) |
| 1366 | // reinterpret_cast<T&>(a) |
| 1367 | // where accessing 'a' as type 'T' will result in undefined behavior. |
| 1368 | void Sema::CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, |
| 1369 | bool IsDereference, |
| 1370 | SourceRange Range) { |
| 1371 | unsigned DiagID = IsDereference ? |
| 1372 | diag::warn_pointer_indirection_from_incompatible_type : |
| 1373 | diag::warn_undefined_reinterpret_cast; |
| 1374 | |
| 1375 | if (Diags.getDiagnosticLevel(DiagID, Range.getBegin()) == |
| 1376 | Diagnostic::Ignored) { |
| 1377 | return; |
| 1378 | } |
| 1379 | |
| 1380 | QualType SrcTy, DestTy; |
| 1381 | if (IsDereference) { |
| 1382 | if (!SrcType->getAs<PointerType>() || !DestType->getAs<PointerType>()) { |
| 1383 | return; |
| 1384 | } |
| 1385 | SrcTy = SrcType->getPointeeType(); |
| 1386 | DestTy = DestType->getPointeeType(); |
| 1387 | } else { |
| 1388 | if (!DestType->getAs<ReferenceType>()) { |
| 1389 | return; |
| 1390 | } |
| 1391 | SrcTy = SrcType; |
| 1392 | DestTy = DestType->getPointeeType(); |
| 1393 | } |
| 1394 | |
| 1395 | // Cast is compatible if the types are the same. |
| 1396 | if (Context.hasSameUnqualifiedType(DestTy, SrcTy)) { |
| 1397 | return; |
| 1398 | } |
| 1399 | // or one of the types is a char or void type |
| 1400 | if (DestTy->isAnyCharacterType() || DestTy->isVoidType() || |
| 1401 | SrcTy->isAnyCharacterType() || SrcTy->isVoidType()) { |
| 1402 | return; |
| 1403 | } |
| 1404 | // or one of the types is a tag type. |
Chandler Carruth | 1f8f2d5 | 2011-05-24 07:43:19 +0000 | [diff] [blame] | 1405 | if (SrcTy->getAs<TagType>() || DestTy->getAs<TagType>()) { |
Argyrios Kyrtzidis | f4bbbf0 | 2011-05-02 18:21:19 +0000 | [diff] [blame] | 1406 | return; |
| 1407 | } |
| 1408 | |
Douglas Gregor | 575a1c9 | 2011-05-20 16:38:50 +0000 | [diff] [blame] | 1409 | // FIXME: Scoped enums? |
Argyrios Kyrtzidis | f4bbbf0 | 2011-05-02 18:21:19 +0000 | [diff] [blame] | 1410 | if ((SrcTy->isUnsignedIntegerType() && DestTy->isSignedIntegerType()) || |
| 1411 | (SrcTy->isSignedIntegerType() && DestTy->isUnsignedIntegerType())) { |
| 1412 | if (Context.getTypeSize(DestTy) == Context.getTypeSize(SrcTy)) { |
| 1413 | return; |
| 1414 | } |
| 1415 | } |
| 1416 | |
| 1417 | Diag(Range.getBegin(), DiagID) << SrcType << DestType << Range; |
| 1418 | } |
Douglas Gregor | fadb53b | 2011-03-12 01:48:56 +0000 | [diff] [blame] | 1419 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1420 | static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1421 | QualType DestType, bool CStyle, |
| 1422 | const SourceRange &OpRange, |
Anders Carlsson | 3c31a39 | 2009-09-26 00:12:34 +0000 | [diff] [blame] | 1423 | unsigned &msg, |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1424 | CastKind &Kind) { |
Douglas Gregor | e39a389 | 2010-07-13 23:17:26 +0000 | [diff] [blame] | 1425 | bool IsLValueCast = false; |
| 1426 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1427 | DestType = Self.Context.getCanonicalType(DestType); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1428 | QualType SrcType = SrcExpr.get()->getType(); |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 1429 | |
| 1430 | // Is the source an overloaded name? (i.e. &foo) |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 1431 | // If so, reinterpret_cast can not help us here (13.4, p1, bullet 5) ... |
| 1432 | if (SrcType == Self.Context.OverloadTy) { |
| 1433 | // ... unless foo<int> resolves to an lvalue unambiguously |
| 1434 | ExprResult SingleFunctionExpr = |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1435 | Self.ResolveAndFixSingleFunctionTemplateSpecialization(SrcExpr.get(), |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 1436 | Expr::getValueKindForType(DestType) == VK_RValue // Convert Fun to Ptr |
| 1437 | ); |
| 1438 | if (SingleFunctionExpr.isUsable()) { |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1439 | SrcExpr = move(SingleFunctionExpr); |
| 1440 | SrcType = SrcExpr.get()->getType(); |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 1441 | } |
| 1442 | else |
| 1443 | return TC_NotApplicable; |
| 1444 | } |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 1445 | |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 1446 | if (const ReferenceType *DestTypeTmp = DestType->getAs<ReferenceType>()) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1447 | bool LValue = DestTypeTmp->isLValueReferenceType(); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1448 | if (LValue && !SrcExpr.get()->isLValue()) { |
Douglas Gregor | 575d2a3 | 2011-01-22 00:19:52 +0000 | [diff] [blame] | 1449 | // Cannot cast non-lvalue to lvalue reference type. See the similar |
| 1450 | // comment in const_cast. |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1451 | msg = diag::err_bad_cxx_cast_rvalue; |
| 1452 | return TC_NotApplicable; |
| 1453 | } |
| 1454 | |
Argyrios Kyrtzidis | f4bbbf0 | 2011-05-02 18:21:19 +0000 | [diff] [blame] | 1455 | if (!CStyle) { |
| 1456 | Self.CheckCompatibleReinterpretCast(SrcType, DestType, |
| 1457 | /*isDereference=*/false, OpRange); |
| 1458 | } |
| 1459 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1460 | // C++ 5.2.10p10: [...] a reference cast reinterpret_cast<T&>(x) has the |
| 1461 | // same effect as the conversion *reinterpret_cast<T*>(&x) with the |
| 1462 | // built-in & and * operators. |
Argyrios Kyrtzidis | b464a5b | 2011-04-22 22:31:13 +0000 | [diff] [blame] | 1463 | |
Argyrios Kyrtzidis | bb29d1b | 2011-04-22 23:57:57 +0000 | [diff] [blame] | 1464 | const char *inappropriate = 0; |
| 1465 | switch (SrcExpr.get()->getObjectKind()) { |
Argyrios Kyrtzidis | e5e3d31 | 2011-04-23 01:10:24 +0000 | [diff] [blame] | 1466 | case OK_Ordinary: |
| 1467 | break; |
Argyrios Kyrtzidis | bb29d1b | 2011-04-22 23:57:57 +0000 | [diff] [blame] | 1468 | case OK_BitField: inappropriate = "bit-field"; break; |
| 1469 | case OK_VectorComponent: inappropriate = "vector element"; break; |
| 1470 | case OK_ObjCProperty: inappropriate = "property expression"; break; |
| 1471 | } |
| 1472 | if (inappropriate) { |
| 1473 | Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_reference) |
| 1474 | << inappropriate << DestType |
| 1475 | << OpRange << SrcExpr.get()->getSourceRange(); |
| 1476 | msg = 0; SrcExpr = ExprError(); |
Argyrios Kyrtzidis | b464a5b | 2011-04-22 22:31:13 +0000 | [diff] [blame] | 1477 | return TC_NotApplicable; |
| 1478 | } |
| 1479 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1480 | // This code does this transformation for the checked types. |
| 1481 | DestType = Self.Context.getPointerType(DestTypeTmp->getPointeeType()); |
| 1482 | SrcType = Self.Context.getPointerType(SrcType); |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 1483 | |
Douglas Gregor | e39a389 | 2010-07-13 23:17:26 +0000 | [diff] [blame] | 1484 | IsLValueCast = true; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1485 | } |
| 1486 | |
| 1487 | // Canonicalize source for comparison. |
| 1488 | SrcType = Self.Context.getCanonicalType(SrcType); |
| 1489 | |
Ted Kremenek | 6217b80 | 2009-07-29 21:53:49 +0000 | [diff] [blame] | 1490 | const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>(), |
| 1491 | *SrcMemPtr = SrcType->getAs<MemberPointerType>(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1492 | if (DestMemPtr && SrcMemPtr) { |
| 1493 | // C++ 5.2.10p9: An rvalue of type "pointer to member of X of type T1" |
| 1494 | // can be explicitly converted to an rvalue of type "pointer to member |
| 1495 | // of Y of type T2" if T1 and T2 are both function types or both object |
| 1496 | // types. |
| 1497 | if (DestMemPtr->getPointeeType()->isFunctionType() != |
| 1498 | SrcMemPtr->getPointeeType()->isFunctionType()) |
| 1499 | return TC_NotApplicable; |
| 1500 | |
| 1501 | // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away |
| 1502 | // constness. |
| 1503 | // A reinterpret_cast followed by a const_cast can, though, so in C-style, |
| 1504 | // we accept it. |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 1505 | if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle, |
| 1506 | /*CheckObjCLifetime=*/CStyle)) { |
Douglas Gregor | d4c5f84 | 2011-04-15 17:59:54 +0000 | [diff] [blame] | 1507 | msg = diag::err_bad_cxx_cast_qualifiers_away; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1508 | return TC_Failed; |
| 1509 | } |
| 1510 | |
Charles Davis | f231df3 | 2010-08-16 05:30:44 +0000 | [diff] [blame] | 1511 | // Don't allow casting between member pointers of different sizes. |
| 1512 | if (Self.Context.getTypeSize(DestMemPtr) != |
| 1513 | Self.Context.getTypeSize(SrcMemPtr)) { |
| 1514 | msg = diag::err_bad_cxx_cast_member_pointer_size; |
| 1515 | return TC_Failed; |
| 1516 | } |
| 1517 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1518 | // A valid member pointer cast. |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1519 | Kind = IsLValueCast? CK_LValueBitCast : CK_BitCast; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1520 | return TC_Success; |
| 1521 | } |
| 1522 | |
| 1523 | // See below for the enumeral issue. |
Douglas Gregor | 9d3347a | 2010-06-16 00:35:25 +0000 | [diff] [blame] | 1524 | if (SrcType->isNullPtrType() && DestType->isIntegralType(Self.Context)) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1525 | // C++0x 5.2.10p4: A pointer can be explicitly converted to any integral |
| 1526 | // type large enough to hold it. A value of std::nullptr_t can be |
| 1527 | // converted to an integral type; the conversion has the same meaning |
| 1528 | // and validity as a conversion of (void*)0 to the integral type. |
| 1529 | if (Self.Context.getTypeSize(SrcType) > |
| 1530 | Self.Context.getTypeSize(DestType)) { |
| 1531 | msg = diag::err_bad_reinterpret_cast_small_int; |
| 1532 | return TC_Failed; |
| 1533 | } |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1534 | Kind = CK_PointerToIntegral; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1535 | return TC_Success; |
| 1536 | } |
| 1537 | |
Anders Carlsson | 0de51bc | 2009-09-16 19:19:43 +0000 | [diff] [blame] | 1538 | bool destIsVector = DestType->isVectorType(); |
| 1539 | bool srcIsVector = SrcType->isVectorType(); |
| 1540 | if (srcIsVector || destIsVector) { |
Douglas Gregor | 9d3347a | 2010-06-16 00:35:25 +0000 | [diff] [blame] | 1541 | // FIXME: Should this also apply to floating point types? |
| 1542 | bool srcIsScalar = SrcType->isIntegralType(Self.Context); |
| 1543 | bool destIsScalar = DestType->isIntegralType(Self.Context); |
Anders Carlsson | 0de51bc | 2009-09-16 19:19:43 +0000 | [diff] [blame] | 1544 | |
| 1545 | // Check if this is a cast between a vector and something else. |
| 1546 | if (!(srcIsScalar && destIsVector) && !(srcIsVector && destIsScalar) && |
| 1547 | !(srcIsVector && destIsVector)) |
| 1548 | return TC_NotApplicable; |
| 1549 | |
| 1550 | // If both types have the same size, we can successfully cast. |
Douglas Gregor | f2a5539 | 2009-12-22 22:47:22 +0000 | [diff] [blame] | 1551 | if (Self.Context.getTypeSize(SrcType) |
| 1552 | == Self.Context.getTypeSize(DestType)) { |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1553 | Kind = CK_BitCast; |
Anders Carlsson | 0de51bc | 2009-09-16 19:19:43 +0000 | [diff] [blame] | 1554 | return TC_Success; |
Douglas Gregor | f2a5539 | 2009-12-22 22:47:22 +0000 | [diff] [blame] | 1555 | } |
Anders Carlsson | 0de51bc | 2009-09-16 19:19:43 +0000 | [diff] [blame] | 1556 | |
| 1557 | if (destIsScalar) |
| 1558 | msg = diag::err_bad_cxx_cast_vector_to_scalar_different_size; |
| 1559 | else if (srcIsScalar) |
| 1560 | msg = diag::err_bad_cxx_cast_scalar_to_vector_different_size; |
| 1561 | else |
| 1562 | msg = diag::err_bad_cxx_cast_vector_to_vector_different_size; |
| 1563 | |
| 1564 | return TC_Failed; |
| 1565 | } |
| 1566 | |
Douglas Gregor | bf9fb88 | 2010-07-08 20:27:32 +0000 | [diff] [blame] | 1567 | bool destIsPtr = DestType->isAnyPointerType() || |
| 1568 | DestType->isBlockPointerType(); |
| 1569 | bool srcIsPtr = SrcType->isAnyPointerType() || |
| 1570 | SrcType->isBlockPointerType(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1571 | if (!destIsPtr && !srcIsPtr) { |
| 1572 | // Except for std::nullptr_t->integer and lvalue->reference, which are |
| 1573 | // handled above, at least one of the two arguments must be a pointer. |
| 1574 | return TC_NotApplicable; |
| 1575 | } |
| 1576 | |
| 1577 | if (SrcType == DestType) { |
| 1578 | // C++ 5.2.10p2 has a note that mentions that, subject to all other |
| 1579 | // restrictions, a cast to the same type is allowed. The intent is not |
| 1580 | // entirely clear here, since all other paragraphs explicitly forbid casts |
| 1581 | // to the same type. However, the behavior of compilers is pretty consistent |
| 1582 | // on this point: allow same-type conversion if the involved types are |
| 1583 | // pointers, disallow otherwise. |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1584 | Kind = CK_NoOp; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1585 | return TC_Success; |
| 1586 | } |
| 1587 | |
Douglas Gregor | 9d3347a | 2010-06-16 00:35:25 +0000 | [diff] [blame] | 1588 | if (DestType->isIntegralType(Self.Context)) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1589 | assert(srcIsPtr && "One type must be a pointer"); |
| 1590 | // C++ 5.2.10p4: A pointer can be explicitly converted to any integral |
Francois Pichet | 30aff5b | 2011-05-11 22:13:54 +0000 | [diff] [blame] | 1591 | // type large enough to hold it; except in Microsoft mode, where the |
| 1592 | // integral type size doesn't matter. |
| 1593 | if ((Self.Context.getTypeSize(SrcType) > |
| 1594 | Self.Context.getTypeSize(DestType)) && |
| 1595 | !Self.getLangOptions().Microsoft) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1596 | msg = diag::err_bad_reinterpret_cast_small_int; |
| 1597 | return TC_Failed; |
| 1598 | } |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1599 | Kind = CK_PointerToIntegral; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1600 | return TC_Success; |
| 1601 | } |
| 1602 | |
Douglas Gregor | 2ade35e | 2010-06-16 00:17:44 +0000 | [diff] [blame] | 1603 | if (SrcType->isIntegralOrEnumerationType()) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1604 | assert(destIsPtr && "One type must be a pointer"); |
| 1605 | // C++ 5.2.10p5: A value of integral or enumeration type can be explicitly |
| 1606 | // converted to a pointer. |
John McCall | 404cd16 | 2010-11-13 01:35:44 +0000 | [diff] [blame] | 1607 | // C++ 5.2.10p9: [Note: ...a null pointer constant of integral type is not |
| 1608 | // necessarily converted to a null pointer value.] |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1609 | Kind = CK_IntegralToPointer; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1610 | return TC_Success; |
| 1611 | } |
| 1612 | |
| 1613 | if (!destIsPtr || !srcIsPtr) { |
| 1614 | // With the valid non-pointer conversions out of the way, we can be even |
| 1615 | // more stringent. |
| 1616 | return TC_NotApplicable; |
| 1617 | } |
| 1618 | |
| 1619 | // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away constness. |
| 1620 | // The C-style cast operator can. |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 1621 | if (CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle, |
| 1622 | /*CheckObjCLifetime=*/CStyle)) { |
Douglas Gregor | d4c5f84 | 2011-04-15 17:59:54 +0000 | [diff] [blame] | 1623 | msg = diag::err_bad_cxx_cast_qualifiers_away; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1624 | return TC_Failed; |
| 1625 | } |
Douglas Gregor | bf9fb88 | 2010-07-08 20:27:32 +0000 | [diff] [blame] | 1626 | |
| 1627 | // Cannot convert between block pointers and Objective-C object pointers. |
| 1628 | if ((SrcType->isBlockPointerType() && DestType->isObjCObjectPointerType()) || |
| 1629 | (DestType->isBlockPointerType() && SrcType->isObjCObjectPointerType())) |
| 1630 | return TC_NotApplicable; |
| 1631 | |
| 1632 | // Any pointer can be cast to an Objective-C pointer type with a C-style |
| 1633 | // cast. |
Fariborz Jahanian | 92ef5d7 | 2009-12-08 23:09:15 +0000 | [diff] [blame] | 1634 | if (CStyle && DestType->isObjCObjectPointerType()) { |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1635 | Kind = CK_AnyPointerToObjCPointerCast; |
Fariborz Jahanian | 92ef5d7 | 2009-12-08 23:09:15 +0000 | [diff] [blame] | 1636 | return TC_Success; |
| 1637 | } |
Douglas Gregor | bf9fb88 | 2010-07-08 20:27:32 +0000 | [diff] [blame] | 1638 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1639 | // Not casting away constness, so the only remaining check is for compatible |
| 1640 | // pointer categories. |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1641 | Kind = IsLValueCast? CK_LValueBitCast : CK_BitCast; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1642 | |
| 1643 | if (SrcType->isFunctionPointerType()) { |
| 1644 | if (DestType->isFunctionPointerType()) { |
| 1645 | // C++ 5.2.10p6: A pointer to a function can be explicitly converted to |
| 1646 | // a pointer to a function of a different type. |
| 1647 | return TC_Success; |
| 1648 | } |
| 1649 | |
| 1650 | // C++0x 5.2.10p8: Converting a pointer to a function into a pointer to |
| 1651 | // an object type or vice versa is conditionally-supported. |
| 1652 | // Compilers support it in C++03 too, though, because it's necessary for |
| 1653 | // casting the return value of dlsym() and GetProcAddress(). |
| 1654 | // FIXME: Conditionally-supported behavior should be configurable in the |
| 1655 | // TargetInfo or similar. |
| 1656 | if (!Self.getLangOptions().CPlusPlus0x) |
| 1657 | Self.Diag(OpRange.getBegin(), diag::ext_cast_fn_obj) << OpRange; |
| 1658 | return TC_Success; |
| 1659 | } |
| 1660 | |
| 1661 | if (DestType->isFunctionPointerType()) { |
| 1662 | // See above. |
| 1663 | if (!Self.getLangOptions().CPlusPlus0x) |
| 1664 | Self.Diag(OpRange.getBegin(), diag::ext_cast_fn_obj) << OpRange; |
| 1665 | return TC_Success; |
| 1666 | } |
Douglas Gregor | bf9fb88 | 2010-07-08 20:27:32 +0000 | [diff] [blame] | 1667 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1668 | // C++ 5.2.10p7: A pointer to an object can be explicitly converted to |
| 1669 | // a pointer to an object of different type. |
| 1670 | // Void pointers are not specified, but supported by every compiler out there. |
| 1671 | // So we finish by allowing everything that remains - it's got to be two |
| 1672 | // object pointers. |
| 1673 | return TC_Success; |
John McCall | 79ab2c8 | 2011-02-14 18:34:10 +0000 | [diff] [blame] | 1674 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1675 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1676 | ExprResult |
John McCall | f89e55a | 2010-11-18 06:31:45 +0000 | [diff] [blame] | 1677 | Sema::CXXCheckCStyleCast(SourceRange R, QualType CastTy, ExprValueKind &VK, |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1678 | Expr *CastExpr, CastKind &Kind, |
John McCall | f871d0c | 2010-08-07 06:22:56 +0000 | [diff] [blame] | 1679 | CXXCastPath &BasePath, |
Anders Carlsson | 5cf86ba | 2010-04-24 19:06:50 +0000 | [diff] [blame] | 1680 | bool FunctionalStyle) { |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1681 | // This test is outside everything else because it's the only case where |
| 1682 | // a non-lvalue-reference target type does not lead to decay. |
| 1683 | // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void". |
Anders Carlsson | bb378cb | 2009-10-18 20:31:03 +0000 | [diff] [blame] | 1684 | if (CastTy->isVoidType()) { |
John McCall | fb8721c | 2011-04-10 19:13:55 +0000 | [diff] [blame] | 1685 | Kind = CK_ToVoid; |
| 1686 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1687 | ExprResult CastExprRes = IgnoredValueConversions(CastExpr); |
| 1688 | if (CastExprRes.isInvalid()) |
| 1689 | return ExprError(); |
| 1690 | CastExpr = CastExprRes.take(); |
John McCall | fb8721c | 2011-04-10 19:13:55 +0000 | [diff] [blame] | 1691 | |
John McCall | 864c041 | 2011-04-26 20:42:42 +0000 | [diff] [blame] | 1692 | if (CastExpr->getType() == Context.BoundMemberTy) |
| 1693 | return CheckPlaceholderExpr(CastExpr); // will always fail |
| 1694 | |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 1695 | if (CastExpr->getType() == Context.OverloadTy) { |
| 1696 | ExprResult SingleFunctionExpr = |
Douglas Gregor | fadb53b | 2011-03-12 01:48:56 +0000 | [diff] [blame] | 1697 | ResolveAndFixSingleFunctionTemplateSpecialization( |
| 1698 | CastExpr, /* Decay Function to ptr */ false, |
| 1699 | /* Complain */ true, R, CastTy, |
| 1700 | diag::err_bad_cstyle_cast_overload); |
John McCall | fb8721c | 2011-04-10 19:13:55 +0000 | [diff] [blame] | 1701 | if (SingleFunctionExpr.isInvalid()) |
| 1702 | return ExprError(); |
| 1703 | CastExpr = SingleFunctionExpr.take(); |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 1704 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1705 | |
John McCall | fb8721c | 2011-04-10 19:13:55 +0000 | [diff] [blame] | 1706 | assert(!CastExpr->getType()->isPlaceholderType()); |
| 1707 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1708 | return Owned(CastExpr); |
Anton Yartsev | d06fea8 | 2011-03-27 09:32:40 +0000 | [diff] [blame] | 1709 | } |
| 1710 | |
John McCall | 9b4b9d6 | 2010-11-30 02:05:44 +0000 | [diff] [blame] | 1711 | // Make sure we determine the value kind before we bail out for |
| 1712 | // dependent types. |
| 1713 | VK = Expr::getValueKindForType(CastTy); |
| 1714 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1715 | // If the type is dependent, we won't do any other semantic analysis now. |
John McCall | daa8e4e | 2010-11-15 09:13:47 +0000 | [diff] [blame] | 1716 | if (CastTy->isDependentType() || CastExpr->isTypeDependent()) { |
| 1717 | Kind = CK_Dependent; |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1718 | return Owned(CastExpr); |
John McCall | daa8e4e | 2010-11-15 09:13:47 +0000 | [diff] [blame] | 1719 | } |
Benjamin Kramer | 5b4a40a | 2011-07-08 20:20:17 +0000 | [diff] [blame] | 1720 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1721 | if (VK == VK_RValue && !CastTy->isRecordType()) { |
| 1722 | ExprResult CastExprRes = DefaultFunctionArrayLvalueConversion(CastExpr); |
| 1723 | if (CastExprRes.isInvalid()) |
| 1724 | return ExprError(); |
| 1725 | CastExpr = CastExprRes.take(); |
| 1726 | } |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1727 | |
John McCall | fb8721c | 2011-04-10 19:13:55 +0000 | [diff] [blame] | 1728 | // AltiVec vector initialization with a single literal. |
| 1729 | if (const VectorType *vecTy = CastTy->getAs<VectorType>()) |
| 1730 | if (vecTy->getVectorKind() == VectorType::AltiVecVector |
| 1731 | && (CastExpr->getType()->isIntegerType() |
| 1732 | || CastExpr->getType()->isFloatingType())) { |
| 1733 | Kind = CK_VectorSplat; |
| 1734 | return Owned(CastExpr); |
| 1735 | } |
| 1736 | |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1737 | // C++ [expr.cast]p5: The conversions performed by |
| 1738 | // - a const_cast, |
| 1739 | // - a static_cast, |
| 1740 | // - a static_cast followed by a const_cast, |
| 1741 | // - a reinterpret_cast, or |
| 1742 | // - a reinterpret_cast followed by a const_cast, |
| 1743 | // can be performed using the cast notation of explicit type conversion. |
| 1744 | // [...] If a conversion can be interpreted in more than one of the ways |
| 1745 | // listed above, the interpretation that appears first in the list is used, |
| 1746 | // even if a cast resulting from that interpretation is ill-formed. |
| 1747 | // In plain language, this means trying a const_cast ... |
| 1748 | unsigned msg = diag::err_bad_cxx_cast_generic; |
Anders Carlsson | cb3c308 | 2009-09-01 20:52:42 +0000 | [diff] [blame] | 1749 | TryCastResult tcr = TryConstCast(*this, CastExpr, CastTy, /*CStyle*/true, |
| 1750 | msg); |
Anders Carlsson | da921fd | 2009-10-19 18:14:28 +0000 | [diff] [blame] | 1751 | if (tcr == TC_Success) |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 1752 | Kind = CK_NoOp; |
Anders Carlsson | da921fd | 2009-10-19 18:14:28 +0000 | [diff] [blame] | 1753 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 1754 | Sema::CheckedConversionKind CCK |
| 1755 | = FunctionalStyle? Sema::CCK_FunctionalCast |
| 1756 | : Sema::CCK_CStyleCast; |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1757 | if (tcr == TC_NotApplicable) { |
| 1758 | // ... or if that is not possible, a static_cast, ignoring const, ... |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1759 | ExprResult CastExprRes = Owned(CastExpr); |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 1760 | tcr = TryStaticCast(*this, CastExprRes, CastTy, CCK, R, msg, Kind, |
| 1761 | BasePath); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1762 | if (CastExprRes.isInvalid()) |
| 1763 | return ExprError(); |
| 1764 | CastExpr = CastExprRes.take(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1765 | if (tcr == TC_NotApplicable) { |
| 1766 | // ... and finally a reinterpret_cast, ignoring const. |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1767 | CastExprRes = Owned(CastExpr); |
Richard Trieu | 32ac00d | 2011-04-16 01:09:30 +0000 | [diff] [blame] | 1768 | tcr = TryReinterpretCast(*this, CastExprRes, CastTy, /*CStyle*/true, R, |
| 1769 | msg, Kind); |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1770 | if (CastExprRes.isInvalid()) |
| 1771 | return ExprError(); |
| 1772 | CastExpr = CastExprRes.take(); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1773 | } |
| 1774 | } |
| 1775 | |
Fariborz Jahanian | 82007c3 | 2011-07-08 17:41:42 +0000 | [diff] [blame] | 1776 | if (getLangOptions().ObjCAutoRefCount && tcr == TC_Success) |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 1777 | CheckObjCARCConversion(R, CastTy, CastExpr, CCK); |
| 1778 | |
Nick Lewycky | 43328e9 | 2010-11-09 00:19:31 +0000 | [diff] [blame] | 1779 | if (tcr != TC_Success && msg != 0) { |
| 1780 | if (CastExpr->getType() == Context.OverloadTy) { |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 1781 | DeclAccessPair Found; |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1782 | FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(CastExpr, |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 1783 | CastTy, |
| 1784 | /* Complain */ true, |
| 1785 | Found); |
Douglas Gregor | 1be8eec | 2011-02-19 21:32:49 +0000 | [diff] [blame] | 1786 | |
Richard Trieu | 32ac00d | 2011-04-16 01:09:30 +0000 | [diff] [blame] | 1787 | assert(!Fn && "cast failed but able to resolve overload expression!!"); |
Nick Lewycky | 43328e9 | 2010-11-09 00:19:31 +0000 | [diff] [blame] | 1788 | (void)Fn; |
John McCall | 79ab2c8 | 2011-02-14 18:34:10 +0000 | [diff] [blame] | 1789 | |
Nick Lewycky | 43328e9 | 2010-11-09 00:19:31 +0000 | [diff] [blame] | 1790 | } else { |
John McCall | 79ab2c8 | 2011-02-14 18:34:10 +0000 | [diff] [blame] | 1791 | diagnoseBadCast(*this, msg, (FunctionalStyle ? CT_Functional : CT_CStyle), |
| 1792 | R, CastExpr, CastTy); |
Douglas Gregor | 8e96043 | 2010-11-08 03:40:48 +0000 | [diff] [blame] | 1793 | } |
| 1794 | } |
John McCall | e2b7688 | 2010-11-16 05:46:29 +0000 | [diff] [blame] | 1795 | else if (Kind == CK_BitCast) |
John McCall | b7f4ffe | 2010-08-12 21:44:57 +0000 | [diff] [blame] | 1796 | CheckCastAlign(CastExpr, CastTy, R); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1797 | |
John Wiegley | 429bb27 | 2011-04-08 18:41:53 +0000 | [diff] [blame] | 1798 | if (tcr != TC_Success) |
| 1799 | return ExprError(); |
| 1800 | |
| 1801 | return Owned(CastExpr); |
Sebastian Redl | 9cc11e7 | 2009-07-25 15:41:38 +0000 | [diff] [blame] | 1802 | } |