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 >>>>> [email protected] >>>>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits >>>> >>>> _______________________________________________ >>>> cfe-commits mailing list >>>> [email protected] >>>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits >>> >> > _______________________________________________ cfe-commits mailing list [email protected] http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
