maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert r145244. It causes us to create broken ASTs with missing type information 

for some cast expressions.

Original commit message:

Removed useless ImplicitCast nodes in explicit cstyle and static casts

llvm-svn: 145447
This commit is contained in:
Richard Smith 2011-11-29 22:48:16 +00:00
parent 8b9ccfe270
commit 507840dbff
9 changed files with 110 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clang/include/clang/AST/ExprCXX.h
View File

@ -178,11 +178,9 @@ public:
/// \brief Retrieve the location of the cast operator keyword, e.g.,
/// "static_cast".
SourceLocation getOperatorLoc() const { return Loc; }
void setOperatorLoc(SourceLocation const& OpLoc) { Loc = OpLoc; }
/// \brief Retrieve the location of the closing parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation const& Loc) { RParenLoc = Loc; }
SourceRange getSourceRange() const {
return SourceRange(Loc, RParenLoc);

13
clang/include/clang/Sema/Initialization.h
View File

@ -340,7 +340,7 @@ private:
SIK_Default = IK_Default, ///< Default initialization
SIK_Value = IK_Value, ///< Value initialization
SIK_ImplicitValue, ///< Implicit value initialization
SIK_DirectStaticCast, ///< Direct initialization due to a static cast
SIK_DirectCast, ///< Direct initialization due to a cast
/// \brief Direct initialization due to a C-style cast.
SIK_DirectCStyleCast,
/// \brief Direct initialization due to a functional-style cast.
@ -372,8 +372,8 @@ public:
/// \brief Create a direct initialization due to a cast that isn't a C-style
/// or functional cast.
static InitializationKind CreateStaticCast(SourceRange TypeRange) {
return InitializationKind(SIK_DirectStaticCast,
static InitializationKind CreateCast(SourceRange TypeRange) {
return InitializationKind(SIK_DirectCast,
TypeRange.getBegin(), TypeRange.getBegin(),
TypeRange.getEnd());
}
@ -425,7 +425,7 @@ public:
/// \brief Determine whether this initialization is an explicit cast.
bool isExplicitCast() const {
return Kind == SIK_DirectStaticCast ||
return Kind == SIK_DirectCast ||
Kind == SIK_DirectCStyleCast ||
Kind == SIK_DirectFunctionalCast;
}
@ -440,11 +440,6 @@ public:
return Kind == SIK_DirectCStyleCast;
}
/// brief Determine whether this is a static cast.
bool isStaticCast() const {
return Kind == SIK_DirectStaticCast;
}
/// brief Determine whether this is a functional-style cast.
bool isFunctionalCast() const {
return Kind == SIK_DirectFunctionalCast;

28
clang/include/clang/Sema/Sema.h
View File

@ -5557,26 +5557,18 @@ public:
CCK_CStyleCast,
/// \brief A functional-style cast.
CCK_FunctionalCast,
/// \breif A static cast
CCK_StaticCast,
/// \brief A cast other than a C-style cast.
CCK_OtherCast
};
/// CastExprToType - If Expr is not of type 'Type', insert a cast of the
/// specified kind.
/// Redundant implicit casts are merged together.
ExprResult CastExprToType(Expr *E, QualType Ty,
CastKind Kind, ExprValueKind VK,
const CXXCastPath *BasePath,
CheckedConversionKind CCK);
/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
/// If there is already an implicit cast, merge into the existing one.
/// The result is of the given category.
/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
/// cast. If there is already an implicit cast, merge into the existing one.
/// If isLvalue, the result of the cast is an lvalue.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
ExprValueKind VK = VK_RValue,
const CXXCastPath *BasePath = 0);
const CXXCastPath *BasePath = 0,
CheckedConversionKind CCK
= CCK_ImplicitConversion);
/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
/// to the conversion from scalar type ScalarTy to the Boolean type.
@ -5765,10 +5757,10 @@ public:
AssignmentAction Action,
CheckedConversionKind CCK
= CCK_ImplicitConversion);
ExprResult PerformConversion(Expr *From, QualType ToType,
const StandardConversionSequence& SCS,
AssignmentAction Action,
CheckedConversionKind CCK);
ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
const StandardConversionSequence& SCS,
AssignmentAction Action,
CheckedConversionKind CCK);
/// the following "Check" methods will return a valid/converted QualType
/// or a null QualType (indicating an error diagnostic was issued).

