Skip to content

Commit dc87d21

Browse files
EndilllEndilll
committed
[clang][NFC] Convert Parser::TypeCastState to scoped enum
1 parent 23c3c4e commit dc87d21

File tree

5 files changed

+47
-46
lines changed

5 files changed

+47
-46
lines changed

‎clang/include/clang/Parse/Parser.h‎

Lines changed: 13 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -101,6 +101,9 @@ enum class ObjCTypeQual {
101101
NumQuals
102102
};
103103

104+
/// TypeCastState - State whether an expression is or may be a type cast.
105+
enum class TypeCastState { NotTypeCast = 0, MaybeTypeCast, IsTypeCast };
106+
104107
/// Parser - This implements a parser for the C family of languages. After
105108
/// parsing units of the grammar, productions are invoked to handle whatever has
106109
/// been read.
@@ -1854,16 +1857,10 @@ class Parser : public CodeCompletionHandler {
18541857
//===--------------------------------------------------------------------===//
18551858
// C99 6.5: Expressions.
18561859

1857-
/// TypeCastState - State whether an expression is or may be a type cast.
1858-
enum TypeCastState {
1859-
NotTypeCast = 0,
1860-
MaybeTypeCast,
1861-
IsTypeCast
1862-
};
1863-
1864-
ExprResult ParseExpression(TypeCastState isTypeCast = NotTypeCast);
1860+
ExprResult
1861+
ParseExpression(TypeCastState isTypeCast = TypeCastState::NotTypeCast);
18651862
ExprResult ParseConstantExpressionInExprEvalContext(
1866-
TypeCastState isTypeCast = NotTypeCast);
1863+
TypeCastState isTypeCast = TypeCastState::NotTypeCast);
18671864
ExprResult ParseConstantExpression();
18681865
ExprResult ParseArrayBoundExpression();
18691866
ExprResult ParseCaseExpression(SourceLocation CaseLoc);
@@ -1872,7 +1869,8 @@ class Parser : public CodeCompletionHandler {
18721869
ParseConstraintLogicalAndExpression(bool IsTrailingRequiresClause);
18731870
ExprResult ParseConstraintLogicalOrExpression(bool IsTrailingRequiresClause);
18741871
// Expr that doesn't include commas.
1875-
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast = NotTypeCast);
1872+
ExprResult ParseAssignmentExpression(
1873+
TypeCastState isTypeCast = TypeCastState::NotTypeCast);
18761874
ExprResult ParseConditionalExpression();
18771875

18781876
ExprResult ParseMSAsmIdentifier(llvm::SmallVectorImpl<Token> &LineToks,
@@ -1908,11 +1906,11 @@ class Parser : public CodeCompletionHandler {
19081906
TypeCastState isTypeCast,
19091907
bool isVectorLiteral = false,
19101908
bool *NotPrimaryExpression = nullptr);
1911-
ExprResult ParseCastExpression(CastParseKind ParseKind,
1912-
bool isAddressOfOperand = false,
1913-
TypeCastState isTypeCast = NotTypeCast,
1914-
bool isVectorLiteral = false,
1915-
bool *NotPrimaryExpression = nullptr);
1909+
ExprResult
1910+
ParseCastExpression(CastParseKind ParseKind, bool isAddressOfOperand = false,
1911+
TypeCastState isTypeCast = TypeCastState::NotTypeCast,
1912+
bool isVectorLiteral = false,
1913+
bool *NotPrimaryExpression = nullptr);
19161914

19171915
/// Returns true if the next token cannot start an expression.
19181916
bool isNotExpressionStart();

‎clang/lib/Parse/ParseExpr.cpp‎

Lines changed: 26 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -196,7 +196,7 @@ ExprResult Parser::ParseConditionalExpression() {
196196
}
197197

198198
ExprResult LHS = ParseCastExpression(
199-
AnyCastExpr, /*isAddressOfOperand=*/false, NotTypeCast);
199+
AnyCastExpr, /*isAddressOfOperand=*/false, TypeCastState::NotTypeCast);
200200
return ParseRHSOfBinaryExpression(LHS, prec::Conditional);
201201
}
202202

