[cfe-commits] r60900 - in /cfe/trunk: include/clang/Parse/Ownership.h include/clang/Parse/Parser.h lib/Parse/ParseDecl.cpp lib/Parse/ParseExpr.cpp lib/Parse/ParseExprCXX.cpp lib/Parse/ParseInit.cpp lib/Parse/ParseObjc.cpp lib/Parse/ParseStmt.cpp
steve naroff
snaroff at apple.com
Fri Dec 12 14:59:21 PST 2008
On Dec 12, 2008, at 5:51 PM, Howard Hinnant wrote:
> On Dec 12, 2008, at 5:32 PM, steve naroff wrote:
>
>>
>> On Dec 12, 2008, at 4:52 PM, Howard Hinnant wrote:
>>
>>> I'm afraid I don't have access to Windows. Is there a compiler
>>> switch you could try that is along the lines of "stress
>>> conformance instead of backwards compatibility"?
>>>
>>
>> I'm not aware of any. Since you are familiar with this specific C++
>> idiom, you might try Googling for some info. I'd do it myself,
>> however I'm not as plugged into the history of this particular C++
>> idiom (so you'd likely have more success finding the right stuff:-)
>
>
> Unfortunately you're not going to find much about this idiom out
> there. As far as I know I invented it last week.
>
> Where does ASTOwningResult live? For some reason I'm having trouble
> finding it.
>
I found it in "include/clang/Parse/Ownership.h"...
snaroff
> -Howard
>
>>
>>
>> Thanks,
>>
>> snaroff
>>
>>> -Howard
>>>
>>> On Dec 12, 2008, at 4:49 PM, steve naroff wrote:
>>>
>>>> Hi Sebastian,
>>>>
>>>> Your recent smart pointer work isn't happy on Windows.
>>>>
>>>> I get 52 identical errors that all say
>>>> 'clang::ASTOwningResult<Destroyer>::operator =': cannot access
>>>> private
>>>> member declared in class 'clang::ASTOwningResult<Destroyer>'
>>>>
>>>> Please advise - thanks,
>>>>
>>>> snaroff
>>>>
>>>> On Dec 11, 2008, at 4:37 PM, Sebastian Redl wrote:
>>>>
>>>>> Author: cornedbee
>>>>> Date: Thu Dec 11 15:36:32 2008
>>>>> New Revision: 60900
>>>>>
>>>>> URL: http://llvm.org/viewvc/llvm-project?rev=60900&view=rev
>>>>> Log:
>>>>> Convert selected expression parsers to use smart pointers.
>>>>>
>>>>> Modified:
>>>>> cfe/trunk/include/clang/Parse/Ownership.h
>>>>> cfe/trunk/include/clang/Parse/Parser.h
>>>>> cfe/trunk/lib/Parse/ParseDecl.cpp
>>>>> cfe/trunk/lib/Parse/ParseExpr.cpp
>>>>> cfe/trunk/lib/Parse/ParseExprCXX.cpp
>>>>> cfe/trunk/lib/Parse/ParseInit.cpp
>>>>> cfe/trunk/lib/Parse/ParseObjc.cpp
>>>>> cfe/trunk/lib/Parse/ParseStmt.cpp
>>>>>
>>>>> Modified: cfe/trunk/include/clang/Parse/Ownership.h
>>>>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Parse/Ownership.h?rev=60900&r1=60899&r2=60900&view=diff
>>>>>
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> ==================================================================
>>>>> --- cfe/trunk/include/clang/Parse/Ownership.h (original)
>>>>> +++ cfe/trunk/include/clang/Parse/Ownership.h Thu Dec 11
>>>>> 15:36:32 2008
>>>>> @@ -150,12 +150,6 @@
>>>>> public:
>>>>> typedef ActionBase::ActionResult<DestroyerToUID<Destroyer>::UID>
>>>>> DumbResult;
>>>>>
>>>>> - // For convenience and compatibility.
>>>>> - ASTOwningResult(bool invalid = false)
>>>>> - : Actions(0), Node(0), Invalid(invalid) {}
>>>>> - // Same
>>>>> - ASTOwningResult(const DiagnosticBuilder &)
>>>>> - : Actions(0), Node(0), Invalid(true) {}
>>>>> explicit ASTOwningResult(ActionBase &actions, bool invalid =
>>>>> false)
>>>>> : Actions(&actions), Node(0), Invalid(invalid) {}
>>>>> ASTOwningResult(ActionBase &actions, void *node)
>>>>>
>>>>> Modified: cfe/trunk/include/clang/Parse/Parser.h
>>>>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Parse/Parser.h?rev=60900&r1=60899&r2=60900&view=diff
>>>>>
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> ==================================================================
>>>>> --- cfe/trunk/include/clang/Parse/Parser.h (original)
>>>>> +++ cfe/trunk/include/clang/Parse/Parser.h Thu Dec 11 15:36:32
>>>>> 2008
>>>>> @@ -98,6 +98,8 @@
>>>>>
>>>>> OwningExprResult ExprError() { return OwningExprResult(Actions,
>>>>> true); }
>>>>> OwningStmtResult StmtError() { return OwningStmtResult(Actions,
>>>>> true); }
>>>>> + OwningExprResult ExprError(const DiagnosticBuilder &) { return
>>>>> ExprError(); }
>>>>> + OwningStmtResult StmtError(const DiagnosticBuilder &) { return
>>>>> StmtError(); }
>>>>>
>>>>> // Parsing methods.
>>>>>
>>>>> @@ -479,15 +481,16 @@
>>>>> //
>>>>> =
>>>>> =
>>>>> =
>>>>> --------------------------------------------------------------------
>>>>> ===//
>>>>> // C99 6.5: Expressions.
>>>>>
>>>>> - ExprResult ParseExpression();
>>>>> - ExprResult ParseConstantExpression();
>>>>> - ExprResult ParseAssignmentExpression(); // Expr that doesn't
>>>>> include commas.
>>>>> -
>>>>> + OwningExprResult ParseExpression();
>>>>> + OwningExprResult ParseConstantExpression();
>>>>> + // Expr that doesn't include commas.
>>>>> + OwningExprResult ParseAssignmentExpression();
>>>>> +
>>>>> ExprResult ParseExpressionWithLeadingAt(SourceLocation AtLoc);
>>>>>
>>>>> ExprResult ParseRHSOfBinaryExpression(ExprResult LHS, unsigned
>>>>> MinPrec);
>>>>> - ExprResult ParseCastExpression(bool isUnaryExpression);
>>>>> - ExprResult ParsePostfixExpressionSuffix(ExprResult LHS);
>>>>> + OwningExprResult ParseCastExpression(bool isUnaryExpression);
>>>>> + OwningExprResult ParsePostfixExpressionSuffix(OwningExprResult
>>>>> LHS);
>>>>> ExprResult ParseSizeofAlignofExpression();
>>>>> ExprResult ParseBuiltinPrimaryExpression();
>>>>>
>>>>> @@ -568,7 +571,7 @@
>>>>>
>>>>> //
>>>>> =
>>>>> =
>>>>> =
>>>>> --------------------------------------------------------------------
>>>>> ===//
>>>>> // C++ if/switch/while/for condition expression.
>>>>> - ExprResult ParseCXXCondition();
>>>>> + OwningExprResult ParseCXXCondition();
>>>>>
>>>>> //
>>>>> =
>>>>> =
>>>>> =
>>>>> --------------------------------------------------------------------
>>>>> ===//
>>>>> // C++ types
>>>>> @@ -582,7 +585,7 @@
>>>>> /// '{' ...
>>>>> ExprResult ParseInitializer() {
>>>>> if (Tok.isNot(tok::l_brace))
>>>>> - return ParseAssignmentExpression();
>>>>> + return ParseAssignmentExpression().result();
>>>>> return ParseBraceInitializer();
>>>>> }
>>>>> ExprResult ParseBraceInitializer();
>>>>>
>>>>> Modified: cfe/trunk/lib/Parse/ParseDecl.cpp
>>>>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseDecl.cpp?rev=60900&r1=60899&r2=60900&view=diff
>>>>>
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> ==================================================================
>>>>> --- cfe/trunk/lib/Parse/ParseDecl.cpp (original)
>>>>> +++ cfe/trunk/lib/Parse/ParseDecl.cpp Thu Dec 11 15:36:32 2008
>>>>> @@ -126,7 +126,7 @@
>>>>>
>>>>> // now parse the non-empty comma separated list of
>>>>> expressions
>>>>> while (1) {
>>>>> - OwningExprResult ArgExpr(Actions,
>>>>> ParseAssignmentExpression());
>>>>> + OwningExprResult
>>>>> ArgExpr(ParseAssignmentExpression());
>>>>> if (ArgExpr.isInvalid()) {
>>>>> ArgExprsOk = false;
>>>>> SkipUntil(tok::r_paren);
>>>>> @@ -158,7 +158,7 @@
>>>>>
>>>>> // now parse the list of expressions
>>>>> while (1) {
>>>>> - OwningExprResult ArgExpr(Actions,
>>>>> ParseAssignmentExpression());
>>>>> + OwningExprResult
>>>>> ArgExpr(ParseAssignmentExpression());
>>>>> if (ArgExpr.isInvalid()) {
>>>>> ArgExprsOk = false;
>>>>> SkipUntil(tok::r_paren);
>>>>> @@ -842,7 +842,7 @@
>>>>>
>>>>> if (Tok.is(tok::colon)) {
>>>>> ConsumeToken();
>>>>> - OwningExprResult Res(Actions, ParseConstantExpression());
>>>>> + OwningExprResult Res(ParseConstantExpression());
>>>>> if (Res.isInvalid())
>>>>> SkipUntil(tok::semi, true, true);
>>>>> else
>>>>> @@ -1796,7 +1796,7 @@
>>>>> ConsumeToken();
>>>>>
>>>>> // Parse the default argument
>>>>> - OwningExprResult DefArgResult(Actions,
>>>>> ParseAssignmentExpression());
>>>>> + OwningExprResult
>>>>> DefArgResult(ParseAssignmentExpression());
>>>>> if (DefArgResult.isInvalid()) {
>>>>> SkipUntil(tok::comma, tok::r_paren, true, true);
>>>>> } else {
>>>>> @@ -1992,8 +1992,7 @@
>>>>> return;
>>>>> }
>>>>>
>>>>> - OwningExprResult Result(Actions,
>>>>> - ParseCastExpression(true/
>>>>> *isUnaryExpression*/));
>>>>> + OwningExprResult Result(ParseCastExpression(true/
>>>>> *isUnaryExpression*/));
>>>>> if (Result.isInvalid())
>>>>> return;
>>>>>
>>>>> @@ -2025,7 +2024,7 @@
>>>>> if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc,
>>>>> PrevSpec, Ty))
>>>>> Diag(StartLoc, diag::err_invalid_decl_spec_combination) <<
>>>>> PrevSpec;
>>>>> } else { // we have an expression.
>>>>> - OwningExprResult Result(Actions, ParseExpression());
>>>>> + OwningExprResult Result(ParseExpression());
>>>>>
>>>>> if (Result.isInvalid() || Tok.isNot(tok::r_paren)) {
>>>>> MatchRHSPunctuation(tok::r_paren, LParenLoc);
>>>>>
>>>>> Modified: cfe/trunk/lib/Parse/ParseExpr.cpp
>>>>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseExpr.cpp?rev=60900&r1=60899&r2=60900&view=diff
>>>>>
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> ==================================================================
>>>>> --- cfe/trunk/lib/Parse/ParseExpr.cpp (original)
>>>>> +++ cfe/trunk/lib/Parse/ParseExpr.cpp Thu Dec 11 15:36:32 2008
>>>>> @@ -169,14 +169,14 @@
>>>>> /// assignment-expression
>>>>> /// expression ',' assignment-expression
>>>>> ///
>>>>> -Parser::ExprResult Parser::ParseExpression() {
>>>>> +Parser::OwningExprResult Parser::ParseExpression() {
>>>>> if (Tok.is(tok::kw_throw))
>>>>> - return ParseThrowExpression();
>>>>> + return Owned(ParseThrowExpression());
>>>>>
>>>>> - OwningExprResult LHS(Actions, ParseCastExpression(false));
>>>>> - if (LHS.isInvalid()) return LHS.result();
>>>>> -
>>>>> - return ParseRHSOfBinaryExpression(LHS.result(), prec::Comma);
>>>>> + OwningExprResult LHS(ParseCastExpression(false));
>>>>> + if (LHS.isInvalid()) return move(LHS);
>>>>> +
>>>>> + return Owned(ParseRHSOfBinaryExpression(LHS.result(),
>>>>> prec::Comma));
>>>>> }
>>>>>
>>>>> /// This routine is called when the '@' is seen and consumed.
>>>>> @@ -193,14 +193,14 @@
>>>>>
>>>>> /// ParseAssignmentExpression - Parse an expr that doesn't include
>>>>> commas.
>>>>> ///
>>>>> -Parser::ExprResult Parser::ParseAssignmentExpression() {
>>>>> +Parser::OwningExprResult Parser::ParseAssignmentExpression() {
>>>>> if (Tok.is(tok::kw_throw))
>>>>> - return ParseThrowExpression();
>>>>> + return Owned(ParseThrowExpression());
>>>>>
>>>>> - OwningExprResult LHS(Actions, ParseCastExpression(false));
>>>>> - if (LHS.isInvalid()) return LHS.result();
>>>>> -
>>>>> - return ParseRHSOfBinaryExpression(LHS.result(),
>>>>> prec::Assignment);
>>>>> + OwningExprResult LHS(ParseCastExpression(false));
>>>>> + if (LHS.isInvalid()) return move(LHS);
>>>>> +
>>>>> + return Owned(ParseRHSOfBinaryExpression(LHS.result(),
>>>>> prec::Assignment));
>>>>> }
>>>>>
>>>>> /// ParseAssignmentExprWithObjCMessageExprStart - Parse an
>>>>> assignment expression
>>>>> @@ -220,17 +220,17 @@
>>>>>
>>>>> ReceiverName,
>>>>>
>>>>> ReceiverExpr));
>>>>> if (R.isInvalid()) return R.result();
>>>>> - R = ParsePostfixExpressionSuffix(R.result());
>>>>> + R = ParsePostfixExpressionSuffix(move(R));
>>>>> if (R.isInvalid()) return R.result();
>>>>> return ParseRHSOfBinaryExpression(R.result(), 2);
>>>>> }
>>>>>
>>>>>
>>>>> -Parser::ExprResult Parser::ParseConstantExpression() {
>>>>> - OwningExprResult LHS(Actions, ParseCastExpression(false));
>>>>> - if (LHS.isInvalid()) return LHS.result();
>>>>> -
>>>>> - return ParseRHSOfBinaryExpression(LHS.result(),
>>>>> prec::Conditional);
>>>>> +Parser::OwningExprResult Parser::ParseConstantExpression() {
>>>>> + OwningExprResult LHS(ParseCastExpression(false));
>>>>> + if (LHS.isInvalid()) return move(LHS);
>>>>> +
>>>>> + return Owned(ParseRHSOfBinaryExpression(LHS.result(),
>>>>> prec::Conditional));
>>>>> }
>>>>>
>>>>> /// ParseRHSOfBinaryExpression - Parse a binary expression that
>>>>> starts with
>>>>> @@ -281,7 +281,7 @@
>>>>> }
>>>>>
>>>>> // Parse another leaf here for the RHS of the operator.
>>>>> - OwningExprResult RHS(Actions, ParseCastExpression(false));
>>>>> + OwningExprResult RHS(ParseCastExpression(false));
>>>>> if (RHS.isInvalid())
>>>>> return RHS.result();
>>>>>
>>>>> @@ -410,7 +410,7 @@
>>>>> /// '::'[opt] 'delete' cast-expression
>>>>> /// '::'[opt] 'delete' '[' ']' cast-expression
>>>>> ///
>>>>> -Parser::ExprResult Parser::ParseCastExpression(bool
>>>>> isUnaryExpression) {
>>>>> +Parser::OwningExprResult Parser::ParseCastExpression(bool
>>>>> isUnaryExpression) {
>>>>> if (getLang().CPlusPlus) {
>>>>> // Annotate typenames and C++ scope specifiers.
>>>>> // Used only in C++, where the typename can be considered as a
>>>>> functional
>>>>> @@ -444,7 +444,7 @@
>>>>> SourceLocation LParenLoc = Tok.getLocation();
>>>>> SourceLocation RParenLoc;
>>>>> Res = ParseParenExpression(ParenExprType, CastTy, RParenLoc);
>>>>> - if (Res.isInvalid()) return Res.result();
>>>>> + if (Res.isInvalid()) return move(Res);
>>>>>
>>>>> switch (ParenExprType) {
>>>>> case SimpleExpr: break; // Nothing else to do.
>>>>> @@ -461,27 +461,27 @@
>>>>> if (!Res.isInvalid())
>>>>> Res = Actions.ActOnCastExpr(LParenLoc, CastTy, RParenLoc,
>>>>> Res.release());
>>>>> - return Res.result();
>>>>> + return move(Res);
>>>>> }
>>>>>
>>>>> // These can be followed by postfix-expr pieces.
>>>>> - return ParsePostfixExpressionSuffix(Res.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>> }
>>>>>
>>>>> // primary-expression
>>>>> case tok::numeric_constant:
>>>>> // constant: integer-constant
>>>>> // constant: floating-constant
>>>>> -
>>>>> +
>>>>> Res = Actions.ActOnNumericConstant(Tok);
>>>>> ConsumeToken();
>>>>> -
>>>>> +
>>>>> // These can be followed by postfix-expr pieces.
>>>>> - return ParsePostfixExpressionSuffix(Res.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>>
>>>>> case tok::kw_true:
>>>>> case tok::kw_false:
>>>>> - return ParseCXXBoolLiteral();
>>>>> + return Owned(ParseCXXBoolLiteral());
>>>>>
>>>>> case tok::identifier: { // primary-expression: identifier
>>>>> // unqualified-id: identifier
>>>>> @@ -495,42 +495,43 @@
>>>>> 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.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>> }
>>>>> case tok::char_constant: // constant: character-constant
>>>>> Res = Actions.ActOnCharacterConstant(Tok);
>>>>> ConsumeToken();
>>>>> // These can be followed by postfix-expr pieces.
>>>>> - return ParsePostfixExpressionSuffix(Res.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>> 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.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>> case tok::string_literal: // primary-expression: string-literal
>>>>> case tok::wide_string_literal:
>>>>> Res = ParseStringLiteralExpression();
>>>>> - if (Res.isInvalid()) return Res.result();
>>>>> + if (Res.isInvalid()) return move(Res);
>>>>> // This can be followed by postfix-expr pieces (e.g. "foo"[1]).
>>>>> - return ParsePostfixExpressionSuffix(Res.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>> case tok::kw___builtin_va_arg:
>>>>> case tok::kw___builtin_offsetof:
>>>>> case tok::kw___builtin_choose_expr:
>>>>> case tok::kw___builtin_overload:
>>>>> case tok::kw___builtin_types_compatible_p:
>>>>> - return ParseBuiltinPrimaryExpression();
>>>>> + return Owned(ParseBuiltinPrimaryExpression());
>>>>> case tok::kw___null:
>>>>> - return Actions.ActOnGNUNullExpr(ConsumeToken());
>>>>> + return Owned(Actions.ActOnGNUNullExpr(ConsumeToken()));
>>>>> break;
>>>>> case tok::plusplus: // unary-expression: '++' unary-
>>>>> expression
>>>>> case tok::minusminus: { // unary-expression: '--' unary-
>>>>> expression
>>>>> SourceLocation SavedLoc = ConsumeToken();
>>>>> Res = ParseCastExpression(true);
>>>>> if (!Res.isInvalid())
>>>>> - Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind,
>>>>> Res.release());
>>>>> - return Res.result();
>>>>> + Res = Owned(Actions.ActOnUnaryOp(CurScope, SavedLoc,
>>>>> SavedKind,
>>>>> + Res.release()));
>>>>> + return move(Res);
>>>>> }
>>>>> case tok::amp: // unary-expression: '&' cast-expression
>>>>> case tok::star: // unary-expression: '*' cast-expression
>>>>> @@ -544,7 +545,7 @@
>>>>> Res = ParseCastExpression(false);
>>>>> if (!Res.isInvalid())
>>>>> Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind,
>>>>> Res.release());
>>>>> - return Res.result();
>>>>> + return move(Res);
>>>>> }
>>>>>
>>>>> case tok::kw___extension__:{//unary-expression:'__extension__'
>>>>> cast-expr [GNU]
>>>>> @@ -554,7 +555,7 @@
>>>>> Res = ParseCastExpression(false);
>>>>> if (!Res.isInvalid())
>>>>> Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind,
>>>>> Res.release());
>>>>> - return Res.result();
>>>>> + return move(Res);
>>>>> }
>>>>> case tok::kw_sizeof: // unary-expression: 'sizeof' unary-
>>>>> expression
>>>>> // unary-expression: 'sizeof' '(' type-
>>>>> name ')'
>>>>> @@ -562,19 +563,17 @@
>>>>> case tok::kw___alignof: // unary-expression: '__alignof' unary-
>>>>> expression
>>>>> // unary-expression: '__alignof' '(' type-
>>>>> name ')'
>>>>> // unary-expression: 'alignof' '(' type-
>>>>> id ')'
>>>>> - return ParseSizeofAlignofExpression();
>>>>> + return Owned(ParseSizeofAlignofExpression());
>>>>> case tok::ampamp: { // unary-expression: '&&' identifier
>>>>> SourceLocation AmpAmpLoc = ConsumeToken();
>>>>> - if (Tok.isNot(tok::identifier)) {
>>>>> - Diag(Tok, diag::err_expected_ident);
>>>>> - return ExprResult(true);
>>>>> - }
>>>>> + if (Tok.isNot(tok::identifier))
>>>>> + return ExprError(Diag(Tok, diag::err_expected_ident));
>>>>>
>>>>> Diag(AmpAmpLoc, diag::ext_gnu_address_of_label);
>>>>> Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(),
>>>>> Tok.getIdentifierInfo());
>>>>> ConsumeToken();
>>>>> - return Res.result();
>>>>> + return move(Res);
>>>>> }
>>>>> case tok::kw_const_cast:
>>>>> case tok::kw_dynamic_cast:
>>>>> @@ -582,15 +581,15 @@
>>>>> case tok::kw_static_cast:
>>>>> Res = ParseCXXCasts();
>>>>> // These can be followed by postfix-expr pieces.
>>>>> - return ParsePostfixExpressionSuffix(Res.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>> case tok::kw_typeid:
>>>>> Res = ParseCXXTypeid();
>>>>> // This can be followed by postfix-expr pieces.
>>>>> - return ParsePostfixExpressionSuffix(Res.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>> case tok::kw_this:
>>>>> Res = ParseCXXThis();
>>>>> // This can be followed by postfix-expr pieces.
>>>>> - return ParsePostfixExpressionSuffix(Res.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>>
>>>>> case tok::kw_char:
>>>>> case tok::kw_wchar_t:
>>>>> @@ -613,54 +612,54 @@
>>>>> DeclSpec DS;
>>>>> ParseCXXSimpleTypeSpecifier(DS);
>>>>> if (Tok.isNot(tok::l_paren))
>>>>> - return Diag(Tok, diag::err_expected_lparen_after_type)
>>>>> - << DS.getSourceRange();
>>>>> + return ExprError(Diag(Tok,
>>>>> diag::err_expected_lparen_after_type)
>>>>> + << DS.getSourceRange());
>>>>>
>>>>> Res = ParseCXXTypeConstructExpression(DS);
>>>>> // This can be followed by postfix-expr pieces.
>>>>> - return ParsePostfixExpressionSuffix(Res.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>> }
>>>>>
>>>>> 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.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res));
>>>>>
>>>>> case tok::coloncolon: // [C++] new-expression or [C++] delete-
>>>>> expression
>>>>> // If the next token is neither 'new' nor 'delete', the :: would
>>>>> have been
>>>>> // parsed as a scope specifier already.
>>>>> if (NextToken().is(tok::kw_new))
>>>>> - return ParseCXXNewExpression();
>>>>> + return Owned(ParseCXXNewExpression());
>>>>> else
>>>>> - return ParseCXXDeleteExpression();
>>>>> + return Owned(ParseCXXDeleteExpression());
>>>>>
>>>>> case tok::kw_new: // [C++] new-expression
>>>>> - return ParseCXXNewExpression();
>>>>> + return Owned(ParseCXXNewExpression());
>>>>>
>>>>> case tok::kw_delete: // [C++] delete-expression
>>>>> - return ParseCXXDeleteExpression();
>>>>> + return Owned(ParseCXXDeleteExpression());
>>>>>
>>>>> case tok::at: {
>>>>> SourceLocation AtLoc = ConsumeToken();
>>>>> - return ParseObjCAtExpression(AtLoc);
>>>>> + return Owned(ParseObjCAtExpression(AtLoc));
>>>>> }
>>>>> case tok::l_square:
>>>>> // These can be followed by postfix-expr pieces.
>>>>> if (getLang().ObjC1)
>>>>> - return
>>>>> ParsePostfixExpressionSuffix(ParseObjCMessageExpression());
>>>>> + return
>>>>> ParsePostfixExpressionSuffix(Owned(ParseObjCMessageExpression()));
>>>>> // FALL THROUGH.
>>>>> case tok::caret:
>>>>> if (getLang().Blocks)
>>>>> - return
>>>>> ParsePostfixExpressionSuffix(ParseBlockLiteralExpression());
>>>>> + return
>>>>> ParsePostfixExpressionSuffix
>>>>> (Owned(ParseBlockLiteralExpression()));
>>>>> Diag(Tok, diag::err_expected_expression);
>>>>> - return ExprResult(true);
>>>>> + return ExprError();
>>>>> default:
>>>>> UnhandledToken:
>>>>> Diag(Tok, diag::err_expected_expression);
>>>>> - return ExprResult(true);
>>>>> + return ExprError();
>>>>> }
>>>>> -
>>>>> +
>>>>> // unreachable.
>>>>> abort();
>>>>> }
>>>>> @@ -683,18 +682,18 @@
>>>>> /// argument-expression
>>>>> /// argument-expression-list ',' assignment-expression
>>>>> ///
>>>>> -Parser::ExprResult
>>>>> Parser::ParsePostfixExpressionSuffix(ExprResult
>>>>> LHSArg) {
>>>>> - OwningExprResult LHS(Actions, LHSArg);
>>>>> +Parser::OwningExprResult
>>>>> +Parser::ParsePostfixExpressionSuffix(OwningExprResult LHS) {
>>>>> // 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.
>>>>> - return LHS.result();
>>>>> + return move(LHS);
>>>>> case tok::l_square: { // postfix-expression: p-e '[' expression
>>>>> ']'
>>>>> Loc = ConsumeBracket();
>>>>> - OwningExprResult Idx(Actions, ParseExpression());
>>>>> + OwningExprResult Idx(ParseExpression());
>>>>>
>>>>> SourceLocation RLoc = Tok.getLocation();
>>>>>
>>>>> @@ -702,7 +701,7 @@
>>>>> LHS = Actions.ActOnArraySubscriptExpr(CurScope,
>>>>> LHS.release(), Loc,
>>>>> Idx.release(), RLoc);
>>>>> } else
>>>>> - LHS = ExprResult(true);
>>>>> + LHS = ExprError();
>>>>>
>>>>> // Match the ']'.
>>>>> MatchRHSPunctuation(tok::r_square, Loc);
>>>>> @@ -712,16 +711,16 @@
>>>>> case tok::l_paren: { // p-e: p-e '(' argument-expression-
>>>>> list[opt] ')'
>>>>> ExprVector ArgExprs(Actions);
>>>>> CommaLocsTy CommaLocs;
>>>>> -
>>>>> +
>>>>> Loc = ConsumeParen();
>>>>> -
>>>>> +
>>>>> if (Tok.isNot(tok::r_paren)) {
>>>>> if (ParseExpressionList(ArgExprs, CommaLocs)) {
>>>>> SkipUntil(tok::r_paren);
>>>>> - return ExprResult(true);
>>>>> + return ExprError();
>>>>> }
>>>>> }
>>>>> -
>>>>> +
>>>>> // Match the ')'.
>>>>> if (!LHS.isInvalid() && Tok.is(tok::r_paren)) {
>>>>> assert((ArgExprs.size() == 0 || ArgExprs.size()-1 ==
>>>>> CommaLocs.size())&&
>>>>> @@ -731,7 +730,7 @@
>>>>> ArgExprs.size(), &CommaLocs[0],
>>>>> Tok.getLocation());
>>>>> }
>>>>> -
>>>>> +
>>>>> MatchRHSPunctuation(tok::r_paren, Loc);
>>>>> break;
>>>>> }
>>>>> @@ -739,12 +738,12 @@
>>>>> case tok::period: { // postfix-expression: p-e '.' identifier
>>>>> tok::TokenKind OpKind = Tok.getKind();
>>>>> SourceLocation OpLoc = ConsumeToken(); // Eat the "." or "->"
>>>>> token.
>>>>> -
>>>>> +
>>>>> if (Tok.isNot(tok::identifier)) {
>>>>> Diag(Tok, diag::err_expected_ident);
>>>>> - return ExprResult(true);
>>>>> + return ExprError();
>>>>> }
>>>>> -
>>>>> +
>>>>> if (!LHS.isInvalid()) {
>>>>> LHS = Actions.ActOnMemberReferenceExpr(LHS.release(), OpLoc,
>>>>> OpKind,
>>>>> Tok.getLocation(),
>>>>> @@ -805,7 +804,7 @@
>>>>> // 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.result());
>>>>> + Operand = ParsePostfixExpressionSuffix(move(Operand));
>>>>> }
>>>>>
>>>>> // If we get here, the operand to the sizeof/alignof was an
>>>>> expresion.
>>>>> @@ -851,7 +850,7 @@
>>>>> switch (T) {
>>>>> default: assert(0 && "Not a builtin primary expression!");
>>>>> case tok::kw___builtin_va_arg: {
>>>>> - OwningExprResult Expr(Actions, ParseAssignmentExpression());
>>>>> + OwningExprResult Expr(ParseAssignmentExpression());
>>>>> if (Expr.isInvalid()) {
>>>>> SkipUntil(tok::r_paren);
>>>>> return ExprResult(true);
>>>>> @@ -933,7 +932,7 @@
>>>>> break;
>>>>> }
>>>>> case tok::kw___builtin_choose_expr: {
>>>>> - OwningExprResult Cond(Actions, ParseAssignmentExpression());
>>>>> + OwningExprResult Cond(ParseAssignmentExpression());
>>>>> if (Cond.isInvalid()) {
>>>>> SkipUntil(tok::r_paren);
>>>>> return Cond.result();
>>>>> @@ -941,7 +940,7 @@
>>>>> if (ExpectAndConsume(tok::comma, diag::err_expected_comma,
>>>>> "",tok::r_paren))
>>>>> return ExprResult(true);
>>>>>
>>>>> - OwningExprResult Expr1(Actions, ParseAssignmentExpression());
>>>>> + OwningExprResult Expr1(ParseAssignmentExpression());
>>>>> if (Expr1.isInvalid()) {
>>>>> SkipUntil(tok::r_paren);
>>>>> return Expr1.result();
>>>>> @@ -949,7 +948,7 @@
>>>>> if (ExpectAndConsume(tok::comma, diag::err_expected_comma,
>>>>> "",tok::r_paren))
>>>>> return ExprResult(true);
>>>>>
>>>>> - OwningExprResult Expr2(Actions, ParseAssignmentExpression());
>>>>> + OwningExprResult Expr2(ParseAssignmentExpression());
>>>>> if (Expr2.isInvalid()) {
>>>>> SkipUntil(tok::r_paren);
>>>>> return Expr2.result();
>>>>> @@ -970,7 +969,7 @@
>>>>> // comma. If there is no comma, break and attempt to match r-
>>>>> paren.
>>>>> if (Tok.isNot(tok::r_paren)) {
>>>>> while (1) {
>>>>> - OwningExprResult ArgExpr(Actions,
>>>>> ParseAssignmentExpression());
>>>>> + OwningExprResult ArgExpr(ParseAssignmentExpression());
>>>>> if (ArgExpr.isInvalid()) {
>>>>> SkipUntil(tok::r_paren);
>>>>> return ExprResult(true);
>>>>> @@ -1008,11 +1007,11 @@
>>>>> }
>>>>> Res = Actions.ActOnTypesCompatibleExpr(StartLoc, Ty1, Ty2,
>>>>> ConsumeParen());
>>>>> break;
>>>>> - }
>>>>> -
>>>>> + }
>>>>> +
>>>>> // These can be followed by postfix-expr pieces because they are
>>>>> // primary-expressions.
>>>>> - return ParsePostfixExpressionSuffix(Res.result());
>>>>> + return ParsePostfixExpressionSuffix(move(Res)).result();
>>>>> }
>>>>>
>>>>> /// ParseParenExpression - This parses the unit that starts with a
>>>>> '(' token,
>>>>> @@ -1130,7 +1129,7 @@
>>>>> ///
>>>>> bool Parser::ParseExpressionList(ExprListTy &Exprs, CommaLocsTy
>>>>> &CommaLocs) {
>>>>> while (1) {
>>>>> - OwningExprResult Expr(Actions, ParseAssignmentExpression());
>>>>> + OwningExprResult Expr(ParseAssignmentExpression());
>>>>> if (Expr.isInvalid())
>>>>> return true;
>>>>>
>>>>>
>>>>> Modified: cfe/trunk/lib/Parse/ParseExprCXX.cpp
>>>>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseExprCXX.cpp?rev=60900&r1=60899&r2=60900&view=diff
>>>>>
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> ==================================================================
>>>>> --- cfe/trunk/lib/Parse/ParseExprCXX.cpp (original)
>>>>> +++ cfe/trunk/lib/Parse/ParseExprCXX.cpp Thu Dec 11 15:36:32 2008
>>>>> @@ -310,7 +310,7 @@
>>>>> return Actions.ActOnCXXThrow(ThrowLoc);
>>>>>
>>>>> default:
>>>>> - OwningExprResult Expr(Actions, ParseAssignmentExpression());
>>>>> + OwningExprResult Expr(ParseAssignmentExpression());
>>>>> if (Expr.isInvalid()) return Expr.result();
>>>>> return Actions.ActOnCXXThrow(ThrowLoc, Expr.release());
>>>>> }
>>>>> @@ -372,7 +372,7 @@
>>>>> /// [GNU] type-specifier-seq declarator simple-asm-expr[opt]
>>>>> attributes[opt]
>>>>> /// '=' assignment-expression
>>>>> ///
>>>>> -Parser::ExprResult Parser::ParseCXXCondition() {
>>>>> +Parser::OwningExprResult Parser::ParseCXXCondition() {
>>>>> if (!isCXXConditionDeclaration())
>>>>> return ParseExpression(); // expression
>>>>>
>>>>> @@ -391,7 +391,7 @@
>>>>> OwningExprResult AsmLabel(ParseSimpleAsm());
>>>>> if (AsmLabel.isInvalid()) {
>>>>> SkipUntil(tok::semi);
>>>>> - return true;
>>>>> + return ExprError();
>>>>> }
>>>>> DeclaratorInfo.setAsmLabel(AsmLabel.release());
>>>>> }
>>>>> @@ -402,15 +402,15 @@
>>>>>
>>>>> // '=' assignment-expression
>>>>> if (Tok.isNot(tok::equal))
>>>>> - return Diag(Tok, diag::err_expected_equal_after_declarator);
>>>>> + return ExprError(Diag(Tok,
>>>>> diag::err_expected_equal_after_declarator));
>>>>> SourceLocation EqualLoc = ConsumeToken();
>>>>> - OwningExprResult AssignExpr(Actions,
>>>>> ParseAssignmentExpression());
>>>>> + OwningExprResult AssignExpr(ParseAssignmentExpression());
>>>>> if (AssignExpr.isInvalid())
>>>>> - return true;
>>>>> -
>>>>> - return Actions.ActOnCXXConditionDeclarationExpr(CurScope,
>>>>> StartLoc,
>>>>> - DeclaratorInfo,
>>>>> EqualLoc,
>>>>> -
>>>>> AssignExpr.release());
>>>>> + return ExprError();
>>>>> +
>>>>> + return Owned(Actions.ActOnCXXConditionDeclarationExpr(CurScope,
>>>>> StartLoc,
>>>>> +
>>>>> DeclaratorInfo,EqualLoc,
>>>>> +
>>>>> AssignExpr.release()));
>>>>> }
>>>>>
>>>>> /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type
>>>>> specifiers.
>>>>> @@ -776,8 +776,8 @@
>>>>> bool first = true;
>>>>> while (Tok.is(tok::l_square)) {
>>>>> SourceLocation LLoc = ConsumeBracket();
>>>>> - OwningExprResult Size(Actions, first ? ParseExpression()
>>>>> - :
>>>>> ParseConstantExpression());
>>>>> + OwningExprResult Size(first ? ParseExpression()
>>>>> + : ParseConstantExpression());
>>>>> if (Size.isInvalid()) {
>>>>> // Recover
>>>>> SkipUntil(tok::r_square);
>>>>> @@ -851,7 +851,7 @@
>>>>> return true;
>>>>> }
>>>>>
>>>>> - OwningExprResult Operand(Actions, ParseCastExpression(false));
>>>>> + OwningExprResult Operand(ParseCastExpression(false));
>>>>> if (Operand.isInvalid())
>>>>> return Operand.result();
>>>>>
>>>>>
>>>>> Modified: cfe/trunk/lib/Parse/ParseInit.cpp
>>>>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseInit.cpp?rev=60900&r1=60899&r2=60900&view=diff
>>>>>
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> ==================================================================
>>>>> --- cfe/trunk/lib/Parse/ParseInit.cpp (original)
>>>>> +++ cfe/trunk/lib/Parse/ParseInit.cpp Thu Dec 11 15:36:32 2008
>>>>> @@ -143,7 +143,7 @@
>>>>> // Note that we parse this as an assignment expression, not a
>>>>> constant
>>>>> // expression (allowing *=, =, etc) to handle the objc case.
>>>>> Sema needs
>>>>> // to validate that the expression is a constant.
>>>>> - OwningExprResult Idx(Actions, ParseAssignmentExpression());
>>>>> + OwningExprResult Idx(ParseAssignmentExpression());
>>>>> if (Idx.isInvalid()) {
>>>>> SkipUntil(tok::r_square);
>>>>> return Idx.result();
>>>>> @@ -184,8 +184,8 @@
>>>>> // Handle the gnu array range extension.
>>>>> Diag(Tok, diag::ext_gnu_array_range);
>>>>> ConsumeToken();
>>>>> -
>>>>> - OwningExprResult RHS(Actions, ParseConstantExpression());
>>>>> +
>>>>> + OwningExprResult RHS(ParseConstantExpression());
>>>>> if (RHS.isInvalid()) {
>>>>> SkipUntil(tok::r_square);
>>>>> return RHS.result();
>>>>>
>>>>> Modified: cfe/trunk/lib/Parse/ParseObjc.cpp
>>>>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseObjc.cpp?rev=60900&r1=60899&r2=60900&view=diff
>>>>>
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> ==================================================================
>>>>> --- cfe/trunk/lib/Parse/ParseObjc.cpp (original)
>>>>> +++ cfe/trunk/lib/Parse/ParseObjc.cpp Thu Dec 11 15:36:32 2008
>>>>> @@ -1199,7 +1199,7 @@
>>>>> return StmtError();
>>>>> }
>>>>> ConsumeParen(); // '('
>>>>> - OwningExprResult Res(Actions, ParseExpression());
>>>>> + OwningExprResult Res(ParseExpression());
>>>>> if (Res.isInvalid()) {
>>>>> SkipUntil(tok::semi);
>>>>> return StmtError();
>>>>> @@ -1397,18 +1397,22 @@
>>>>> switch (Tok.getKind()) {
>>>>> case tok::string_literal: // primary-expression: string-literal
>>>>> case tok::wide_string_literal:
>>>>> - return
>>>>> ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc));
>>>>> + return ParsePostfixExpressionSuffix(
>>>>> + Owned(ParseObjCStringLiteral(AtLoc))).result();
>>>>> default:
>>>>> if (Tok.getIdentifierInfo() == 0)
>>>>> return Diag(AtLoc, diag::err_unexpected_at);
>>>>> -
>>>>> +
>>>>> switch (Tok.getIdentifierInfo()->getObjCKeywordID()) {
>>>>> case tok::objc_encode:
>>>>> - return
>>>>> ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc));
>>>>> + return ParsePostfixExpressionSuffix(
>>>>> + Owned(ParseObjCEncodeExpression(AtLoc))).result();
>>>>> case tok::objc_protocol:
>>>>> - return
>>>>> ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc));
>>>>> + return ParsePostfixExpressionSuffix(
>>>>> + Owned(ParseObjCProtocolExpression(AtLoc))).result();
>>>>> case tok::objc_selector:
>>>>> - return
>>>>> ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc));
>>>>> + return ParsePostfixExpressionSuffix(
>>>>> + Owned(ParseObjCSelectorExpression(AtLoc))).result();
>>>>> default:
>>>>> return Diag(AtLoc, diag::err_unexpected_at);
>>>>> }
>>>>> @@ -1433,7 +1437,7 @@
>>>>> return ParseObjCMessageExpressionBody(LBracLoc, NameLoc,
>>>>> ReceiverName, 0);
>>>>> }
>>>>>
>>>>> - OwningExprResult Res(Actions, ParseExpression());
>>>>> + OwningExprResult Res(ParseExpression());
>>>>> if (Res.isInvalid()) {
>>>>> SkipUntil(tok::r_square);
>>>>> return Res.result();
>>>>> @@ -1492,7 +1496,7 @@
>>>>>
>>>>> ConsumeToken(); // Eat the ':'.
>>>>> /// Parse the expression after ':'
>>>>> - OwningExprResult Res(Actions, ParseAssignmentExpression());
>>>>> + OwningExprResult Res(ParseAssignmentExpression());
>>>>> if (Res.isInvalid()) {
>>>>> // We must manually skip to a ']', otherwise the expression
>>>>> skipper will
>>>>> // stop at the ']' when it skips to the ';'. We want it to
>>>>> skip beyond
>>>>> @@ -1514,7 +1518,7 @@
>>>>> while (Tok.is(tok::comma)) {
>>>>> ConsumeToken(); // Eat the ','.
>>>>> /// Parse the expression after ','
>>>>> - OwningExprResult Res(Actions, ParseAssignmentExpression());
>>>>> + OwningExprResult Res(ParseAssignmentExpression());
>>>>> if (Res.isInvalid()) {
>>>>> // We must manually skip to a ']', otherwise the expression
>>>>> skipper will
>>>>> // stop at the ']' when it skips to the ';'. We want it to
>>>>> skip beyond
>>>>>
>>>>> Modified: cfe/trunk/lib/Parse/ParseStmt.cpp
>>>>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseStmt.cpp?rev=60900&r1=60899&r2=60900&view=diff
>>>>>
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> =
>>>>> ==================================================================
>>>>> --- cfe/trunk/lib/Parse/ParseStmt.cpp (original)
>>>>> +++ cfe/trunk/lib/Parse/ParseStmt.cpp Thu Dec 11 15:36:32 2008
>>>>> @@ -107,7 +107,7 @@
>>>>> return StmtError();
>>>>> } else {
>>>>> // expression[opt] ';'
>>>>> - OwningExprResult Expr(Actions, ParseExpression());
>>>>> + OwningExprResult Expr(ParseExpression());
>>>>> if (Expr.isInvalid()) {
>>>>> // If the expression is invalid, skip ahead to the next
>>>>> semicolon. Not
>>>>> // doing this opens us up to the possibility of infinite
>>>>> loops if
>>>>> @@ -226,7 +226,7 @@
>>>>> assert(Tok.is(tok::kw_case) && "Not a case stmt!");
>>>>> SourceLocation CaseLoc = ConsumeToken(); // eat the 'case'.
>>>>>
>>>>> - OwningExprResult LHS(Actions, ParseConstantExpression());
>>>>> + OwningExprResult LHS(ParseConstantExpression());
>>>>> if (LHS.isInvalid()) {
>>>>> SkipUntil(tok::colon);
>>>>> return StmtError();
>>>>> @@ -379,7 +379,7 @@
>>>>> } else {
>>>>> // Otherwise this was a unary __extension__ marker. Parse the
>>>>> // subexpression and add the __extension__ unary op.
>>>>> - OwningExprResult Res(Actions,
>>>>> ParseCastExpression(false));
>>>>> + OwningExprResult Res(ParseCastExpression(false));
>>>>>
>>>>> if (Res.isInvalid()) {
>>>>> SkipUntil(tok::semi);
>>>>> @@ -940,7 +940,7 @@
>>>>> // GNU indirect goto extension.
>>>>> Diag(Tok, diag::ext_gnu_indirect_goto);
>>>>> SourceLocation StarLoc = ConsumeToken();
>>>>> - OwningExprResult R(Actions, ParseExpression());
>>>>> + OwningExprResult R(ParseExpression());
>>>>> if (R.isInvalid()) { // Skip to the semicolon, but don't
>>>>> consume it.
>>>>> SkipUntil(tok::semi, false, true);
>>>>> return StmtError();
>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> cfe-commits mailing list
>>>>> cfe-commits at cs.uiuc.edu
>>>>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>>>>
>>>> _______________________________________________
>>>> cfe-commits mailing list
>>>> cfe-commits at cs.uiuc.edu
>>>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>>>
>>
>
More information about the cfe-commits
mailing list