60
clang/lib/Sema/Sema.cpp
View File

@ -234,16 +234,13 @@ void Sema::PrintStats() const {
AnalysisWarnings.PrintStats();
}
/// CastExprToType - If Expr is not of type 'Type', insert a cast of the
/// specified kind.
/// Redundant implicit casts are merged together.
/// Pay attention: if CCK != CCK_ImplicitConversion,
/// users of this function must fill
/// SourceTypeInfos and SourceLocations later
ExprResult Sema::CastExprToType(Expr *E, QualType Ty,
CastKind Kind, ExprValueKind VK,
const CXXCastPath *BasePath,
CheckedConversionKind CCK) {
/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
/// If there is already an implicit cast, merge into the existing one.
/// The result is of the given category.
ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
CastKind Kind, ExprValueKind VK,
const CXXCastPath *BasePath,
CheckedConversionKind CCK) {
#ifndef NDEBUG
if (VK == VK_RValue && !E->isRValue()) {
switch (Kind) {
@ -279,41 +276,16 @@ ExprResult Sema::CastExprToType(Expr *E, QualType Ty,
MarkVTableUsed(E->getLocStart(),
cast<CXXRecordDecl>(RecordTy->getDecl()));
}
switch(CCK) {
default:
llvm_unreachable("Unexpected CheckedConversionKind");
case CCK_ImplicitConversion:
if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
ImpCast->setType(Ty);
ImpCast->setValueKind(VK);
return Owned(E);
}
}
return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
case CCK_CStyleCast:
return Owned(CStyleCastExpr::Create(Context, Ty, VK, Kind, E, BasePath,
0, SourceLocation(), SourceLocation()));
case CCK_FunctionalCast:
return Owned(CXXFunctionalCastExpr::Create(Context, Ty, VK, 0,
SourceLocation(), Kind, E,
BasePath, SourceLocation()));
case CCK_StaticCast:
return Owned(CXXStaticCastExpr::Create(Context, Ty, VK, Kind, E, BasePath,
0, SourceLocation(),
SourceLocation()));
}
}
/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
/// If there is already an implicit cast, merge into the existing one.
/// The result is of the given category.
ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
CastKind Kind, ExprValueKind VK,
const CXXCastPath *BasePath) {
return CastExprToType(E, Ty, Kind, VK, BasePath, CCK_ImplicitConversion);
if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
ImpCast->setType(Ty);
ImpCast->setValueKind(VK);
return Owned(E);
}
}
return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
}
/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding

78
clang/lib/Sema/SemaCast.cpp
View File

