Skip to content

Commit 40921a2

Browse files
EndilllEndilll
authored
Revert "[clang][NFC] Refactor CXXNewExpr::InitializationStyle (#71322)"
This reverts commit ace4489.
1 parent 22a323e commit 40921a2

File tree

8 files changed

+74
-96
lines changed

8 files changed

+74
-96
lines changed

‎clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -323,8 +323,7 @@ bool MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag,
323323
return false;
324324
};
325325
switch (New->getInitializationStyle()) {
326-
case CXXNewInitializationStyle::None:
327-
case CXXNewInitializationStyle::Implicit: {
326+
case CXXNewExpr::NoInit: {
328327
if (ArraySizeExpr.empty()) {
329328
Diag << FixItHint::CreateRemoval(SourceRange(NewStart, NewEnd));
330329
} else {
@@ -335,7 +334,7 @@ bool MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag,
335334
}
336335
break;
337336
}
338-
case CXXNewInitializationStyle::Call: {
337+
case CXXNewExpr::CallInit: {
339338
// FIXME: Add fixes for constructors with parameters that can be created
340339
// with a C++11 braced-init-list (e.g. std::vector, std::map).
341340
// Unlike ordinal cases, braced list can not be deduced in
@@ -372,7 +371,7 @@ bool MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag,
372371
}
373372
break;
374373
}
375-
case CXXNewInitializationStyle::List: {
374+
case CXXNewExpr::ListInit: {
376375
// Range of the substring that we do not want to remove.
377376
SourceRange InitRange;
378377
if (const auto *NewConstruct = New->getConstructExpr()) {

‎clang/include/clang/AST/ExprCXX.h

Lines changed: 21 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -2206,20 +2206,6 @@ class CXXScalarValueInitExpr : public Expr {
22062206
}
22072207
};
22082208

2209-
enum class CXXNewInitializationStyle {
2210-
/// New-expression has no initializer as written.
2211-
None,
2212-
2213-
/// New-expression has no written initializer, but has an implicit one.
2214-
Implicit,
2215-
2216-
/// New-expression has a C++98 paren-delimited initializer.
2217-
Call,
2218-
2219-
/// New-expression has a C++11 list-initializer.
2220-
List
2221-
};
2222-
22232209
/// Represents a new-expression for memory allocation and constructor
22242210
/// calls, e.g: "new CXXNewExpr(foo)".
22252211
class CXXNewExpr final
@@ -2273,12 +2259,25 @@ class CXXNewExpr final
22732259
return isParenTypeId();
22742260
}
22752261

2262+
public:
2263+
enum InitializationStyle {
2264+
/// New-expression has no initializer as written.
2265+
NoInit,
2266+
2267+
/// New-expression has a C++98 paren-delimited initializer.
2268+
CallInit,
2269+
2270+
/// New-expression has a C++11 list-initializer.
2271+
ListInit
2272+
};
2273+
2274+
private:
22762275
/// Build a c++ new expression.
22772276
CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew,
22782277
FunctionDecl *OperatorDelete, bool ShouldPassAlignment,
22792278
bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
22802279
SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
2281-
CXXNewInitializationStyle InitializationStyle, Expr *Initializer,
2280+
InitializationStyle InitializationStyle, Expr *Initializer,
22822281
QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
22832282
SourceRange DirectInitRange);
22842283

@@ -2293,7 +2292,7 @@ class CXXNewExpr final
22932292
FunctionDecl *OperatorDelete, bool ShouldPassAlignment,
22942293
bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
22952294
SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
2296-
CXXNewInitializationStyle InitializationStyle, Expr *Initializer,
2295+
InitializationStyle InitializationStyle, Expr *Initializer,
22972296
QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
22982297
SourceRange DirectInitRange);
22992298

@@ -2389,20 +2388,15 @@ class CXXNewExpr final
23892388

23902389
/// Whether this new-expression has any initializer at all.
23912390
bool hasInitializer() const {
2392-
switch (getInitializationStyle()) {
2393-
case CXXNewInitializationStyle::None:
2394-
return false;
2395-
case CXXNewInitializationStyle::Implicit:
2396-
case CXXNewInitializationStyle::Call:
2397-
case CXXNewInitializationStyle::List:
2398-
return true;
2399-
}
2391+
return CXXNewExprBits.StoredInitializationStyle > 0;
24002392
}
24012393

24022394
/// The kind of initializer this new-expression has.
2403-
CXXNewInitializationStyle getInitializationStyle() const {
2404-
return static_cast<CXXNewInitializationStyle>(
2405-
CXXNewExprBits.StoredInitializationStyle);
2395+
InitializationStyle getInitializationStyle() const {
2396+
if (CXXNewExprBits.StoredInitializationStyle == 0)
2397+
return NoInit;
2398+
return static_cast<InitializationStyle>(
2399+
CXXNewExprBits.StoredInitializationStyle - 1);
24062400
}
24072401

24082402
/// The initializer of this new-expression.

‎clang/lib/AST/ExprCXX.cpp

Lines changed: 14 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -184,7 +184,7 @@ CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew,
184184
bool UsualArrayDeleteWantsSize,
185185
ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens,
186186
std::optional<Expr *> ArraySize,
187-
CXXNewInitializationStyle InitializationStyle,
187+
InitializationStyle InitializationStyle,
188188
Expr *Initializer, QualType Ty,
189189
TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
190190
SourceRange DirectInitRange)
@@ -193,17 +193,15 @@ CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew,
193193
AllocatedTypeInfo(AllocatedTypeInfo), Range(Range),
194194
DirectInitRange(DirectInitRange) {
195195

196-
assert((Initializer != nullptr ||
197-
InitializationStyle == CXXNewInitializationStyle::None ||
198-
InitializationStyle == CXXNewInitializationStyle::Implicit) &&
196+
assert((Initializer != nullptr || InitializationStyle == NoInit) &&
199197
"Only NoInit can have no initializer!");
200198

201199
CXXNewExprBits.IsGlobalNew = IsGlobalNew;
202200
CXXNewExprBits.IsArray = ArraySize.has_value();
203201
CXXNewExprBits.ShouldPassAlignment = ShouldPassAlignment;
204202
CXXNewExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;
205203
CXXNewExprBits.StoredInitializationStyle =
206-
llvm::to_underlying(InitializationStyle);
204+
Initializer ? InitializationStyle + 1 : 0;
207205
bool IsParenTypeId = TypeIdParens.isValid();
208206
CXXNewExprBits.IsParenTypeId = IsParenTypeId;
209207
CXXNewExprBits.NumPlacementArgs = PlacementArgs.size();
@@ -219,10 +217,10 @@ CXXNewExpr::CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew,
219217
getTrailingObjects<SourceRange>()[0] = TypeIdParens;
220218

221219
switch (getInitializationStyle()) {
222-
case CXXNewInitializationStyle::Call:
220+
case CallInit:
223221
this->Range.setEnd(DirectInitRange.getEnd());
224222
break;
225-
case CXXNewInitializationStyle::List:
223+
case ListInit:
226224
this->Range.setEnd(getInitializer()->getSourceRange().getEnd());
227225
break;
228226
default:
@@ -242,14 +240,15 @@ CXXNewExpr::CXXNewExpr(EmptyShell Empty, bool IsArray,
242240
CXXNewExprBits.IsParenTypeId = IsParenTypeId;
243241
}
244242

245-
CXXNewExpr *CXXNewExpr::Create(
246-
const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew,
247-
FunctionDecl *OperatorDelete, bool ShouldPassAlignment,
248-
bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
249-
SourceRange TypeIdParens, std::optional<Expr *> ArraySize,
250-
CXXNewInitializationStyle InitializationStyle, Expr *Initializer,
251-
QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
252-
SourceRange DirectInitRange) {
243+
CXXNewExpr *
244+
CXXNewExpr::Create(const ASTContext &Ctx, bool IsGlobalNew,
245+
FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete,
246+
bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize,
247+
ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens,
248+
std::optional<Expr *> ArraySize,
249+
InitializationStyle InitializationStyle, Expr *Initializer,
250+
QualType Ty, TypeSourceInfo *AllocatedTypeInfo,
251+
SourceRange Range, SourceRange DirectInitRange) {
253252
bool IsArray = ArraySize.has_value();
254253
bool HasInit = Initializer != nullptr;
255254
unsigned NumPlacementArgs = PlacementArgs.size();

‎clang/lib/AST/ItaniumMangle.cpp

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -4826,7 +4826,7 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity,
48264826
Out << '_';
48274827
mangleType(New->getAllocatedType());
48284828
if (New->hasInitializer()) {
4829-
if (New->getInitializationStyle() == CXXNewInitializationStyle::List)
4829+
if (New->getInitializationStyle() == CXXNewExpr::ListInit)
48304830
Out << "il";
48314831
else
48324832
Out << "pi";
@@ -4840,8 +4840,7 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity,
48404840
} else if (const ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init)) {
48414841
for (unsigned i = 0, e = PLE->getNumExprs(); i != e; ++i)
48424842
mangleExpression(PLE->getExpr(i));
4843-
} else if (New->getInitializationStyle() ==
4844-
CXXNewInitializationStyle::List &&
4843+
} else if (New->getInitializationStyle() == CXXNewExpr::ListInit &&
48454844
isa<InitListExpr>(Init)) {
48464845
// Only take InitListExprs apart for list-initialization.
48474846
mangleInitListElements(cast<InitListExpr>(Init));

‎clang/lib/AST/JSONNodeDumper.cpp

Lines changed: 3 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1351,15 +1351,9 @@ void JSONNodeDumper::VisitCXXNewExpr(const CXXNewExpr *NE) {
13511351
attributeOnlyIfTrue("isArray", NE->isArray());
13521352
attributeOnlyIfTrue("isPlacement", NE->getNumPlacementArgs() != 0);
13531353
switch (NE->getInitializationStyle()) {
1354-
case CXXNewInitializationStyle::None:
1355-
case CXXNewInitializationStyle::Implicit:
1356-
break;
1357-
case CXXNewInitializationStyle::Call:
1358-
JOS.attribute("initStyle", "call");
1359-
break;
1360-
case CXXNewInitializationStyle::List:
1361-
JOS.attribute("initStyle", "list");
1362-
break;
1354+
case CXXNewExpr::NoInit: break;
1355+
case CXXNewExpr::CallInit: JOS.attribute("initStyle", "call"); break;
1356+
case CXXNewExpr::ListInit: JOS.attribute("initStyle", "list"); break;
13631357
}
13641358
if (const FunctionDecl *FD = NE->getOperatorNew())
13651359
JOS.attribute("operatorNewDecl", createBareDeclRef(FD));

‎clang/lib/AST/StmtPrinter.cpp

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2298,10 +2298,9 @@ void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
22982298
if (E->isParenTypeId())
22992299
OS << ")";
23002300

2301-
CXXNewInitializationStyle InitStyle = E->getInitializationStyle();
2302-
if (InitStyle != CXXNewInitializationStyle::None &&
2303-
InitStyle != CXXNewInitializationStyle::Implicit) {
2304-
bool Bare = InitStyle == CXXNewInitializationStyle::Call &&
2301+
CXXNewExpr::InitializationStyle InitStyle = E->getInitializationStyle();
2302+
if (InitStyle != CXXNewExpr::NoInit) {
2303+
bool Bare = InitStyle == CXXNewExpr::CallInit &&
23052304
!isa<ParenListExpr>(E->getInitializer());
23062305
if (Bare)
23072306
OS << "(";

‎clang/lib/AST/StmtProfile.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2096,7 +2096,7 @@ void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) {
20962096
ID.AddInteger(S->getNumPlacementArgs());
20972097
ID.AddBoolean(S->isGlobalNew());
20982098
ID.AddBoolean(S->isParenTypeId());
2099-
ID.AddInteger(llvm::to_underlying(S->getInitializationStyle()));
2099+
ID.AddInteger(S->getInitializationStyle());
21002100
}
21012101

21022102
void

‎clang/lib/Sema/SemaExprCXX.cpp

Lines changed: 27 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -1946,7 +1946,7 @@ Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
19461946
Initializer);
19471947
}
19481948

1949-
static bool isLegalArrayNewInitializer(CXXNewInitializationStyle Style,
1949+
static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style,
19501950
Expr *Init) {
19511951
if (!Init)
19521952
return true;
@@ -1957,7 +1957,7 @@ static bool isLegalArrayNewInitializer(CXXNewInitializationStyle Style,
19571957
else if (CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init))
19581958
return !CCE->isListInitialization() &&
19591959
CCE->getConstructor()->isDefaultConstructor();
1960-
else if (Style == CXXNewInitializationStyle::List) {
1960+
else if (Style == CXXNewExpr::ListInit) {
19611961
assert(isa<InitListExpr>(Init) &&
19621962
"Shouldn't create list CXXConstructExprs for arrays.");
19631963
return true;
@@ -2008,49 +2008,44 @@ ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
20082008
SourceRange TypeRange = AllocTypeInfo->getTypeLoc().getSourceRange();
20092009
SourceLocation StartLoc = Range.getBegin();
20102010

2011-
CXXNewInitializationStyle InitStyle;
2011+
CXXNewExpr::InitializationStyle initStyle;
20122012
if (DirectInitRange.isValid()) {
20132013
assert(Initializer && "Have parens but no initializer.");
2014-
InitStyle = CXXNewInitializationStyle::Call;
2014+
initStyle = CXXNewExpr::CallInit;
20152015
} else if (Initializer && isa<InitListExpr>(Initializer))
2016-
InitStyle = CXXNewInitializationStyle::List;
2016+
initStyle = CXXNewExpr::ListInit;
20172017
else {
20182018
assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||
20192019
isa<CXXConstructExpr>(Initializer)) &&
20202020
"Initializer expression that cannot have been implicitly created.");
2021-
InitStyle = CXXNewInitializationStyle::None;
2021+
initStyle = CXXNewExpr::NoInit;
20222022
}
20232023

20242024
MultiExprArg Exprs(&Initializer, Initializer ? 1 : 0);
20252025
if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) {
2026-
assert(InitStyle == CXXNewInitializationStyle::Call &&
2027-
"paren init for non-call init");
2026+
assert(initStyle == CXXNewExpr::CallInit && "paren init for non-call init");
20282027
Exprs = MultiExprArg(List->getExprs(), List->getNumExprs());
20292028
}
20302029

20312030
// C++11 [expr.new]p15:
20322031
// A new-expression that creates an object of type T initializes that
20332032
// object as follows:
2034-
InitializationKind Kind = [&] {
2035-
switch (InitStyle) {
2036-
// - If the new-initializer is omitted, the object is default-
2037-
// initialized (8.5); if no initialization is performed,
2038-
// the object has indeterminate value
2039-
case CXXNewInitializationStyle::None:
2040-
case CXXNewInitializationStyle::Implicit:
2041-
return InitializationKind::CreateDefault(TypeRange.getBegin());
2042-
// - Otherwise, the new-initializer is interpreted according to the
2043-
// initialization rules of 8.5 for direct-initialization.
2044-
case CXXNewInitializationStyle::Call:
2045-
return InitializationKind::CreateDirect(TypeRange.getBegin(),
2046-
DirectInitRange.getBegin(),
2047-
DirectInitRange.getEnd());
2048-
case CXXNewInitializationStyle::List:
2049-
return InitializationKind::CreateDirectList(TypeRange.getBegin(),
2050-
Initializer->getBeginLoc(),
2051-
Initializer->getEndLoc());
2052-
}
2053-
}();
2033+
InitializationKind Kind
2034+
// - If the new-initializer is omitted, the object is default-
2035+
// initialized (8.5); if no initialization is performed,
2036+
// the object has indeterminate value
2037+
= initStyle == CXXNewExpr::NoInit
2038+
? InitializationKind::CreateDefault(TypeRange.getBegin())
2039+
// - Otherwise, the new-initializer is interpreted according to
2040+
// the
2041+
// initialization rules of 8.5 for direct-initialization.
2042+
: initStyle == CXXNewExpr::ListInit
2043+
? InitializationKind::CreateDirectList(
2044+
TypeRange.getBegin(), Initializer->getBeginLoc(),
2045+
Initializer->getEndLoc())
2046+
: InitializationKind::CreateDirect(TypeRange.getBegin(),
2047+
DirectInitRange.getBegin(),
2048+
DirectInitRange.getEnd());
20542049

20552050
// C++11 [dcl.spec.auto]p6. Deduce the type which 'auto' stands in for.
20562051
auto *Deduced = AllocType->getContainedDeducedType();
@@ -2071,14 +2066,13 @@ ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
20712066
return ExprError();
20722067
} else if (Deduced && !Deduced->isDeduced()) {
20732068
MultiExprArg Inits = Exprs;
2074-
bool Braced = (InitStyle == CXXNewInitializationStyle::List);
2069+
bool Braced = (initStyle == CXXNewExpr::ListInit);
20752070
if (Braced) {
20762071
auto *ILE = cast<InitListExpr>(Exprs[0]);
20772072
Inits = MultiExprArg(ILE->getInits(), ILE->getNumInits());
20782073
}
20792074

2080-
if (InitStyle == CXXNewInitializationStyle::None ||
2081-
InitStyle == CXXNewInitializationStyle::Implicit || Inits.empty())
2075+
if (initStyle == CXXNewExpr::NoInit || Inits.empty())
20822076
return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
20832077
<< AllocType << TypeRange);
20842078
if (Inits.size() > 1) {
@@ -2402,7 +2396,7 @@ ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
24022396
// Array 'new' can't have any initializers except empty parentheses.
24032397
// Initializer lists are also allowed, in C++11. Rely on the parser for the
24042398
// dialect distinction.
2405-
if (ArraySize && !isLegalArrayNewInitializer(InitStyle, Initializer)) {
2399+
if (ArraySize && !isLegalArrayNewInitializer(initStyle, Initializer)) {
24062400
SourceRange InitRange(Exprs.front()->getBeginLoc(),
24072401
Exprs.back()->getEndLoc());
24082402
Diag(StartLoc, diag::err_new_array_init_args) << InitRange;
@@ -2474,7 +2468,7 @@ ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
24742468

24752469
return CXXNewExpr::Create(Context, UseGlobal, OperatorNew, OperatorDelete,
24762470
PassAlignment, UsualArrayDeleteWantsSize,
2477-
PlacementArgs, TypeIdParens, ArraySize, InitStyle,
2471+
PlacementArgs, TypeIdParens, ArraySize, initStyle,
24782472
Initializer, ResultType, AllocTypeInfo, Range,
24792473
DirectInitRange);
24802474
}

0 commit comments

Comments
 (0)