/// 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; }
/// 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 [...]. TryStaticCastResult TryStaticImplicitCast(Sema &Self, Expr *SrcExpr, QualType DestType, const SourceRange &OpRange) { 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. return Self.CheckReferenceInit(SrcExpr, DestType) ? TSC_Failed : TSC_Success; } if (DestType->isRecordType()) { // FIXME: Use an implementation of C++ [over.match.ctor] for this. return TSC_NotApplicable; } // FIXME: To get a proper error from invalid conversions here, we need to // reimplement more of this. ImplicitConversionSequence ICS = Self.TryImplicitConversion( SrcExpr, DestType); return ICS.ConversionKind == ImplicitConversionSequence::BadConversion ? TSC_NotApplicable : TSC_Success; }