/// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2
/// is valid:
///
/// An expression e can be explicitly converted to a type T using a
/// @c static_cast if the declaration "T t(e);" is well-formed [...].
TryCastResult
TryStaticImplicitCast(Sema &Self, Expr *SrcExpr, QualType DestType,
bool CStyle, const SourceRange &OpRange, unsigned &msg)
{
if (DestType->isReferenceType()) {
// At this point of CheckStaticCast, if the destination is a reference,
// this has to work. There is no other way that works.
// On the other hand, if we're checking a C-style cast, we've still got
// the reinterpret_cast way. In that case, we pass an ICS so we don't
// get error messages.
ImplicitConversionSequence ICS;
bool failed = Self.CheckReferenceInit(SrcExpr, DestType, CStyle ? &ICS : 0);
if (!failed)
return TC_Success;
if (CStyle)
return TC_NotApplicable;
// If we didn't pass the ICS, we already got an error message.
msg = 0;
return TC_Failed;
}
if (DestType->isRecordType()) {
// There are no further possibilities for the target type being a class,
// neither in static_cast nor in a C-style cast. So we can fail here.
// FIXME: We need to store this constructor in the AST.
if (Self.PerformInitializationByConstructor(DestType, &SrcExpr, 1,
OpRange.getBegin(), OpRange, DeclarationName(), Sema::IK_Direct))
return TC_Success;
// The function already emitted an error.
msg = 0;
return TC_Failed;
}
// FIXME: To get a proper error from invalid conversions here, we need to
// reimplement more of this.
// FIXME: This does not actually perform the conversion, and thus does not
// check for ambiguity or access.
ImplicitConversionSequence ICS = Self.TryImplicitConversion(
SrcExpr, DestType);
return ICS.ConversionKind == ImplicitConversionSequence::BadConversion ?
TC_NotApplicable : TC_Success;
}