@ -75,9 +75,9 @@ namespace {
// Top-level semantics-checking routines.
void CheckConstCast();
void CheckReinterpretCast();
void CheckStaticCast(bool &CastNodesCreated);
void CheckStaticCast();
void CheckDynamicCast();
void CheckCXXCStyleCast(bool FunctionalCast, bool &CastNodesCreated);
void CheckCXXCStyleCast(bool FunctionalCast);
void CheckCStyleCast();
/// Complete an apparently-successful cast operation that yields
@ -283,28 +283,12 @@ Sema::BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind,
Parens.getEnd()));
}
case tok::kw_static_cast: {
bool CastNodesCreated = false;
if (!TypeDependent) {
Op.CheckStaticCast(CastNodesCreated);
Op.CheckStaticCast();
if (Op.SrcExpr.isInvalid())
return ExprError();
}
// CheckStaticCast _may_ have already created the cast node. Let's check
if (CastNodesCreated) {
if (CXXStaticCastExpr *Cast =
dyn_cast<CXXStaticCastExpr>(Op.SrcExpr.get())) {
assert(!Cast->getTypeInfoAsWritten() &&
"The explicit cast node created by CheckStaticCast "
"has source type infos!");
Cast->setTypeInfoAsWritten(DestTInfo);
Cast->setOperatorLoc(OpLoc);
Cast->setRParenLoc(Parens.getEnd());
return Op.complete(Cast);
}
}
return Op.complete(CXXStaticCastExpr::Create(Context, Op.ResultType,
Op.ValueKind, Op.Kind, Op.SrcExpr.take(),
&Op.BasePath, DestTInfo,
@ -343,7 +327,7 @@ static bool tryDiagnoseOverloadedCast(Sema &S, CastType CT,
= (CT == CT_CStyle)? InitializationKind::CreateCStyleCast(range.getBegin(),
range)
: (CT == CT_Functional)? InitializationKind::CreateFunctionalCast(range)
: InitializationKind::CreateStaticCast(/*type range?*/ range);
: InitializationKind::CreateCast(/*type range?*/ range);
InitializationSequence sequence(S, entity, initKind, &src, 1);
assert(sequence.Failed() && "initialization succeeded on second try?");
@ -730,7 +714,7 @@ void CastOperation::CheckReinterpretCast() {
/// CheckStaticCast - Check that a static_cast\<DestType\>(SrcExpr) is valid.
/// Refer to C++ 5.2.9 for details. Static casts are mostly used for making
/// implicit conversions explicit and getting rid of data loss warnings.
void CastOperation::CheckStaticCast(bool &CastNodesCreated) {
void CastOperation::CheckStaticCast() {
if (isPlaceholder()) {
checkNonOverloadPlaceholders();
if (SrcExpr.isInvalid())
@ -763,10 +747,9 @@ void CastOperation::CheckStaticCast(bool &CastNodesCreated) {
return;
}
Expr *SrcExprOrig = SrcExpr.get();
unsigned msg = diag::err_bad_cxx_cast_generic;
TryCastResult tcr
= TryStaticCast(Self, SrcExpr, DestType, Sema::CCK_StaticCast, OpRange, msg,
= TryStaticCast(Self, SrcExpr, DestType, Sema::CCK_OtherCast, OpRange, msg,
Kind, BasePath);
if (tcr != TC_Success && msg != 0) {
if (SrcExpr.isInvalid())
@ -784,12 +767,10 @@ void CastOperation::CheckStaticCast(bool &CastNodesCreated) {
if (Kind == CK_BitCast)
checkCastAlign();
if (Self.getLangOptions().ObjCAutoRefCount)
checkObjCARCConversion(Sema::CCK_StaticCast);
checkObjCARCConversion(Sema::CCK_OtherCast);
} else if (Kind == CK_BitCast) {
checkCastAlign();
}
CastNodesCreated = (SrcExpr.get() != SrcExprOrig);
}
/// TryStaticCast - Check if a static cast can be performed, and do so if
@ -1327,7 +1308,7 @@ TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
? InitializationKind::CreateCStyleCast(OpRange.getBegin(), OpRange)
: (CCK == Sema::CCK_FunctionalCast)
? InitializationKind::CreateFunctionalCast(OpRange)
: InitializationKind::CreateStaticCast(OpRange);
: InitializationKind::CreateCast(OpRange);
Expr *SrcExprRaw = SrcExpr.get();
InitializationSequence InitSeq(Self, Entity, InitKind, &SrcExprRaw, 1);
@ -1761,9 +1742,7 @@ static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
return TC_Success;
}
void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
bool &CastNodesCreated) {
CastNodesCreated = false;
void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle) {
// Handle placeholders.
if (isPlaceholder()) {
// C-style casts can resolve __unknown_any types.
@ -1844,7 +1823,6 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
= FunctionalStyle? Sema::CCK_FunctionalCast
: Sema::CCK_CStyleCast;
if (tcr == TC_NotApplicable) {
Expr *SrcExprOrig = SrcExpr.get();
// ... or if that is not possible, a static_cast, ignoring const, ...
tcr = TryStaticCast(Self, SrcExpr, DestType, CCK, OpRange,
msg, Kind, BasePath);
@ -1858,8 +1836,6 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
if (SrcExpr.isInvalid())
return;
}
CastNodesCreated = (SrcExpr.get() != SrcExprOrig);
}
if (Self.getLangOptions().ObjCAutoRefCount && tcr == TC_Success)
@ -2077,9 +2053,8 @@ ExprResult Sema::BuildCStyleCastExpr(SourceLocation LPLoc,
Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
Op.OpRange = SourceRange(LPLoc, CastExpr->getLocEnd());
bool CastNodesCreated = false;
if (getLangOptions().CPlusPlus) {
Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ false, CastNodesCreated);
Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ false);
} else {
Op.CheckCStyleCast();
}
@ -2087,20 +2062,6 @@ ExprResult Sema::BuildCStyleCastExpr(SourceLocation LPLoc,
if (Op.SrcExpr.isInvalid())
return ExprError();
// CheckCXXCStyleCast _may_ have already created the CStyleCastExpr
// node. Let's check.
if (CastNodesCreated) {
if (CStyleCastExpr *Cast = dyn_cast<CStyleCastExpr>(Op.SrcExpr.get())){
assert(!Cast->getTypeInfoAsWritten() &&
"The explicit cast node created by CheckStaticCast "
"has source type infos!");
Cast->setTypeInfoAsWritten(CastTypeInfo);
Cast->setLParenLoc(LPLoc);
Cast->setRParenLoc(RPLoc);
return Op.complete(Cast);
}
}
return Op.complete(CStyleCastExpr::Create(Context, Op.ResultType,
Op.ValueKind, Op.Kind, Op.SrcExpr.take(),
&Op.BasePath, CastTypeInfo, LPLoc, RPLoc));
@ -2114,28 +2075,11 @@ ExprResult Sema::BuildCXXFunctionalCastExpr(TypeSourceInfo *CastTypeInfo,
Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
Op.OpRange = SourceRange(Op.DestRange.getBegin(), CastExpr->getLocEnd());
bool CastNodesCreated = false;
Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ true, CastNodesCreated);
Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ true);
if (Op.SrcExpr.isInvalid())
return ExprError();
// CheckCXXCStyleCast _may_ have already created the CXXFunctionalCastExpr
// node. Let's check.
if (CastNodesCreated) {
if (CXXFunctionalCastExpr *Cast =
dyn_cast<CXXFunctionalCastExpr>(Op.SrcExpr.get())){
assert(!Cast->getTypeInfoAsWritten() &&
"The explicit cast node created by CheckStaticCast "
"has source type infos!");
Cast->setTypeInfoAsWritten(CastTypeInfo);
Cast->setTypeBeginLoc(Op.DestRange.getBegin());
Cast->setRParenLoc(RPLoc);
return Op.complete(Cast);
}
}
return Op.complete(CXXFunctionalCastExpr::Create(Context, Op.ResultType,
Op.ValueKind, CastTypeInfo, Op.DestRange.getBegin(),
Op.Kind, Op.SrcExpr.take(), &Op.BasePath, RPLoc));
}

132
clang/lib/Sema/SemaExprCXX.cpp
View File

@ -2125,8 +2125,8 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType,
CheckedConversionKind CCK) {
switch (ICS.getKind()) {
case ImplicitConversionSequence::StandardConversion: {
ExprResult Res = PerformConversion(From, ToType, ICS.Standard,
Action, CCK);
ExprResult Res = PerformImplicitConversion(From, ToType, ICS.Standard,
Action, CCK);
if (Res.isInvalid())
return ExprError();
From = Res.take();
@ -2160,8 +2160,9 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType,
// Watch out for elipsis conversion.
if (!ICS.UserDefined.EllipsisConversion) {
ExprResult Res =
PerformConversion(From, BeforeToType,
ICS.UserDefined.Before, AA_Converting, CCK);
PerformImplicitConversion(From, BeforeToType,
ICS.UserDefined.Before, AA_Converting,
CCK);
if (Res.isInvalid())
return ExprError();
From = Res.take();
@ -2181,8 +2182,8 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType,
From = CastArg.take();
return PerformConversion(From, ToType, ICS.UserDefined.After,
AA_Converting, CCK);
return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
AA_Converting, CCK);
}
case ImplicitConversionSequence::AmbiguousConversion:
@ -2202,13 +2203,13 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType,
return Owned(From);
}
/// PerformConversion - Perform a conversion of the
/// PerformImplicitConversion - Perform an implicit conversion of the
/// expression From to the type ToType by following the standard
/// conversion sequence SCS. Returns the converted
/// expression. Flavor is the context in which we're performing this
/// conversion, for use in error messages.
ExprResult
Sema::PerformConversion(Expr *From, QualType ToType,
Sema::PerformImplicitConversion(Expr *From, QualType ToType,
const StandardConversionSequence& SCS,
AssignmentAction Action,
CheckedConversionKind CCK) {
@ -2262,7 +2263,7 @@ Sema::PerformConversion(Expr *From, QualType ToType,
FromType = From->getType();
}
// Perform the first conversion step.
// Perform the first implicit conversion.
switch (SCS.First) {
case ICK_Identity:
// Nothing to do.
@ -2277,21 +2278,21 @@ Sema::PerformConversion(Expr *From, QualType ToType,
case ICK_Array_To_Pointer:
FromType = Context.getArrayDecayedType(FromType);
From = CastExprToType(From, FromType, CK_ArrayToPointerDecay,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
case ICK_Function_To_Pointer:
FromType = Context.getPointerType(FromType);
From = CastExprToType(From, FromType, CK_FunctionToPointerDecay,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
default:
llvm_unreachable("Improper first standard conversion");
}
// Perform the second conversion step
// Perform the second implicit conversion
switch (SCS.Second) {
case ICK_Identity:
// If both sides are functions (or pointers/references to them), there could
@ -2307,20 +2308,20 @@ Sema::PerformConversion(Expr *From, QualType ToType,
if (CheckExceptionSpecCompatibility(From, ToType))
return ExprError();
From = CastExprToType(From, ToType, CK_NoOp,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType, CK_NoOp,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
case ICK_Integral_Promotion:
case ICK_Integral_Conversion:
From = CastExprToType(From, ToType, CK_IntegralCast,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType, CK_IntegralCast,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
case ICK_Floating_Promotion:
case ICK_Floating_Conversion:
From = CastExprToType(From, ToType, CK_FloatingCast,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType, CK_FloatingCast,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
case ICK_Complex_Promotion:
@ -2338,23 +2339,23 @@ Sema::PerformConversion(Expr *From, QualType ToType,
} else {
CK = CK_IntegralComplexCast;
}
From = CastExprToType(From, ToType, CK,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType, CK,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
}
case ICK_Floating_Integral:
if (ToType->isRealFloatingType())
From = CastExprToType(From, ToType, CK_IntegralToFloating,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType, CK_IntegralToFloating,
VK_RValue, /*BasePath=*/0, CCK).take();
else
From = CastExprToType(From, ToType, CK_FloatingToIntegral,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
case ICK_Compatible_Conversion:
From = CastExprToType(From, ToType, CK_NoOp,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType, CK_NoOp,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
case ICK_Writeback_Conversion:
@ -2402,7 +2403,8 @@ Sema::PerformConversion(Expr *From, QualType ToType,
From = E.take();
}
From = CastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK).take();
From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
.take();
break;
}
@ -2413,7 +2415,8 @@ Sema::PerformConversion(Expr *From, QualType ToType,
return ExprError();
if (CheckExceptionSpecCompatibility(From, ToType))
return ExprError();
From = CastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK).take();
From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
.take();
break;
}
@ -2424,9 +2427,9 @@ Sema::PerformConversion(Expr *From, QualType ToType,
FromType = Context.FloatTy;
}
From = CastExprToType(From, Context.BoolTy,
ScalarTypeToBooleanCastKind(FromType),
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, Context.BoolTy,
ScalarTypeToBooleanCastKind(FromType),
VK_RValue, /*BasePath=*/0, CCK).take();
break;
case ICK_Derived_To_Base: {
@ -2439,20 +2442,20 @@ Sema::PerformConversion(Expr *From, QualType ToType,
CStyle))
return ExprError();
From = CastExprToType(From, ToType.getNonReferenceType(),
CK_DerivedToBase, From->getValueKind(),
&BasePath, CCK).take();
From = ImpCastExprToType(From, ToType.getNonReferenceType(),
CK_DerivedToBase, From->getValueKind(),
&BasePath, CCK).take();
break;
}
case ICK_Vector_Conversion:
From = CastExprToType(From, ToType, CK_BitCast,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType, CK_BitCast,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
case ICK_Vector_Splat:
From = CastExprToType(From, ToType, CK_VectorSplat,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType, CK_VectorSplat,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
case ICK_Complex_Real:
@ -2465,22 +2468,17 @@ Sema::PerformConversion(Expr *From, QualType ToType,
if (Context.hasSameUnqualifiedType(ElType, From->getType())) {
// do nothing
} else if (From->getType()->isRealFloatingType()) {
From = CastExprToType(From, ElType,
isFloatingComplex ? CK_FloatingCast
: CK_FloatingToIntegral,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ElType,
isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).take();
} else {
assert(From->getType()->isIntegerType());
From = CastExprToType(From, ElType,
isFloatingComplex ? CK_IntegralToFloating
: CK_IntegralCast,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ElType,
isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).take();
}
// y -> _Complex y
From = CastExprToType(From, ToType,
isFloatingComplex ? CK_FloatingRealToComplex
: CK_IntegralRealToComplex,
VK_RValue, /*BasePath=*/ 0, CCK).take();
From = ImpCastExprToType(From, ToType,
isFloatingComplex ? CK_FloatingRealToComplex
: CK_IntegralRealToComplex).take();
// Case 2. _Complex x -> y
} else {
@ -2491,32 +2489,30 @@ Sema::PerformConversion(Expr *From, QualType ToType,
bool isFloatingComplex = ElType->isRealFloatingType();
// _Complex x -> x
From = CastExprToType(From, ElType,
isFloatingComplex ? CK_FloatingComplexToReal
: CK_IntegralComplexToReal,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ElType,
isFloatingComplex ? CK_FloatingComplexToReal
: CK_IntegralComplexToReal,
VK_RValue, /*BasePath=*/0, CCK).take();
// x -> y
if (Context.hasSameUnqualifiedType(ElType, ToType)) {
// do nothing
} else if (ToType->isRealFloatingType()) {
From = CastExprToType(From, ToType,
isFloatingComplex ? CK_FloatingCast
: CK_IntegralToFloating,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType,
isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating,
VK_RValue, /*BasePath=*/0, CCK).take();
} else {
assert(ToType->isIntegerType());
From = CastExprToType(From, ToType,
isFloatingComplex ? CK_FloatingToIntegral
: CK_IntegralCast,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType,
isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast,
VK_RValue, /*BasePath=*/0, CCK).take();
}
}
break;
case ICK_Block_Pointer_Conversion: {
From = CastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
VK_RValue, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
VK_RValue, /*BasePath=*/0, CCK).take();
break;
}
@ -2551,8 +2547,8 @@ Sema::PerformConversion(Expr *From, QualType ToType,
// target type isn't a reference.
ExprValueKind VK = ToType->isReferenceType() ?
From->getValueKind() : VK_RValue;
From = CastExprToType(From, ToType.getNonLValueExprType(Context),
CK_NoOp, VK, /*BasePath=*/0, CCK).take();
From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
CK_NoOp, VK, /*BasePath=*/0, CCK).take();
if (SCS.DeprecatedStringLiteralToCharPtr &&
!getLangOptions().WritableStrings)

2
clang/lib/Sema/SemaInit.cpp
View File

@ -4863,7 +4863,7 @@ InitializationSequence::Perform(Sema &S,
Sema::CheckedConversionKind CCK
= Kind.isCStyleCast()? Sema::CCK_CStyleCast
: Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
: Kind.isStaticCast()? Sema::CCK_StaticCast
: Kind.isExplicitCast()? Sema::CCK_OtherCast
: Sema::CCK_ImplicitConversion;
ExprResult CurInitExprRes =
S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,

1
clang/test/Index/preamble_macro_template.cpp
View File

@ -9,6 +9,7 @@ int main() { }
// CHECK: preamble_macro_template.h:4:16: CompoundStmt= Extent=[4:16 - 6:2]
// CHECK: preamble_macro_template.h:5:3: CStyleCastExpr= Extent=[5:3 - 5:27]
// CHECK: preamble_macro_template.h:1:21: CXXStaticCastExpr= Extent=[1:21 - 5:27]
// CHECK: preamble_macro_template.h:5:25: UnexposedExpr= Extent=[5:25 - 5:26]
// CHECK: preamble_macro_template.h:5:25: IntegerLiteral= Extent=[5:25 - 5:26]
// CHECK: preamble_macro_template.cpp:3:5: FunctionDecl=main:3:5 (Definition) Extent=[3:1 - 3:15]
// CHECK: preamble_macro_template.cpp:3:12: CompoundStmt= Extent=[3:12 - 3:15]

3
clang/test/Index/recursive-cxx-member-calls.cpp
View File

@ -1632,6 +1632,7 @@ AttributeList::Kind AttributeList::getKind(const IdentifierInfo * Name) {
// CHECK: 41:30: UnaryOperator= Extent=[41:30 - 41:40]
// CHECK: 41:31: CXXFunctionalCastExpr= Extent=[41:31 - 41:40]
// CHECK: 41:31: TypeRef=size_t:2:25 Extent=[41:31 - 41:37]
// CHECK: 41:38: UnexposedExpr= Extent=[41:38 - 41:39]
// CHECK: 41:38: IntegerLiteral= Extent=[41:38 - 41:39]
// CHECK: 42:1: CXXAccessSpecifier=:42:1 (Definition) Extent=[42:1 - 42:9]
// CHECK: 43:15: FieldDecl=Data:43:15 (Definition) Extent=[43:3 - 43:19]
@ -1803,6 +1804,7 @@ AttributeList::Kind AttributeList::getKind(const IdentifierInfo * Name) {
// CHECK: 75:13: ParenExpr= Extent=[75:13 - 75:30]
// CHECK: 75:14: CStyleCastExpr= Extent=[75:14 - 75:29]
// CHECK: 75:25: UnexposedExpr= Extent=[75:25 - 75:29]
// CHECK: 75:25: UnexposedExpr= Extent=[75:25 - 75:29]
// CHECK: 75:25: ArraySubscriptExpr= Extent=[75:25 - 75:29]
// CHECK: 75:25: DeclRefExpr=p:74:17 Extent=[75:25 - 75:26]
// CHECK: 75:27: IntegerLiteral= Extent=[75:27 - 75:28]
@ -1811,6 +1813,7 @@ AttributeList::Kind AttributeList::getKind(const IdentifierInfo * Name) {
// CHECK: 75:34: ParenExpr= Extent=[75:34 - 75:51]
// CHECK: 75:35: CStyleCastExpr= Extent=[75:35 - 75:50]
// CHECK: 75:46: UnexposedExpr= Extent=[75:46 - 75:50]
// CHECK: 75:46: UnexposedExpr= Extent=[75:46 - 75:50]
// CHECK: 75:46: ArraySubscriptExpr= Extent=[75:46 - 75:50]
// CHECK: 75:46: DeclRefExpr=p:74:17 Extent=[75:46 - 75:47]
// CHECK: 75:48: IntegerLiteral= Extent=[75:48 - 75:49]