Convert a big bunch of expression parsers to use smart pointers.

llvm-svn: 60906

6 files changed, 93 insertions, 92 deletions

diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
index c36c9b4ec21..201e9d3a74f 100644
--- a/clang/lib/Parse/ParseDecl.cpp
+++ b/clang/lib/Parse/ParseDecl.cpp
@@ -289,7 +289,7 @@ ParseInitDeclaratorListAfterFirstDeclarator(Declarator &D) {
     // Parse declarator '=' initializer.
     if (Tok.is(tok::equal)) {
       ConsumeToken();
-      OwningExprResult Init(Actions, ParseInitializer());
+      OwningExprResult Init(ParseInitializer());
       if (Init.isInvalid()) {
         SkipUntil(tok::semi);
         return 0;
diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp
index b8bd2eeeaa3..ac3a46a0014 100644
--- a/clang/lib/Parse/ParseExpr.cpp
+++ b/clang/lib/Parse/ParseExpr.cpp
@@ -171,7 +171,7 @@ static prec::Level getBinOpPrecedence(tok::TokenKind Kind) {
 ///
 Parser::OwningExprResult Parser::ParseExpression() {
   if (Tok.is(tok::kw_throw))
-    return Owned(ParseThrowExpression());
+    return ParseThrowExpression();
 
   OwningExprResult LHS(ParseCastExpression(false));
   if (LHS.isInvalid()) return move(LHS);
@@ -196,7 +196,7 @@ Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) {
 ///
 Parser::OwningExprResult Parser::ParseAssignmentExpression() {
   if (Tok.is(tok::kw_throw))
-    return Owned(ParseThrowExpression());
+    return ParseThrowExpression();
 
   OwningExprResult LHS(ParseCastExpression(false));
   if (LHS.isInvalid()) return move(LHS);
@@ -481,7 +481,7 @@ Parser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
 
   case tok::kw_true:
   case tok::kw_false:
-    return Owned(ParseCXXBoolLiteral());
+    return ParseCXXBoolLiteral();
 
   case tok::identifier: {      // primary-expression: identifier
                                // unqualified-id: identifier
@@ -630,15 +630,15 @@ Parser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
     // 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 Owned(ParseCXXNewExpression());
+      return ParseCXXNewExpression();
     else
-      return Owned(ParseCXXDeleteExpression());
+      return ParseCXXDeleteExpression();
 
   case tok::kw_new: // [C++] new-expression
-    return Owned(ParseCXXNewExpression());
+    return ParseCXXNewExpression();
 
   case tok::kw_delete: // [C++] delete-expression
-    return Owned(ParseCXXDeleteExpression());
+    return ParseCXXDeleteExpression();
 
   case tok::at: {
     SourceLocation AtLoc = ConsumeToken();
@@ -1100,20 +1100,20 @@ Parser::ParseParenExpression(ParenParseOption &ExprType,
 ///
 ///       primary-expression: [C99 6.5.1]
 ///         string-literal
-Parser::ExprResult Parser::ParseStringLiteralExpression() {
+Parser::OwningExprResult Parser::ParseStringLiteralExpression() {
   assert(isTokenStringLiteral() && "Not a string literal!");
-  
+
   // String concat.  Note that keywords like __func__ and __FUNCTION__ are not
   // considered to be strings for concatenation purposes.
   llvm::SmallVector<Token, 4> StringToks;
-  
+
   do {
     StringToks.push_back(Tok);
     ConsumeStringToken();
   } while (isTokenStringLiteral());
 
   // Pass the set of string tokens, ready for concatenation, to the actions.
-  return Actions.ActOnStringLiteral(&StringToks[0], StringToks.size());
+  return Owned(Actions.ActOnStringLiteral(&StringToks[0], StringToks.size()));
 }
 
 /// ParseExpressionList - Used for C/C++ (argument-)expression-list.
diff --git a/clang/lib/Parse/ParseExprCXX.cpp b/clang/lib/Parse/ParseExprCXX.cpp
index 6539341a399..5da39bae07d 100644
--- a/clang/lib/Parse/ParseExprCXX.cpp
+++ b/clang/lib/Parse/ParseExprCXX.cpp
@@ -135,7 +135,7 @@ bool Parser::MaybeParseCXXScopeSpecifier(CXXScopeSpec &SS) {
 /// That way Sema can handle and report similar errors for namespaces and the
 /// global scope.
 ///
-Parser::ExprResult Parser::ParseCXXIdExpression() {
+Parser::OwningExprResult Parser::ParseCXXIdExpression() {
   // qualified-id:
   //   '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
   //   '::' unqualified-id
@@ -152,30 +152,29 @@ Parser::ExprResult Parser::ParseCXXIdExpression() {
   //
   switch (Tok.getKind()) {
   default:
-    return Diag(Tok, diag::err_expected_unqualified_id);
+    return ExprError(Diag(Tok, diag::err_expected_unqualified_id));
 
   case tok::identifier: {
     // Consume the identifier so that we can see if it is followed by a '('.
     IdentifierInfo &II = *Tok.getIdentifierInfo();
     SourceLocation L = ConsumeToken();
-    return Actions.ActOnIdentifierExpr(CurScope, L, II,
-                                       Tok.is(tok::l_paren), &SS);
+    return Owned(Actions.ActOnIdentifierExpr(CurScope, L, II,
+                                             Tok.is(tok::l_paren), &SS));
   }
 
   case tok::kw_operator: {
     SourceLocation OperatorLoc = Tok.getLocation();
     if (OverloadedOperatorKind Op = TryParseOperatorFunctionId()) {
-      return Actions.ActOnCXXOperatorFunctionIdExpr(CurScope, OperatorLoc, Op, 
-                                                    Tok.is(tok::l_paren), SS);
+      return Owned(Actions.ActOnCXXOperatorFunctionIdExpr(
+                         CurScope, OperatorLoc, Op, Tok.is(tok::l_paren), SS));
     } else if (TypeTy *Type = ParseConversionFunctionId()) {
-      return Actions.ActOnCXXConversionFunctionExpr(CurScope, OperatorLoc,
-                                                    Type, Tok.is(tok::l_paren), 
-                                                    SS);
+      return Owned(Actions.ActOnCXXConversionFunctionExpr(
+                         CurScope, OperatorLoc, Type, Tok.is(tok::l_paren),SS));
     }
-     
+
     // We already complained about a bad conversion-function-id,
     // above.
-    return true;
+    return ExprError();
   }
 
   } // switch.
@@ -192,7 +191,7 @@ Parser::ExprResult Parser::ParseCXXIdExpression() {
 ///         'reinterpret_cast' '<' type-name '>' '(' expression ')'
 ///         'const_cast' '<' type-name '>' '(' expression ')'
 ///
-Parser::ExprResult Parser::ParseCXXCasts() {
+Parser::OwningExprResult Parser::ParseCXXCasts() {
   tok::TokenKind Kind = Tok.getKind();
   const char *CastName = 0;     // For error messages
 
@@ -208,18 +207,18 @@ Parser::ExprResult Parser::ParseCXXCasts() {
   SourceLocation LAngleBracketLoc = Tok.getLocation();
 
   if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
-    return ExprResult(true);
+    return ExprError();
 
   TypeTy *CastTy = ParseTypeName();
   SourceLocation RAngleBracketLoc = Tok.getLocation();
 
   if (ExpectAndConsume(tok::greater, diag::err_expected_greater))
-    return Diag(LAngleBracketLoc, diag::note_matching) << "<";
+    return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << "<");
 
   SourceLocation LParenLoc = Tok.getLocation(), RParenLoc;
 
   if (Tok.isNot(tok::l_paren))
-    return Diag(Tok, diag::err_expected_lparen_after) << CastName;
+    return ExprError(Diag(Tok, diag::err_expected_lparen_after) << CastName);
 
   OwningExprResult Result(ParseSimpleParenExpression(RParenLoc));
 
@@ -228,7 +227,7 @@ Parser::ExprResult Parser::ParseCXXCasts() {
                                        LAngleBracketLoc, CastTy, RAngleBracketLoc,
                                        LParenLoc, Result.release(), RParenLoc);
 
-  return Result.result();
+  return move(Result);
 }
 
 /// ParseCXXTypeid - This handles the C++ typeid expression.
@@ -237,7 +236,7 @@ Parser::ExprResult Parser::ParseCXXCasts() {
 ///         'typeid' '(' expression ')'
 ///         'typeid' '(' type-id ')'
 ///
-Parser::ExprResult Parser::ParseCXXTypeid() {
+Parser::OwningExprResult Parser::ParseCXXTypeid() {
   assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
 
   SourceLocation OpLoc = ConsumeToken();
@@ -247,7 +246,7 @@ Parser::ExprResult Parser::ParseCXXTypeid() {
   // typeid expressions are always parenthesized.
   if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
       "typeid"))
-    return ExprResult(true);
+    return ExprError();
 
   OwningExprResult Result(Actions);
 
@@ -258,7 +257,7 @@ Parser::ExprResult Parser::ParseCXXTypeid() {
     MatchRHSPunctuation(tok::r_paren, LParenLoc);
 
     if (!Ty)
-      return ExprResult(true);
+      return ExprError();
 
     Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
                                     Ty, RParenLoc);
@@ -276,7 +275,7 @@ Parser::ExprResult Parser::ParseCXXTypeid() {
     }
   }
 
-  return Result.result();
+  return move(Result);
 }
 
 /// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
@@ -284,19 +283,19 @@ Parser::ExprResult Parser::ParseCXXTypeid() {
 ///       boolean-literal: [C++ 2.13.5]
 ///         'true'
 ///         'false'
-Parser::ExprResult Parser::ParseCXXBoolLiteral() {
+Parser::OwningExprResult Parser::ParseCXXBoolLiteral() {
   tok::TokenKind Kind = Tok.getKind();
-  return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
+  return Owned(Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind));
 }
 
 /// ParseThrowExpression - This handles the C++ throw expression.
 ///
 ///       throw-expression: [C++ 15]
 ///         'throw' assignment-expression[opt]
-Parser::ExprResult Parser::ParseThrowExpression() {
+Parser::OwningExprResult Parser::ParseThrowExpression() {
   assert(Tok.is(tok::kw_throw) && "Not throw!");
   SourceLocation ThrowLoc = ConsumeToken();           // Eat the throw token.
-  
+
   // If the current token isn't the start of an assignment-expression,
   // then the expression is not present.  This handles things like:
   //   "C ? throw : (void)42", which is crazy but legal.
@@ -307,12 +306,12 @@ Parser::ExprResult Parser::ParseThrowExpression() {
   case tok::r_brace:
   case tok::colon:
   case tok::comma:
-    return Actions.ActOnCXXThrow(ThrowLoc);
+    return Owned(Actions.ActOnCXXThrow(ThrowLoc));
 
   default:
     OwningExprResult Expr(ParseAssignmentExpression());
-    if (Expr.isInvalid()) return Expr.result();
-    return Actions.ActOnCXXThrow(ThrowLoc, Expr.release());
+    if (Expr.isInvalid()) return move(Expr);
+    return Owned(Actions.ActOnCXXThrow(ThrowLoc, Expr.release()));
   }
 }
 
@@ -321,10 +320,10 @@ Parser::ExprResult Parser::ParseThrowExpression() {
 /// C++ 9.3.2: In the body of a non-static member function, the keyword this is
 /// a non-lvalue expression whose value is the address of the object for which
 /// the function is called.
-Parser::ExprResult Parser::ParseCXXThis() {
+Parser::OwningExprResult Parser::ParseCXXThis() {
   assert(Tok.is(tok::kw_this) && "Not 'this'!");
   SourceLocation ThisLoc = ConsumeToken();
-  return Actions.ActOnCXXThis(ThisLoc);
+  return Owned(Actions.ActOnCXXThis(ThisLoc));
 }
 
 /// ParseCXXTypeConstructExpression - Parse construction of a specified type.
@@ -336,7 +335,8 @@ Parser::ExprResult Parser::ParseCXXThis() {
 ///         simple-type-specifier '(' expression-list[opt] ')'      [C++ 5.2.3]
 ///         typename-specifier '(' expression-list[opt] ')'         [TODO]
 ///
-Parser::ExprResult Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
+Parser::OwningExprResult
+Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
   Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
   TypeTy *TypeRep = Actions.ActOnTypeName(CurScope, DeclaratorInfo).Val;
 
@@ -349,7 +349,7 @@ Parser::ExprResult Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
   if (Tok.isNot(tok::r_paren)) {
     if (ParseExpressionList(Exprs, CommaLocs)) {
       SkipUntil(tok::r_paren);
-      return ExprResult(true);
+      return ExprError();
     }
   }
 
@@ -358,10 +358,10 @@ Parser::ExprResult Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
 
   assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
          "Unexpected number of commas!");
-  return Actions.ActOnCXXTypeConstructExpr(DS.getSourceRange(), TypeRep,
-                                           LParenLoc,
-                                           Exprs.take(), Exprs.size(),
-                                           &CommaLocs[0], RParenLoc);
+  return Owned(Actions.ActOnCXXTypeConstructExpr(DS.getSourceRange(), TypeRep,
+                                                 LParenLoc,
+                                                 Exprs.take(), Exprs.size(),
+                                                 &CommaLocs[0], RParenLoc));
 }
 
 /// ParseCXXCondition - if/switch/while/for condition expression.
@@ -662,7 +662,7 @@ Parser::TypeTy *Parser::ParseConversionFunctionId() {
 ///                   '(' expression-list[opt] ')'
 /// [C++0x]           braced-init-list                                   [TODO]
 ///
-Parser::ExprResult Parser::ParseCXXNewExpression()
+Parser::OwningExprResult Parser::ParseCXXNewExpression()
 {
   assert((Tok.is(tok::coloncolon) || Tok.is(tok::kw_new)) &&
          "Expected :: or 'new' keyword");
@@ -692,13 +692,13 @@ Parser::ExprResult Parser::ParseCXXNewExpression()
     PlacementLParen = ConsumeParen();
     if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
       SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
-      return true;
+      return ExprError();
     }
 
     PlacementRParen = MatchRHSPunctuation(tok::r_paren, PlacementLParen);
     if (PlacementRParen.isInvalid()) {
       SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
-      return true;
+      return ExprError();
     }
 
     if (PlacementArgs.empty()) {
@@ -734,7 +734,7 @@ Parser::ExprResult Parser::ParseCXXNewExpression()
   }
   if (DeclaratorInfo.getInvalidType()) {
     SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
-    return true;
+    return ExprError();
   }
 
   ExprVector ConstructorArgs(Actions);
@@ -746,21 +746,21 @@ Parser::ExprResult Parser::ParseCXXNewExpression()
       CommaLocsTy CommaLocs;
       if (ParseExpressionList(ConstructorArgs, CommaLocs)) {
         SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
-        return true;
+        return ExprError();
       }
     }
     ConstructorRParen = MatchRHSPunctuation(tok::r_paren, ConstructorLParen);
     if (ConstructorRParen.isInvalid()) {
       SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
-      return true;
+      return ExprError();
     }
   }
 
-  return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
-                             PlacementArgs.take(), PlacementArgs.size(),
-                             PlacementRParen, ParenTypeId, DeclaratorInfo,
-                             ConstructorLParen, ConstructorArgs.take(),
-                             ConstructorArgs.size(), ConstructorRParen);
+  return Owned(Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
+                                   PlacementArgs.take(), PlacementArgs.size(),
+                                   PlacementRParen, ParenTypeId, DeclaratorInfo,
+                                   ConstructorLParen, ConstructorArgs.take(),
+                                   ConstructorArgs.size(), ConstructorRParen));
 }
 
 /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
@@ -825,7 +825,7 @@ bool Parser::ParseExpressionListOrTypeId(ExprListTy &PlacementArgs,
 ///        delete-expression:
 ///                   '::'[opt] 'delete' cast-expression
 ///                   '::'[opt] 'delete' '[' ']' cast-expression
-Parser::ExprResult Parser::ParseCXXDeleteExpression()
+Parser::OwningExprResult Parser::ParseCXXDeleteExpression()
 {
   assert((Tok.is(tok::coloncolon) || Tok.is(tok::kw_delete)) &&
          "Expected :: or 'delete' keyword");
@@ -848,13 +848,13 @@ Parser::ExprResult Parser::ParseCXXDeleteExpression()
     SourceLocation LHS = ConsumeBracket();
     SourceLocation RHS = MatchRHSPunctuation(tok::r_square, LHS);
     if (RHS.isInvalid())
-      return true;
+      return ExprError();
   }
 
   OwningExprResult Operand(ParseCastExpression(false));
   if (Operand.isInvalid())
-    return Operand.result();
+    return move(Operand);
 
-  return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete,
-                                Operand.release());
+  return Owned(Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete,
+                                      Operand.release()));
 }
diff --git a/clang/lib/Parse/ParseInit.cpp b/clang/lib/Parse/ParseInit.cpp
index a6a2d8179e9..26c40a7116b 100644
--- a/clang/lib/Parse/ParseInit.cpp
+++ b/clang/lib/Parse/ParseInit.cpp
@@ -57,10 +57,10 @@ static bool MayBeDesignationStart(tok::TokenKind K, Preprocessor &PP) {
 /// initializer (because it is an expression).  We need to consider this case
 /// when parsing array designators.
 ///
-Parser::ExprResult Parser::
+Parser::OwningExprResult Parser::
 ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
                                         unsigned InitNum) {
-  
+
   // If this is the old-style GNU extension:
   //   designation ::= identifier ':'
   // Handle it as a field designator.  Otherwise, this must be the start of a
@@ -94,7 +94,7 @@ ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
       
       if (Tok.isNot(tok::identifier)) {
         Diag(Tok.getLocation(), diag::err_expected_field_designator);
-        return ExprResult(true);
+        return ExprError();
       }
       
       Desig->AddDesignator(Designator::getField(Tok.getIdentifierInfo()));
@@ -136,8 +136,8 @@ ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
       
       IdentifierInfo *Name = Tok.getIdentifierInfo();
       SourceLocation NameLoc = ConsumeToken();
-      return ParseAssignmentExprWithObjCMessageExprStart(StartLoc, NameLoc,
-                                                         Name, 0);
+      return Owned(ParseAssignmentExprWithObjCMessageExprStart(
+                       StartLoc, NameLoc, Name, 0));
     }
     
     // Note that we parse this as an assignment expression, not a constant
@@ -146,7 +146,7 @@ ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
     OwningExprResult Idx(ParseAssignmentExpression());
     if (Idx.isInvalid()) {
       SkipUntil(tok::r_square);
-      return Idx.result();
+      return move(Idx);
     }
     
     // Given an expression, we could either have a designator (if the next
@@ -167,10 +167,10 @@ ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
         else
           Diag(Tok, diag::err_expected_equal_designator);
       }
-      
-      return ParseAssignmentExprWithObjCMessageExprStart(StartLoc,
-                                                         SourceLocation(), 
-                                                         0, Idx.release());
+
+      return Owned(ParseAssignmentExprWithObjCMessageExprStart(StartLoc,
+                                                               SourceLocation(),
+                                                             0, Idx.release()));
     }
 
     // Create designation if we haven't already.
@@ -188,7 +188,7 @@ ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
       OwningExprResult RHS(ParseConstantExpression());
       if (RHS.isInvalid()) {
         SkipUntil(tok::r_square);
-        return RHS.result();
+        return move(RHS);
       }
       Desig->AddDesignator(Designator::getArrayRange(Idx.release(),
                                                      RHS.release()));
@@ -202,13 +202,13 @@ ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
   // without a designator is when we have an objc message send.  That case is
   // handled and returned from above.
   assert(Desig && "Designator didn't get created?");
-  
+
   // Handle a normal designator sequence end, which is an equal.
   if (Tok.is(tok::equal)) {
     ConsumeToken();
     return ParseInitializer();
   }
-  
+
   // We read some number of designators and found something that isn't an = or
   // an initializer.  If we have exactly one array designator, this
   // is the GNU 'designation: array-designator' extension.  Otherwise, it is a
@@ -219,9 +219,9 @@ ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
     Diag(Tok, diag::ext_gnu_missing_equal_designator);
     return ParseInitializer();
   }
-  
+
   Diag(Tok, diag::err_expected_equal_designator);
-  return true;
+  return ExprError();
 }
 
 
@@ -237,7 +237,7 @@ ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
 ///         designation[opt] initializer
 ///         initializer-list ',' designation[opt] initializer
 ///
-Parser::ExprResult Parser::ParseBraceInitializer() {
+Parser::OwningExprResult Parser::ParseBraceInitializer() {
   SourceLocation LBraceLoc = ConsumeBrace();
 
   /// InitExprs - This is the actual list of expressions contained in the
@@ -253,15 +253,15 @@ Parser::ExprResult Parser::ParseBraceInitializer() {
   if (Tok.is(tok::r_brace)) {
     Diag(LBraceLoc, diag::ext_gnu_empty_initializer);
     // Match the '}'.
-    return Actions.ActOnInitList(LBraceLoc, 0, 0, InitExprDesignations,
-                                 ConsumeBrace());
+    return Owned(Actions.ActOnInitList(LBraceLoc, 0, 0, InitExprDesignations,
+                                       ConsumeBrace()));
   }
-  
+
   bool InitExprsOk = true;
-  
+
   while (1) {
     // Parse: designation[opt] initializer
-    
+
     // If we know that this cannot be a designation, just parse the nested
     // initializer directly.
     OwningExprResult SubElt(Actions);
@@ -301,19 +301,20 @@ Parser::ExprResult Parser::ParseBraceInitializer() {
 
     // If we don't have a comma continued list, we're done.
     if (Tok.isNot(tok::comma)) break;
-    
+
     // TODO: save comma locations if some client cares.
     ConsumeToken();
-    
+
     // Handle trailing comma.
     if (Tok.is(tok::r_brace)) break;
   }
   if (InitExprsOk && Tok.is(tok::r_brace))
-    return Actions.ActOnInitList(LBraceLoc, InitExprs.take(), InitExprs.size(),
-                                 InitExprDesignations, ConsumeBrace());
-  
+    return Owned(Actions.ActOnInitList(LBraceLoc, InitExprs.take(),
+                                       InitExprs.size(),
+                                       InitExprDesignations, ConsumeBrace()));
+
   // Match the '}'.
   MatchRHSPunctuation(tok::r_brace, LBraceLoc);
-  return ExprResult(true); // an error occurred.
+  return ExprError(); // an error occurred.
 }
 
diff --git a/clang/lib/Parse/ParseObjc.cpp b/clang/lib/Parse/ParseObjc.cpp
index 50d6af97b7e..1966512239f 100644
--- a/clang/lib/Parse/ParseObjc.cpp
+++ b/clang/lib/Parse/ParseObjc.cpp
@@ -1567,7 +1567,7 @@ Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc,
 }
 
 Parser::ExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) {
-  OwningExprResult Res(Actions, ParseStringLiteralExpression());
+  OwningExprResult Res(ParseStringLiteralExpression());
   if (Res.isInvalid()) return Res.result();
   
   // @"foo" @"bar" is a valid concatenated string.  Eat any subsequent string
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index cf512ad1dd9..1cd7c0e0750 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -669,7 +669,7 @@ Parser::OwningExprResult Parser::ParseAsmStringLiteral() {
     return ExprError();
   }
 
-  OwningExprResult Res(Actions, ParseStringLiteralExpression());
+  OwningExprResult Res(ParseStringLiteralExpression());
   if (Res.isInvalid()) return move(Res);
 
   // TODO: Diagnose: wide string literal in 'asm'