Consistently use smart pointers for stmt and expr nodes in parser local variables.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@60761 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
index e31c7a5..dca12e6 100644
--- a/lib/Parse/ParseExpr.cpp
+++ b/lib/Parse/ParseExpr.cpp
@@ -173,10 +173,10 @@
if (Tok.is(tok::kw_throw))
return ParseThrowExpression();
- ExprResult LHS = ParseCastExpression(false);
- if (LHS.isInvalid) return LHS;
+ ExprOwner LHS(Actions, ParseCastExpression(false));
+ if (LHS.isInvalid()) return LHS.move();
- return ParseRHSOfBinaryExpression(LHS, prec::Comma);
+ return ParseRHSOfBinaryExpression(LHS.move(), prec::Comma);
}
/// This routine is called when the '@' is seen and consumed.
@@ -185,10 +185,10 @@
/// for example, @encode-expression.
///
Parser::ExprResult Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) {
- ExprResult LHS = ParseObjCAtExpression(AtLoc);
- if (LHS.isInvalid) return LHS;
-
- return ParseRHSOfBinaryExpression(LHS, prec::Comma);
+ ExprOwner LHS(Actions, ParseObjCAtExpression(AtLoc));
+ if (LHS.isInvalid()) return LHS.move();
+
+ return ParseRHSOfBinaryExpression(LHS.move(), prec::Comma);
}
/// ParseAssignmentExpression - Parse an expr that doesn't include commas.
@@ -197,10 +197,10 @@
if (Tok.is(tok::kw_throw))
return ParseThrowExpression();
- ExprResult LHS = ParseCastExpression(false);
- if (LHS.isInvalid) return LHS;
+ ExprOwner LHS(Actions, ParseCastExpression(false));
+ if (LHS.isInvalid()) return LHS.move();
- return ParseRHSOfBinaryExpression(LHS, prec::Assignment);
+ return ParseRHSOfBinaryExpression(LHS.move(), prec::Assignment);
}
/// ParseAssignmentExprWithObjCMessageExprStart - Parse an assignment expression
@@ -216,46 +216,44 @@
SourceLocation NameLoc,
IdentifierInfo *ReceiverName,
ExprTy *ReceiverExpr) {
- ExprResult R = ParseObjCMessageExpressionBody(LBracLoc, NameLoc, ReceiverName,
- ReceiverExpr);
- if (R.isInvalid) return R;
- R = ParsePostfixExpressionSuffix(R);
- if (R.isInvalid) return R;
- return ParseRHSOfBinaryExpression(R, 2);
+ ExprOwner R(Actions, ParseObjCMessageExpressionBody(LBracLoc, NameLoc,
+ ReceiverName,
+ ReceiverExpr));
+ if (R.isInvalid()) return R.move();
+ R = ParsePostfixExpressionSuffix(R.move());
+ if (R.isInvalid()) return R.move();
+ return ParseRHSOfBinaryExpression(R.move(), 2);
}
Parser::ExprResult Parser::ParseConstantExpression() {
- ExprResult LHS = ParseCastExpression(false);
- if (LHS.isInvalid) return LHS;
+ ExprOwner LHS(Actions, ParseCastExpression(false));
+ if (LHS.isInvalid()) return LHS.move();
- return ParseRHSOfBinaryExpression(LHS, prec::Conditional);
+ return ParseRHSOfBinaryExpression(LHS.move(), prec::Conditional);
}
/// ParseRHSOfBinaryExpression - Parse a binary expression that starts with
/// LHS and has a precedence of at least MinPrec.
Parser::ExprResult
-Parser::ParseRHSOfBinaryExpression(ExprResult LHS, unsigned MinPrec) {
+Parser::ParseRHSOfBinaryExpression(ExprResult LHSArg, unsigned MinPrec) {
unsigned NextTokPrec = getBinOpPrecedence(Tok.getKind());
SourceLocation ColonLoc;
- ExprGuard LHSGuard(Actions, LHS);
+ ExprOwner LHS(Actions, LHSArg);
while (1) {
// If this token has a lower precedence than we are allowed to parse (e.g.
// because we are called recursively, or because the token is not a binop),
// then we are done!
- if (NextTokPrec < MinPrec) {
- LHSGuard.take();
- return LHS;
- }
+ if (NextTokPrec < MinPrec)
+ return LHS.move();
// Consume the operator, saving the operator token for error reporting.
Token OpToken = Tok;
ConsumeToken();
// Special case handling for the ternary operator.
- ExprResult TernaryMiddle(true);
- ExprGuard MiddleGuard(Actions);
+ ExprOwner TernaryMiddle(Actions, true);
if (NextTokPrec == prec::Conditional) {
if (Tok.isNot(tok::colon)) {
// Handle this production specially:
@@ -263,17 +261,15 @@
// In particular, the RHS of the '?' is 'expression', not
// 'logical-OR-expression' as we might expect.
TernaryMiddle = ParseExpression();
- if (TernaryMiddle.isInvalid) {
- return TernaryMiddle;
- }
+ if (TernaryMiddle.isInvalid())
+ return TernaryMiddle.move();
} else {
// Special case handling of "X ? Y : Z" where Y is empty:
// logical-OR-expression '?' ':' conditional-expression [GNU]
- TernaryMiddle = ExprResult(false);
+ TernaryMiddle.reset();
Diag(Tok, diag::ext_gnu_conditional_expr);
}
- MiddleGuard.reset(TernaryMiddle);
-
+
if (Tok.isNot(tok::colon)) {
Diag(Tok, diag::err_expected_colon);
Diag(OpToken, diag::note_matching) << "?";
@@ -285,11 +281,9 @@
}
// Parse another leaf here for the RHS of the operator.
- ExprResult RHS = ParseCastExpression(false);
- if (RHS.isInvalid) {
- return RHS;
- }
- ExprGuard RHSGuard(Actions, RHS);
+ ExprOwner RHS(Actions, ParseCastExpression(false));
+ if (RHS.isInvalid())
+ return RHS.move();
// Remember the precedence of this operator and get the precedence of the
// operator immediately to the right of the RHS.
@@ -309,31 +303,24 @@
// is okay, to bind exactly as tightly. For example, compile A=B=C=D as
// A=(B=(C=D)), where each paren is a level of recursion here.
// The function takes ownership of the RHS.
- RHSGuard.take();
- RHS = ParseRHSOfBinaryExpression(RHS, ThisPrec + !isRightAssoc);
- if (RHS.isInvalid) {
- return RHS;
- }
- RHSGuard.reset(RHS);
+ RHS = ParseRHSOfBinaryExpression(RHS.move(), ThisPrec + !isRightAssoc);
+ if (RHS.isInvalid())
+ return RHS.move();
NextTokPrec = getBinOpPrecedence(Tok.getKind());
}
assert(NextTokPrec <= ThisPrec && "Recursion didn't work!");
- if (!LHS.isInvalid) {
+ if (!LHS.isInvalid()) {
// Combine the LHS and RHS into the LHS (e.g. build AST).
- LHSGuard.take();
- MiddleGuard.take();
- RHSGuard.take();
- if (TernaryMiddle.isInvalid)
+ if (TernaryMiddle.isInvalid())
LHS = Actions.ActOnBinOp(CurScope, OpToken.getLocation(),
- OpToken.getKind(), LHS.Val, RHS.Val);
+ OpToken.getKind(), LHS.move(), RHS.move());
else
LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc,
- LHS.Val, TernaryMiddle.Val, RHS.Val);
- LHSGuard.reset(LHS);
+ LHS.move(), TernaryMiddle.move(),
+ RHS.move());
}
- // If we had an invalid LHS, Middle and RHS will be freed by the guards here
}
}
@@ -433,7 +420,7 @@
TryAnnotateTypeOrScopeToken();
}
- ExprResult Res;
+ ExprOwner Res(Actions);
tok::TokenKind SavedKind = Tok.getKind();
// This handles all of cast-expression, unary-expression, postfix-expression,
@@ -456,7 +443,7 @@
SourceLocation LParenLoc = Tok.getLocation();
SourceLocation RParenLoc;
Res = ParseParenExpression(ParenExprType, CastTy, RParenLoc);
- if (Res.isInvalid) return Res;
+ if (Res.isInvalid()) return Res.move();
switch (ParenExprType) {
case SimpleExpr: break; // Nothing else to do.
@@ -470,15 +457,15 @@
// the cast-expression that follows it next.
// TODO: For cast expression with CastTy.
Res = ParseCastExpression(false);
- if (!Res.isInvalid)
- Res = Actions.ActOnCastExpr(LParenLoc, CastTy, RParenLoc, Res.Val);
- return Res;
+ if (!Res.isInvalid())
+ Res = Actions.ActOnCastExpr(LParenLoc, CastTy, RParenLoc, Res.move());
+ return Res.move();
}
-
+
// These can be followed by postfix-expr pieces.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
}
-
+
// primary-expression
case tok::numeric_constant:
// constant: integer-constant
@@ -488,7 +475,7 @@
ConsumeToken();
// These can be followed by postfix-expr pieces.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
case tok::kw_true:
case tok::kw_false:
@@ -506,26 +493,26 @@
SourceLocation L = ConsumeToken();
Res = Actions.ActOnIdentifierExpr(CurScope, L, II, Tok.is(tok::l_paren));
// These can be followed by postfix-expr pieces.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
}
case tok::char_constant: // constant: character-constant
Res = Actions.ActOnCharacterConstant(Tok);
ConsumeToken();
// These can be followed by postfix-expr pieces.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
case tok::kw___func__: // primary-expression: __func__ [C99 6.4.2.2]
case tok::kw___FUNCTION__: // primary-expression: __FUNCTION__ [GNU]
case tok::kw___PRETTY_FUNCTION__: // primary-expression: __P..Y_F..N__ [GNU]
Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind);
ConsumeToken();
// These can be followed by postfix-expr pieces.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
case tok::string_literal: // primary-expression: string-literal
case tok::wide_string_literal:
Res = ParseStringLiteralExpression();
- if (Res.isInvalid) return Res;
+ if (Res.isInvalid()) return Res.move();
// This can be followed by postfix-expr pieces (e.g. "foo"[1]).
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
case tok::kw___builtin_va_arg:
case tok::kw___builtin_offsetof:
case tok::kw___builtin_choose_expr:
@@ -539,9 +526,9 @@
case tok::minusminus: { // unary-expression: '--' unary-expression
SourceLocation SavedLoc = ConsumeToken();
Res = ParseCastExpression(true);
- if (!Res.isInvalid)
- Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.Val);
- return Res;
+ if (!Res.isInvalid())
+ Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.move());
+ return Res.move();
}
case tok::amp: // unary-expression: '&' cast-expression
case tok::star: // unary-expression: '*' cast-expression
@@ -553,19 +540,19 @@
case tok::kw___imag: { // unary-expression: '__imag' cast-expression [GNU]
SourceLocation SavedLoc = ConsumeToken();
Res = ParseCastExpression(false);
- if (!Res.isInvalid)
- Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.Val);
- return Res;
- }
-
+ if (!Res.isInvalid())
+ Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.move());
+ return Res.move();
+ }
+
case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU]
// __extension__ silences extension warnings in the subexpression.
ExtensionRAIIObject O(Diags); // Use RAII to do this.
SourceLocation SavedLoc = ConsumeToken();
Res = ParseCastExpression(false);
- if (!Res.isInvalid)
- Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.Val);
- return Res;
+ if (!Res.isInvalid())
+ Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.move());
+ return Res.move();
}
case tok::kw_sizeof: // unary-expression: 'sizeof' unary-expression
// unary-expression: 'sizeof' '(' type-name ')'
@@ -585,7 +572,7 @@
Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(),
Tok.getIdentifierInfo());
ConsumeToken();
- return Res;
+ return Res.move();
}
case tok::kw_const_cast:
case tok::kw_dynamic_cast:
@@ -593,15 +580,15 @@
case tok::kw_static_cast:
Res = ParseCXXCasts();
// These can be followed by postfix-expr pieces.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
case tok::kw_typeid:
Res = ParseCXXTypeid();
// This can be followed by postfix-expr pieces.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
case tok::kw_this:
Res = ParseCXXThis();
// This can be followed by postfix-expr pieces.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
case tok::kw_char:
case tok::kw_wchar_t:
@@ -629,14 +616,14 @@
Res = ParseCXXTypeConstructExpression(DS);
// This can be followed by postfix-expr pieces.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
}
case tok::annot_cxxscope: // [C++] id-expression: qualified-id
case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id
// template-id
Res = ParseCXXIdExpression();
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
case tok::coloncolon: // [C++] new-expression or [C++] delete-expression
// If the next token is neither 'new' nor 'delete', the :: would have been
@@ -694,35 +681,32 @@
/// argument-expression
/// argument-expression-list ',' assignment-expression
///
-Parser::ExprResult Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {
- ExprGuard LHSGuard(Actions, LHS);
+Parser::ExprResult Parser::ParsePostfixExpressionSuffix(ExprResult LHSArg) {
+ ExprOwner LHS(Actions, LHSArg);
// Now that the primary-expression piece of the postfix-expression has been
// parsed, see if there are any postfix-expression pieces here.
SourceLocation Loc;
while (1) {
switch (Tok.getKind()) {
default: // Not a postfix-expression suffix.
- LHSGuard.take();
- return LHS;
+ return LHS.move();
case tok::l_square: { // postfix-expression: p-e '[' expression ']'
Loc = ConsumeBracket();
- ExprResult Idx = ParseExpression();
- ExprGuard IdxGuard(Actions, Idx);
+ ExprOwner Idx(Actions, ParseExpression());
SourceLocation RLoc = Tok.getLocation();
-
- if (!LHS.isInvalid && !Idx.isInvalid && Tok.is(tok::r_square)) {
- LHS = Actions.ActOnArraySubscriptExpr(CurScope, LHSGuard.take(), Loc,
- IdxGuard.take(), RLoc);
- LHSGuard.reset(LHS);
- } else
+
+ if (!LHS.isInvalid() && !Idx.isInvalid() && Tok.is(tok::r_square)) {
+ LHS = Actions.ActOnArraySubscriptExpr(CurScope, LHS.move(), Loc,
+ Idx.move(), RLoc);
+ } else
LHS = ExprResult(true);
// Match the ']'.
MatchRHSPunctuation(tok::r_square, Loc);
break;
}
-
+
case tok::l_paren: { // p-e: p-e '(' argument-expression-list[opt] ')'
ExprVector ArgExprs(Actions);
CommaLocsTy CommaLocs;
@@ -737,14 +721,13 @@
}
// Match the ')'.
- if (!LHS.isInvalid && Tok.is(tok::r_paren)) {
+ if (!LHS.isInvalid() && Tok.is(tok::r_paren)) {
assert((ArgExprs.size() == 0 || ArgExprs.size()-1 == CommaLocs.size())&&
"Unexpected number of commas!");
- LHS = Actions.ActOnCallExpr(CurScope, LHSGuard.take(), Loc,
+ LHS = Actions.ActOnCallExpr(CurScope, LHS.move(), Loc,
ArgExprs.take(),
ArgExprs.size(), &CommaLocs[0],
Tok.getLocation());
- LHSGuard.reset(LHS);
}
MatchRHSPunctuation(tok::r_paren, Loc);
@@ -760,21 +743,19 @@
return ExprResult(true);
}
- if (!LHS.isInvalid) {
- LHS = Actions.ActOnMemberReferenceExpr(LHSGuard.take(), OpLoc, OpKind,
+ if (!LHS.isInvalid()) {
+ LHS = Actions.ActOnMemberReferenceExpr(LHS.move(), OpLoc, OpKind,
Tok.getLocation(),
*Tok.getIdentifierInfo());
- LHSGuard.reset(LHS);
}
ConsumeToken();
break;
}
case tok::plusplus: // postfix-expression: postfix-expression '++'
case tok::minusminus: // postfix-expression: postfix-expression '--'
- if (!LHS.isInvalid) {
+ if (!LHS.isInvalid()) {
LHS = Actions.ActOnPostfixUnaryOp(CurScope, Tok.getLocation(),
- Tok.getKind(), LHSGuard.take());
- LHSGuard.reset(LHS);
+ Tok.getKind(), LHS.move());
}
ConsumeToken();
break;
@@ -798,7 +779,7 @@
ConsumeToken();
// If the operand doesn't start with an '(', it must be an expression.
- ExprResult Operand;
+ ExprOwner Operand(Actions);
if (Tok.isNot(tok::l_paren)) {
Operand = ParseCastExpression(true);
} else {
@@ -822,16 +803,16 @@
// If this is a parenthesized expression, it is the start of a
// unary-expression, but doesn't include any postfix pieces. Parse these
// now if present.
- Operand = ParsePostfixExpressionSuffix(Operand);
+ Operand = ParsePostfixExpressionSuffix(Operand.move());
}
// If we get here, the operand to the sizeof/alignof was an expresion.
- if (!Operand.isInvalid)
+ if (!Operand.isInvalid())
Operand = Actions.ActOnSizeOfAlignOfExpr(OpTok.getLocation(),
OpTok.is(tok::kw_sizeof),
- /*isType=*/false, Operand.Val,
+ /*isType=*/false, Operand.move(),
SourceRange());
- return Operand;
+ return Operand.move();
}
/// ParseBuiltinPrimaryExpression
@@ -850,7 +831,7 @@
/// [GNU] offsetof-member-designator '[' expression ']'
///
Parser::ExprResult Parser::ParseBuiltinPrimaryExpression() {
- ExprResult Res(false);
+ ExprOwner Res(Actions);
const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo();
tok::TokenKind T = Tok.getKind();
@@ -868,9 +849,8 @@
switch (T) {
default: assert(0 && "Not a builtin primary expression!");
case tok::kw___builtin_va_arg: {
- ExprResult Expr = ParseAssignmentExpression();
- ExprGuard ExprGuard(Actions, Expr);
- if (Expr.isInvalid) {
+ ExprOwner Expr(Actions, ParseAssignmentExpression());
+ if (Expr.isInvalid()) {
SkipUntil(tok::r_paren);
return ExprResult(true);
}
@@ -879,12 +859,12 @@
return ExprResult(true);
TypeTy *Ty = ParseTypeName();
-
+
if (Tok.isNot(tok::r_paren)) {
Diag(Tok, diag::err_expected_rparen);
return ExprResult(true);
}
- Res = Actions.ActOnVAArg(StartLoc, ExprGuard.take(), Ty, ConsumeParen());
+ Res = Actions.ActOnVAArg(StartLoc, Expr.move(), Ty, ConsumeParen());
break;
}
case tok::kw___builtin_offsetof: {
@@ -931,11 +911,11 @@
Comps.back().isBrackets = true;
Comps.back().LocStart = ConsumeBracket();
Res = ParseExpression();
- if (Res.isInvalid) {
+ if (Res.isInvalid()) {
SkipUntil(tok::r_paren);
- return Res;
+ return Res.move();
}
- Comps.back().U.E = Res.Val;
+ Comps.back().U.E = Res.move();
Comps.back().LocEnd =
MatchRHSPunctuation(tok::r_square, Comps.back().LocStart);
@@ -951,36 +931,33 @@
break;
}
case tok::kw___builtin_choose_expr: {
- ExprResult Cond = ParseAssignmentExpression();
- ExprGuard CondGuard(Actions, Cond);
- if (Cond.isInvalid) {
+ ExprOwner Cond(Actions, ParseAssignmentExpression());
+ if (Cond.isInvalid()) {
SkipUntil(tok::r_paren);
- return Cond;
+ return Cond.move();
}
if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
return ExprResult(true);
- ExprResult Expr1 = ParseAssignmentExpression();
- ExprGuard Guard1(Actions, Expr1);
- if (Expr1.isInvalid) {
+ ExprOwner Expr1(Actions, ParseAssignmentExpression());
+ if (Expr1.isInvalid()) {
SkipUntil(tok::r_paren);
- return Expr1;
- }
+ return Expr1.move();
+ }
if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
return ExprResult(true);
- ExprResult Expr2 = ParseAssignmentExpression();
- ExprGuard Guard2(Actions, Expr2);
- if (Expr2.isInvalid) {
+ ExprOwner Expr2(Actions, ParseAssignmentExpression());
+ if (Expr2.isInvalid()) {
SkipUntil(tok::r_paren);
- return Expr2;
- }
+ return Expr2.move();
+ }
if (Tok.isNot(tok::r_paren)) {
Diag(Tok, diag::err_expected_rparen);
return ExprResult(true);
}
- Res = Actions.ActOnChooseExpr(StartLoc, CondGuard.take(), Guard1.take(),
- Guard2.take(), ConsumeParen());
+ Res = Actions.ActOnChooseExpr(StartLoc, Cond.move(), Expr1.move(),
+ Expr2.move(), ConsumeParen());
break;
}
case tok::kw___builtin_overload: {
@@ -991,13 +968,13 @@
// comma. If there is no comma, break and attempt to match r-paren.
if (Tok.isNot(tok::r_paren)) {
while (1) {
- ExprResult ArgExpr = ParseAssignmentExpression();
- if (ArgExpr.isInvalid) {
+ ExprOwner ArgExpr(Actions, ParseAssignmentExpression());
+ if (ArgExpr.isInvalid()) {
SkipUntil(tok::r_paren);
return ExprResult(true);
} else
- ArgExprs.push_back(ArgExpr.Val);
-
+ ArgExprs.push_back(ArgExpr.move());
+
if (Tok.isNot(tok::comma))
break;
// Move to the next argument, remember where the comma was.
@@ -1033,7 +1010,7 @@
// These can be followed by postfix-expr pieces because they are
// primary-expressions.
- return ParsePostfixExpressionSuffix(Res);
+ return ParsePostfixExpressionSuffix(Res.move());
}
/// ParseParenExpression - This parses the unit that starts with a '(' token,
@@ -1054,18 +1031,19 @@
SourceLocation &RParenLoc) {
assert(Tok.is(tok::l_paren) && "Not a paren expr!");
SourceLocation OpenLoc = ConsumeParen();
- ExprResult Result(true);
+ ExprOwner Result(Actions, true);
CastTy = 0;
if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {
Diag(Tok, diag::ext_gnu_statement_expr);
- Parser::StmtResult Stmt = ParseCompoundStatement(true);
+ StmtOwner Stmt(Actions, ParseCompoundStatement(true));
ExprType = CompoundStmt;
-
+
// If the substmt parsed correctly, build the AST node.
- if (!Stmt.isInvalid && Tok.is(tok::r_paren))
- Result = Actions.ActOnStmtExpr(OpenLoc, Stmt.Val, Tok.getLocation());
-
+ if (!Stmt.isInvalid() && Tok.is(tok::r_paren))
+ Result = Actions.ActOnStmtExpr(
+ OpenLoc, Stmt.move(), Tok.getLocation());
+
} else if (ExprType >= CompoundLiteral && isTypeIdInParens()) {
// Otherwise, this is a compound literal expression or cast expression.
TypeTy *Ty = ParseTypeName();
@@ -1081,8 +1059,9 @@
Diag(OpenLoc, diag::ext_c99_compound_literal);
Result = ParseInitializer();
ExprType = CompoundLiteral;
- if (!Result.isInvalid)
- return Actions.ActOnCompoundLiteral(OpenLoc, Ty, RParenLoc, Result.Val);
+ if (!Result.isInvalid())
+ return Actions.ActOnCompoundLiteral(OpenLoc, Ty, RParenLoc,
+ Result.take());
} else if (ExprType == CastExpr) {
// Note that this doesn't parse the subsequence cast-expression, it just
// returns the parsed type to the callee.
@@ -1093,16 +1072,17 @@
Diag(Tok, diag::err_expected_lbrace_in_compound_literal);
return ExprResult(true);
}
- return Result;
+ return Result.move();
} else {
Result = ParseExpression();
ExprType = SimpleExpr;
- if (!Result.isInvalid && Tok.is(tok::r_paren))
- Result = Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), Result.Val);
+ if (!Result.isInvalid() && Tok.is(tok::r_paren))
+ Result = Actions.ActOnParenExpr(
+ OpenLoc, Tok.getLocation(), Result.take());
}
// Match the ')'.
- if (Result.isInvalid)
+ if (Result.isInvalid())
SkipUntil(tok::r_paren);
else {
if (Tok.is(tok::r_paren))
@@ -1111,7 +1091,7 @@
MatchRHSPunctuation(tok::r_paren, OpenLoc);
}
- return Result;
+ return Result.move();
}
/// ParseStringLiteralExpression - This handles the various token types that
@@ -1148,11 +1128,11 @@
///
bool Parser::ParseExpressionList(ExprListTy &Exprs, CommaLocsTy &CommaLocs) {
while (1) {
- ExprResult Expr = ParseAssignmentExpression();
- if (Expr.isInvalid)
+ ExprOwner Expr(Actions, ParseAssignmentExpression());
+ if (Expr.isInvalid())
return true;
- Exprs.push_back(Expr.Val);
+ Exprs.push_back(Expr.move());
if (Tok.isNot(tok::comma))
return false;
@@ -1209,16 +1189,16 @@
// Inform sema that we are starting a block.
Actions.ActOnBlockArguments(ParamInfo);
- ExprResult Result = true;
+ ExprOwner Result(Actions, true);
if (Tok.is(tok::l_brace)) {
- StmtResult Stmt = ParseCompoundStatementBody();
- if (!Stmt.isInvalid) {
- Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.Val, CurScope);
+ StmtOwner Stmt(Actions, ParseCompoundStatementBody());
+ if (!Stmt.isInvalid()) {
+ Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.move(), CurScope);
} else {
Actions.ActOnBlockError(CaretLoc, CurScope);
}
}
ExitScope();
- return Result;
+ return Result.move();
}