@@ -239,7 +239,7 @@ ExprResult Parser::ParseConstantExpression() {
239239
// C++98 and C++11 have no such rule, but this is only a defect in C++98.
240240
EnterExpressionEvaluationContext ConstantEvaluated(
241241
Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
242-
return ParseConstantExpressionInExprEvalContext(NotTypeCast);
242+
return ParseConstantExpressionInExprEvalContext(TypeCastState::NotTypeCast);
243243
}
244244

245245
ExprResult Parser::ParseArrayBoundExpression() {
@@ -267,13 +267,14 @@ ExprResult Parser::ParseArrayBoundExpression() {
267267
break;
268268
Iter->InConditionallyConstantEvaluateContext = true;
269269
}
270-
return ParseConstantExpressionInExprEvalContext(NotTypeCast);
270+
return ParseConstantExpressionInExprEvalContext(TypeCastState::NotTypeCast);
271271
}
272272

273273
ExprResult Parser::ParseCaseExpression(SourceLocation CaseLoc) {
274274
EnterExpressionEvaluationContext ConstantEvaluated(
275275
Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
276-
ExprResult LHS(ParseCastExpression(AnyCastExpr, false, NotTypeCast));
276+
ExprResult LHS(
277+
ParseCastExpression(AnyCastExpr, false, TypeCastState::NotTypeCast));
277278
ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
278279
return Actions.ActOnCaseExpr(CaseLoc, Res);
279280
}
@@ -310,12 +311,12 @@ Parser::ParseConstraintLogicalAndExpression(bool IsTrailingRequiresClause) {
310311
EnterExpressionEvaluationContext ConstantEvaluated(
311312
Actions, Sema::ExpressionEvaluationContext::Unevaluated);
312313
bool NotPrimaryExpression = false;
313-
auto ParsePrimary = [&] () {
314-
ExprResult E = ParseCastExpression(PrimaryExprOnly,
315-
/*isAddressOfOperand=*/false,
316-
/*isTypeCast=*/NotTypeCast,
317-
/*isVectorLiteral=*/false,
318-
&NotPrimaryExpression);
314+
auto ParsePrimary = [&]() {
315+
ExprResult E =
316+
ParseCastExpression(PrimaryExprOnly,
317+
/*isAddressOfOperand=*/false,
318+
/*isTypeCast=*/TypeCastState::NotTypeCast,
319+
/*isVectorLiteral=*/false, &NotPrimaryExpression);
319320
if (E.isInvalid())
320321
return ExprError();
321322
auto RecoverFromNonPrimary = [&] (ExprResult E, bool Note) {
@@ -1107,8 +1108,9 @@ ExprResult Parser::ParseCastExpression(CastParseKind ParseKind,
11071108
}
11081109
ParsedType CastTy;
11091110
SourceLocation RParenLoc;
1110-
Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/,
1111-
isTypeCast == IsTypeCast, CastTy, RParenLoc);
1111+
Res = ParseParenExpression(ParenExprType, false /*stopIfCastExr*/,
1112+
isTypeCast == TypeCastState::IsTypeCast, CastTy,
1113+
RParenLoc);
11121114

11131115
// FIXME: What should we do if a vector literal is followed by a
11141116
// postfix-expression suffix? Usually postfix operators are permitted on
@@ -1347,8 +1349,8 @@ ExprResult Parser::ParseCastExpression(CastParseKind ParseKind,
13471349
Token Replacement;
13481350
CastExpressionIdValidator Validator(
13491351
/*Next=*/Tok,
1350-
/*AllowTypes=*/isTypeCast != NotTypeCast,
1351-
/*AllowNonTypes=*/isTypeCast != IsTypeCast);
1352+
/*AllowTypes=*/isTypeCast != TypeCastState::NotTypeCast,
1353+
/*AllowNonTypes=*/isTypeCast != TypeCastState::IsTypeCast);
13521354
Validator.IsAddressOfOperand = isAddressOfOperand;
13531355
if (Tok.isOneOf(tok::periodstar, tok::arrowstar)) {
13541356
Validator.WantExpressionKeywords = false;
@@ -1449,10 +1451,9 @@ ExprResult Parser::ParseCastExpression(CastParseKind ParseKind,
14491451
// One special case is implicitly handled here: if the preceding tokens are
14501452
// an ambiguous cast expression, such as "(T())++", then we recurse to
14511453
// determine whether the '++' is prefix or postfix.
1452-
Res = ParseCastExpression(getLangOpts().CPlusPlus ?
1453-
UnaryExprOnly : AnyCastExpr,
1454-
/*isAddressOfOperand*/false, NotCastExpr,
1455-
NotTypeCast);
1454+
Res = ParseCastExpression(
1455+
getLangOpts().CPlusPlus ? UnaryExprOnly : AnyCastExpr,
1456+
/*isAddressOfOperand*/ false, NotCastExpr, TypeCastState::NotTypeCast);
14561457
if (NotCastExpr) {
14571458
// If we return with NotCastExpr = true, we must not consume any tokens,
14581459
// so put the token back where we found it.
@@ -3258,10 +3259,11 @@ Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
32583259
// Parse the cast-expression that follows it next.
32593260
// isVectorLiteral = true will make sure we don't parse any
32603261
// Postfix expression yet
3261-
Result = ParseCastExpression(/*isUnaryExpression=*/AnyCastExpr,
3262-
/*isAddressOfOperand=*/false,
3263-
/*isTypeCast=*/IsTypeCast,
3264-
/*isVectorLiteral=*/true);
3262+
Result =
3263+
ParseCastExpression(/*isUnaryExpression=*/AnyCastExpr,
3264+
/*isAddressOfOperand=*/false,
3265+
/*isTypeCast=*/TypeCastState::IsTypeCast,
3266+
/*isVectorLiteral=*/true);
32653267

32663268
if (!Result.isInvalid()) {
32673269
Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc,
@@ -3312,7 +3314,7 @@ Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
33123314
// TODO: For cast expression with CastTy.
33133315
Result = ParseCastExpression(/*isUnaryExpression=*/AnyCastExpr,
33143316
/*isAddressOfOperand=*/false,
3315-
/*isTypeCast=*/IsTypeCast);
3317+
/*isTypeCast=*/TypeCastState::IsTypeCast);
33163318
if (!Result.isInvalid()) {
33173319
Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc,
33183320
DeclaratorInfo, CastTy,
@@ -3381,7 +3383,7 @@ Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
33813383
} else {
33823384
InMessageExpressionRAIIObject InMessage(*this, false);
33833385

3384-
Result = ParseExpression(MaybeTypeCast);
3386+
Result = ParseExpression(TypeCastState::MaybeTypeCast);
33853387
if (!getLangOpts().CPlusPlus && Result.isUsable()) {
33863388
// Correct typos in non-C++ code earlier so that implicit-cast-like
33873389
// expressions are parsed correctly.

‎clang/lib/Parse/ParseExprCXX.cpp‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -4132,11 +4132,10 @@ Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
41324132
// If it is not a cast-expression, NotCastExpr will be true and no token
41334133
// will be consumed.
41344134
ColonProt.restore();
4135-
Result = ParseCastExpression(AnyCastExpr,
4136-
false/*isAddressofOperand*/,
4135+
Result = ParseCastExpression(AnyCastExpr, false /*isAddressofOperand*/,
41374136
NotCastExpr,
41384137
// type-id has priority.
4139-
IsTypeCast);
4138+
TypeCastState::IsTypeCast);
41404139
}
41414140

41424141
// If we parsed a cast-expression, it's really a type-id, otherwise it's

‎clang/lib/Parse/ParseOpenMP.cpp‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3552,8 +3552,8 @@ ExprResult Parser::ParseOpenMPParensExpr(StringRef ClauseName,
35523552
return ExprError();
35533553

35543554
SourceLocation ELoc = Tok.getLocation();
3555-
ExprResult LHS(
3556-
ParseCastExpression(AnyCastExpr, IsAddressOfOperand, NotTypeCast));
3555+
ExprResult LHS(ParseCastExpression(AnyCastExpr, IsAddressOfOperand,
3556+
TypeCastState::NotTypeCast));
35573557
ExprResult Val(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
35583558
Val = Actions.ActOnFinishFullExpr(Val.get(), ELoc, /*DiscardedValue*/ false);
35593559

@@ -4188,7 +4188,8 @@ OMPClause *Parser::ParseOpenMPSingleExprWithArgClause(OpenMPDirectiveKind DKind,
41884188
Kind == OMPC_grainsize || Kind == OMPC_num_tasks;
41894189
if (NeedAnExpression) {
41904190
SourceLocation ELoc = Tok.getLocation();
4191-
ExprResult LHS(ParseCastExpression(AnyCastExpr, false, NotTypeCast));
4191+
ExprResult LHS(
4192+
ParseCastExpression(AnyCastExpr, false, TypeCastState::NotTypeCast));
41924193
Val = ParseRHSOfBinaryExpression(LHS, prec::Conditional);
41934194
Val =
41944195
Actions.ActOnFinishFullExpr(Val.get(), ELoc, /*DiscardedValue*/ false);

‎clang/lib/Parse/ParseTemplate.cpp‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1533,7 +1533,8 @@ ParsedTemplateArgument Parser::ParseTemplateArgument() {
15331533
if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))
15341534
ExprArg = ParseBraceInitializer();
15351535
else
1536-
ExprArg = ParseConstantExpressionInExprEvalContext(MaybeTypeCast);
1536+
ExprArg =
1537+
ParseConstantExpressionInExprEvalContext(TypeCastState::MaybeTypeCast);
15371538
if (ExprArg.isInvalid() || !ExprArg.get()) {
15381539
return ParsedTemplateArgument();
15391540
}

0 commit comments

Comments
 (0)