Modify the move emulation according to the excellent design of Howard Hinnant. Makes for much nicer syntax when smart pointers are used consistently. Also, start converting internal argument passing of Parser to smart pointers.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@60809 91177308-0d34-0410-b5e6-96231b3b80d8

11 files changed, 307 insertions, 275 deletions

diff --git a/include/clang/Parse/Ownership.h b/include/clang/Parse/Ownership.h
index fc27605071..e2464ca8da 100644
--- a/include/clang/Parse/Ownership.h
+++ b/include/clang/Parse/Ownership.h
@@ -83,50 +83,49 @@ namespace clang
   /// the individual pointers, not the array holding them.
   template <ASTDestroyer Destroyer> class ASTMultiPtr;
 
-  /// Move emulation helper for ASTOwningResult
-  template <ASTDestroyer Destroyer>
-  class ASTResultMover
-  {
-    ASTOwningResult<Destroyer> &Moved;
+  namespace moving {
+    /// Move emulation helper for ASTOwningResult. NEVER EVER use this class
+    /// directly if you don't know what you're doing.
+    template <ASTDestroyer Destroyer>
+    class ASTResultMover
+    {
+      ASTOwningResult<Destroyer> &Moved;
 
-  public:
-    ASTResultMover(ASTOwningResult<Destroyer> &moved) : Moved(moved) {}
+    public:
+      ASTResultMover(ASTOwningResult<Destroyer> &moved) : Moved(moved) {}
 
-    ASTOwningResult<Destroyer> * operator ->() { return &Moved; }
+      ASTOwningResult<Destroyer> * operator ->() { return &Moved; }
+    };
 
-    // For the transition phase.
-    operator void*();
+    /// Move emulation helper for ASTOwningPtr. NEVER EVER use this class
+    /// directly if you don't know what you're doing.
+    template <ASTDestroyer Destroyer>
+    class ASTPtrMover
+    {
+      ASTOwningPtr<Destroyer> &Moved;
 
-    // For the transition phase.
-    operator ActionBase::ActionResult<DestroyerToUID<Destroyer>::UID>();
-  };
+    public:
+      ASTPtrMover(ASTOwningPtr<Destroyer> &moved) : Moved(moved) {}
 
-  /// Move emulation helper for ASTOwningPtr
-  template <ASTDestroyer Destroyer>
-  class ASTPtrMover
-  {
-    ASTOwningPtr<Destroyer> &Moved;
-
-  public:
-    ASTPtrMover(ASTOwningPtr<Destroyer> &moved) : Moved(moved) {}
+      ASTOwningPtr<Destroyer> * operator ->() { return &Moved; }
+    };
 
-    ASTOwningPtr<Destroyer> * operator ->() { return &Moved; }
+    /// Move emulation helper for ASTMultiPtr. NEVER EVER use this class
+    /// directly if you don't know what you're doing.
+    template <ASTDestroyer Destroyer>
+    class ASTMultiMover
+    {
+      ASTMultiPtr<Destroyer> &Moved;
 
-    operator void*();
-  };
+    public:
+      ASTMultiMover(ASTMultiPtr<Destroyer> &moved) : Moved(moved) {}
 
-  /// Move emulation helper for ASTMultiPtr
-  template <ASTDestroyer Destroyer>
-  class ASTMultiMover
-  {
-    ASTMultiPtr<Destroyer> &Moved;
+      ASTMultiPtr<Destroyer> * operator ->() { return &Moved; }
 
-  public:
-    ASTMultiMover(ASTMultiPtr<Destroyer> &moved) : Moved(moved) {}
-
-    /// Reset the moved object's internal structures.
-    void release();
-  };
+      /// Reset the moved object's internal structures.
+      void release();
+    };
+  }
 
   template <ASTDestroyer Destroyer>
   class ASTOwningResult
@@ -135,11 +134,11 @@ namespace clang
     void *Node;
     bool Invalid;
 
-    friend class ASTResultMover<Destroyer>;
+    friend class moving::ASTResultMover<Destroyer>;
     friend class ASTOwningPtr<Destroyer>;
 
-    ASTOwningResult(const ASTOwningResult&); // DO NOT IMPLEMENT
-    ASTOwningResult& operator =(const ASTOwningResult&); // DO NOT IMPLEMENT
+    ASTOwningResult(ASTOwningResult&); // DO NOT IMPLEMENT
+    ASTOwningResult& operator =(ASTOwningResult&); // DO NOT IMPLEMENT
 
     void destroy() {
       if (Node) {
@@ -148,12 +147,6 @@ namespace clang
       }
     }
 
-    void * take() {
-      if (Invalid)
-        return 0;
-      return Node;
-    }
-
   public:
     typedef ActionBase::ActionResult<DestroyerToUID<Destroyer>::UID> DumbResult;
 
@@ -170,13 +163,13 @@ namespace clang
     ASTOwningResult(ActionBase &actions, const DumbResult &res)
       : Actions(&actions), Node(res.Val), Invalid(res.isInvalid) {}
     /// Move from another owning result
-    ASTOwningResult(ASTResultMover<Destroyer> mover)
+    ASTOwningResult(moving::ASTResultMover<Destroyer> mover)
       : Actions(mover->Actions), Node(mover->take()), Invalid(mover->Invalid) {}
     /// Move from an owning pointer
-    ASTOwningResult(ASTPtrMover<Destroyer> mover);
+    ASTOwningResult(moving::ASTPtrMover<Destroyer> mover);
 
     /// Move assignment from another owning result
-    ASTOwningResult & operator =(ASTResultMover<Destroyer> mover) {
+    ASTOwningResult & operator =(moving::ASTResultMover<Destroyer> mover) {
       Actions = mover->Actions;
       Node = mover->take();
       Invalid = mover->Invalid;
@@ -184,7 +177,7 @@ namespace clang
     }
 
     /// Move assignment from an owning ptr
-    ASTOwningResult & operator =(ASTPtrMover<Destroyer> mover);
+    ASTOwningResult & operator =(moving::ASTPtrMover<Destroyer> mover);
 
     /// Assignment from a raw pointer. Takes ownership - beware!
     ASTOwningResult & operator =(void *raw)
@@ -214,9 +207,30 @@ namespace clang
     /// valid and non-null.
     bool isUsable() const { return !Invalid && Node; }
 
+    /// Take outside ownership of the raw pointer.
+    void * take() {
+      if (Invalid)
+        return 0;
+      void *tmp = Node;
+      Node = 0;
+      return tmp;
+    }
+
+    /// Alias for interface familiarity with unique_ptr.
+    void * release() {
+      return take();
+    }
+
+    /// Pass ownership to a classical ActionResult.
+    DumbResult result() {
+      if (Invalid)
+        return true;
+      return Node;
+    }
+
     /// Move hook
-    ASTResultMover<Destroyer> move() {
-      return ASTResultMover<Destroyer>(*this);
+    operator moving::ASTResultMover<Destroyer>() {
+      return moving::ASTResultMover<Destroyer>(*this);
     }
   };
 
@@ -226,11 +240,11 @@ namespace clang
     ActionBase *Actions;
     void *Node;
 
-    friend class ASTPtrMover<Destroyer>;
+    friend class moving::ASTPtrMover<Destroyer>;
     friend class ASTOwningResult<Destroyer>;
 
-    ASTOwningPtr(const ASTOwningPtr&); // DO NOT IMPLEMENT
-    ASTOwningPtr& operator =(const ASTOwningPtr&); // DO NOT IMPLEMENT
+    ASTOwningPtr(ASTOwningPtr&); // DO NOT IMPLEMENT
+    ASTOwningPtr& operator =(ASTOwningPtr&); // DO NOT IMPLEMENT
 
     void destroy() {
       if (Node) {
@@ -245,20 +259,20 @@ namespace clang
     ASTOwningPtr(ActionBase &actions, void *node)
       : Actions(&actions), Node(node) {}
     /// Move from another owning pointer
-    ASTOwningPtr(ASTPtrMover<Destroyer> mover)
+    ASTOwningPtr(moving::ASTPtrMover<Destroyer> mover)
       : Actions(mover->Actions), Node(mover->take()) {}
     /// Move from an owning result
-    ASTOwningPtr(ASTResultMover<Destroyer> mover);
+    ASTOwningPtr(moving::ASTResultMover<Destroyer> mover);
 
     /// Move assignment from another owning pointer
-    ASTOwningPtr & operator =(ASTPtrMover<Destroyer> mover) {
+    ASTOwningPtr & operator =(moving::ASTPtrMover<Destroyer> mover) {
       Actions = mover->Actions;
       Node = mover->take();
       return *this;
     }
 
     /// Move assignment from an owning result
-    ASTOwningPtr & operator =(ASTResultMover<Destroyer> mover);
+    ASTOwningPtr & operator =(moving::ASTResultMover<Destroyer> mover);
 
     /// Assignment from a raw pointer. Takes ownership - beware!
     ASTOwningPtr & operator =(void *raw)
@@ -271,9 +285,21 @@ namespace clang
     /// Access to the raw pointer.
     void * get() const { return Node; }
 
+    /// Release the raw pointer.
+    void * take() {
+      void *tmp = Node;
+      Node = 0;
+      return tmp;
+    }
+
+    /// Alias for interface familiarity with unique_ptr.
+    void * release() {
+      return take();
+    }
+
     /// Move hook
-    ASTPtrMover<Destroyer> move() {
-      return ASTPtrMover<Destroyer>(*this);
+    operator moving::ASTPtrMover<Destroyer>() {
+      return moving::ASTPtrMover<Destroyer>(*this);
     }
   };
 
@@ -284,9 +310,9 @@ namespace clang
     void **Nodes;
     unsigned Count;
 
-    friend class ASTMultiMover<Destroyer>;
+    friend class moving::ASTMultiMover<Destroyer>;
 
-    ASTMultiPtr(const ASTMultiPtr&); // DO NOT IMPLEMENT
+    ASTMultiPtr(ASTMultiPtr&); // DO NOT IMPLEMENT
     // Reference member prevents copy assignment.
 
     void destroy() {
@@ -303,15 +329,14 @@ namespace clang
     ASTMultiPtr(ActionBase &actions, void **nodes, unsigned count)
       : Actions(actions), Nodes(nodes), Count(count) {}
     /// Move constructor
-    ASTMultiPtr(ASTMultiMover<Destroyer> mover)
+    ASTMultiPtr(moving::ASTMultiMover<Destroyer> mover)
       : Actions(mover->Actions), Nodes(mover->Nodes), Count(mover->Count) {
-      mover->Nodes = 0;
-      mover->Count = 0;
+      mover.release();
     }
 
     /// Move assignment
-    ASTMultiPtr & operator =(ASTMultiMover<Destroyer> mover) {
-      Actions = mover->Actions;
+    ASTMultiPtr & operator =(moving::ASTMultiMover<Destroyer> mover) {
+      destroy();
       Nodes = mover->Nodes;
       Count = mover->Count;
       mover.release();
@@ -325,45 +350,27 @@ namespace clang
     unsigned size() const { return Count; }
 
     /// Move hook
-    ASTMultiMover<Destroyer> move() {
-      return ASTMultiMover<Destroyer>(*this);
+    operator moving::ASTMultiMover<Destroyer>() {
+      return moving::ASTMultiMover<Destroyer>(*this);
     }
   };
 
   // Out-of-line implementations due to definition dependencies
 
   template <ASTDestroyer Destroyer> inline
-  ASTResultMover<Destroyer>::operator void*() {
-    return Moved.take();
-  }
-
-  template <ASTDestroyer Destroyer> inline
-  ASTResultMover<Destroyer>::operator
-                    ActionBase::ActionResult<DestroyerToUID<Destroyer>::UID>()
-  {
-    if(Moved.isInvalid())
-      return true;
-    return Moved.take();
-  }
-
-  template <ASTDestroyer Destroyer> inline
-  ASTPtrMover<Destroyer>::operator void*() {
-    return Moved.take();
-  }
-
-  template <ASTDestroyer Destroyer> inline
-  void ASTMultiMover<Destroyer>::release() {
+  void moving::ASTMultiMover<Destroyer>::release() {
     Moved.Nodes = 0;
     Moved.Count = 0;
   }
 
   template <ASTDestroyer Destroyer> inline
-  ASTOwningResult<Destroyer>::ASTOwningResult(ASTPtrMover<Destroyer> mover)
+  ASTOwningResult<Destroyer>::ASTOwningResult(
+                                          moving::ASTPtrMover<Destroyer> mover)
     : Actions(mover->Actions), Node(mover->take()), Invalid(false) {}
 
   template <ASTDestroyer Destroyer> inline
   ASTOwningResult<Destroyer> &
-  ASTOwningResult<Destroyer>::operator =(ASTPtrMover<Destroyer> mover) {
+  ASTOwningResult<Destroyer>::operator =(moving::ASTPtrMover<Destroyer> mover) {
     Actions = mover->Actions;
     Node = mover->take();
     Invalid = false;
@@ -371,17 +378,34 @@ namespace clang
   }
 
   template <ASTDestroyer Destroyer> inline
-  ASTOwningPtr<Destroyer>::ASTOwningPtr(ASTResultMover<Destroyer> mover)
+  ASTOwningPtr<Destroyer>::ASTOwningPtr(moving::ASTResultMover<Destroyer> mover)
     : Actions(mover->Actions), Node(mover->take()) {
   }
 
   template <ASTDestroyer Destroyer> inline
   ASTOwningPtr<Destroyer> &
-  ASTOwningPtr<Destroyer>::operator =(ASTResultMover<Destroyer> mover) {
+  ASTOwningPtr<Destroyer>::operator =(moving::ASTResultMover<Destroyer> mover) {
     Actions = mover->Actions;
     Node = mover->take();
     return *this;
   }
+
+  // Move overloads.
+
+  template <ASTDestroyer Destroyer> inline
+  ASTOwningResult<Destroyer> move(ASTOwningResult<Destroyer> &ptr) {
+    return ASTOwningResult<Destroyer>(moving::ASTResultMover<Destroyer>(ptr));
+  }
+
+  template <ASTDestroyer Destroyer> inline
+  ASTOwningPtr<Destroyer> move(ASTOwningPtr<Destroyer> &ptr) {
+    return ASTOwningPtr<Destroyer>(moving::ASTPtrMover<Destroyer>(ptr));
+  }
+
+  template <ASTDestroyer Destroyer> inline
+  ASTMultiPtr<Destroyer> move(ASTMultiPtr<Destroyer> &ptr) {
+    return ASTMultiPtr<Destroyer>(moving::ASTMultiMover<Destroyer>(ptr));
+  }
 }
 
 #endif
diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h
index dedad120ba..ffd70a8971 100644
--- a/include/clang/Parse/Parser.h
+++ b/include/clang/Parse/Parser.h
@@ -379,8 +379,8 @@ private:
   DeclTy *ParseDeclarationOrFunctionDefinition();
   DeclTy *ParseFunctionDefinition(Declarator &D);
   void ParseKNRParamDeclarations(Declarator &D);
-  ExprResult ParseSimpleAsm();
-  ExprResult ParseAsmStringLiteral();
+  OwningExprResult ParseSimpleAsm();
+  OwningExprResult ParseAsmStringLiteral();
 
   // Objective-C External Declarations
   DeclTy *ParseObjCAtDirectives(); 
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index 242c1b3c6f..e7f4fc92ea 100644
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -132,7 +132,7 @@ AttributeList *Parser::ParseAttributes() {
                 SkipUntil(tok::r_paren);
                 break;
               } else {
-                ArgExprs.push_back(ArgExpr.move());
+                ArgExprs.push_back(ArgExpr.release());
               }
               if (Tok.isNot(tok::comma))
                 break;
@@ -164,7 +164,7 @@ AttributeList *Parser::ParseAttributes() {
                 SkipUntil(tok::r_paren);
                 break;
               } else {
-                ArgExprs.push_back(ArgExpr.move());
+                ArgExprs.push_back(ArgExpr.release());
               }
               if (Tok.isNot(tok::comma))
                 break;
@@ -270,13 +270,13 @@ ParseInitDeclaratorListAfterFirstDeclarator(Declarator &D) {
   while (1) {
     // If a simple-asm-expr is present, parse it.
     if (Tok.is(tok::kw_asm)) {
-      OwningExprResult AsmLabel(Actions, ParseSimpleAsm());
+      OwningExprResult AsmLabel(ParseSimpleAsm());
       if (AsmLabel.isInvalid()) {
         SkipUntil(tok::semi);
         return 0;
       }
       
-      D.setAsmLabel(AsmLabel.move());
+      D.setAsmLabel(AsmLabel.release());
     }
     
     // If attributes are present, parse them.
@@ -294,7 +294,7 @@ ParseInitDeclaratorListAfterFirstDeclarator(Declarator &D) {
         SkipUntil(tok::semi);
         return 0;
       }
-      Actions.AddInitializerToDecl(LastDeclInGroup, Init.move());
+      Actions.AddInitializerToDecl(LastDeclInGroup, Init.release());
     } else if (Tok.is(tok::l_paren)) {
       // Parse C++ direct initializer: '(' expression-list ')'
       SourceLocation LParenLoc = ConsumeParen();
@@ -846,7 +846,7 @@ ParseStructDeclaration(DeclSpec &DS,
       if (Res.isInvalid())
         SkipUntil(tok::semi, true, true);
       else
-        DeclaratorInfo.BitfieldSize = Res.move();
+        DeclaratorInfo.BitfieldSize = Res.release();
     }
     
     // If attributes exist after the declarator, parse them.
@@ -1087,7 +1087,7 @@ void Parser::ParseEnumBody(SourceLocation StartLoc, DeclTy *EnumDecl) {
                                                       LastEnumConstDecl,
                                                       IdentLoc, Ident,
                                                       EqualLoc,
-                                                      AssignedVal.move());
+                                                      AssignedVal.release());
     EnumConstantDecls.push_back(EnumConstDecl);
     LastEnumConstDecl = EnumConstDecl;
     
@@ -1802,7 +1802,7 @@ void Parser::ParseFunctionDeclarator(SourceLocation LParenLoc, Declarator &D,
         } else {
           // Inform the actions module about the default argument
           Actions.ActOnParamDefaultArgument(Param, EqualLoc,
-                                            DefArgResult.move());
+                                            DefArgResult.release());
         }
       }
       
@@ -1973,7 +1973,7 @@ void Parser::ParseBracketDeclarator(Declarator &D) {
   // Remember that we parsed a pointer type, and remember the type-quals.
   D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(),
                                           StaticLoc.isValid(), isStar,
-                                          NumElements.move(), StartLoc));
+                                          NumElements.release(), StartLoc));
 }
 
 /// [GNU]   typeof-specifier:
@@ -2000,7 +2000,7 @@ void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
     const char *PrevSpec = 0;
     // Check for duplicate type specifiers.
     if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, 
-                           Result.move()))
+                           Result.release()))
       Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
 
     // FIXME: Not accurate, the range gets one token more than it should.
@@ -2035,7 +2035,7 @@ void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
     const char *PrevSpec = 0;
     // Check for duplicate type specifiers (e.g. "int typeof(int)").
     if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, 
-                           Result.move()))
+                           Result.release()))
       Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
   }
   DS.SetRangeEnd(RParenLoc);
diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp
index 4b92c91863..c3b94bc628 100644
--- a/lib/Parse/ParseDeclCXX.cpp
+++ b/lib/Parse/ParseDeclCXX.cpp
@@ -529,8 +529,8 @@ Parser::DeclTy *Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS) {
     // See Sema::ActOnCXXMemberDeclarator for details.
     LastDeclInGroup = Actions.ActOnCXXMemberDeclarator(CurScope, AS,
                                                        DeclaratorInfo,
-                                                       BitfieldSize.move(),
-                                                       Init.move(),
+                                                       BitfieldSize.release(),
+                                                       Init.release(),
                                                        LastDeclInGroup);
 
     // If we don't have a comma, it is either the end of the list (a ';')
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
index 9a8956c274..4cf7c1e4f7 100644
--- a/lib/Parse/ParseExpr.cpp
+++ b/lib/Parse/ParseExpr.cpp
@@ -174,9 +174,9 @@ Parser::ExprResult Parser::ParseExpression() {
     return ParseThrowExpression();
 
   OwningExprResult LHS(Actions, ParseCastExpression(false));
-  if (LHS.isInvalid()) return LHS.move();
+  if (LHS.isInvalid()) return LHS.result();
   
-  return ParseRHSOfBinaryExpression(LHS.move(), prec::Comma);
+  return ParseRHSOfBinaryExpression(LHS.result(), prec::Comma);
 }
 
 /// This routine is called when the '@' is seen and consumed. 
@@ -186,9 +186,9 @@ Parser::ExprResult Parser::ParseExpression() {
 ///
 Parser::ExprResult Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) {
   OwningExprResult LHS(Actions, ParseObjCAtExpression(AtLoc));
-  if (LHS.isInvalid()) return LHS.move();
+  if (LHS.isInvalid()) return LHS.result();
 
-  return ParseRHSOfBinaryExpression(LHS.move(), prec::Comma);
+  return ParseRHSOfBinaryExpression(LHS.result(), prec::Comma);
 }
 
 /// ParseAssignmentExpression - Parse an expr that doesn't include commas.
@@ -198,9 +198,9 @@ Parser::ExprResult Parser::ParseAssignmentExpression() {
     return ParseThrowExpression();
 
   OwningExprResult LHS(Actions, ParseCastExpression(false));
-  if (LHS.isInvalid()) return LHS.move();
+  if (LHS.isInvalid()) return LHS.result();
   
-  return ParseRHSOfBinaryExpression(LHS.move(), prec::Assignment);
+  return ParseRHSOfBinaryExpression(LHS.result(), prec::Assignment);
 }
 
 /// ParseAssignmentExprWithObjCMessageExprStart - Parse an assignment expression
@@ -219,18 +219,18 @@ Parser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc,
   OwningExprResult R(Actions, ParseObjCMessageExpressionBody(LBracLoc, NameLoc,
                                                              ReceiverName,
                                                              ReceiverExpr));
-  if (R.isInvalid()) return R.move();
-  R = ParsePostfixExpressionSuffix(R.move());
-  if (R.isInvalid()) return R.move();
-  return ParseRHSOfBinaryExpression(R.move(), 2);
+  if (R.isInvalid()) return R.result();
+  R = ParsePostfixExpressionSuffix(R.result());
+  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.move();
+  if (LHS.isInvalid()) return LHS.result();
   
-  return ParseRHSOfBinaryExpression(LHS.move(), prec::Conditional);
+  return ParseRHSOfBinaryExpression(LHS.result(), prec::Conditional);
 }
 
 /// ParseRHSOfBinaryExpression - Parse a binary expression that starts with
@@ -246,7 +246,7 @@ Parser::ParseRHSOfBinaryExpression(ExprResult LHSArg, unsigned MinPrec) {
     // because we are called recursively, or because the token is not a binop),
     // then we are done!
     if (NextTokPrec < MinPrec)
-      return LHS.move();
+      return LHS.result();
 
     // Consume the operator, saving the operator token for error reporting.
     Token OpToken = Tok;
@@ -262,7 +262,7 @@ Parser::ParseRHSOfBinaryExpression(ExprResult LHSArg, unsigned MinPrec) {
         // 'logical-OR-expression' as we might expect.
         TernaryMiddle = ParseExpression();
         if (TernaryMiddle.isInvalid())
-          return TernaryMiddle.move();
+          return TernaryMiddle.result();
       } else {
         // Special case handling of "X ? Y : Z" where Y is empty:
         //   logical-OR-expression '?' ':' conditional-expression   [GNU]
@@ -283,7 +283,7 @@ Parser::ParseRHSOfBinaryExpression(ExprResult LHSArg, unsigned MinPrec) {
     // Parse another leaf here for the RHS of the operator.
     OwningExprResult RHS(Actions, ParseCastExpression(false));
     if (RHS.isInvalid())
-      return RHS.move();
+      return RHS.result();
 
     // Remember the precedence of this operator and get the precedence of the
     // operator immediately to the right of the RHS.
@@ -303,9 +303,9 @@ Parser::ParseRHSOfBinaryExpression(ExprResult LHSArg, unsigned MinPrec) {
       // is okay, to bind exactly as tightly.  For example, compile A=B=C=D as
       // A=(B=(C=D)), where each paren is a level of recursion here.
       // The function takes ownership of the RHS.
-      RHS = ParseRHSOfBinaryExpression(RHS.move(), ThisPrec + !isRightAssoc);
+      RHS = ParseRHSOfBinaryExpression(RHS.result(), ThisPrec + !isRightAssoc);
       if (RHS.isInvalid())
-        return RHS.move();
+        return RHS.result();
 
       NextTokPrec = getBinOpPrecedence(Tok.getKind());
     }
@@ -314,12 +314,13 @@ Parser::ParseRHSOfBinaryExpression(ExprResult LHSArg, unsigned MinPrec) {
     if (!LHS.isInvalid()) {
       // Combine the LHS and RHS into the LHS (e.g. build AST).
       if (TernaryMiddle.isInvalid())
-        LHS = Actions.ActOnBinOp(CurScope, OpToken.getLocation(), 
-                                 OpToken.getKind(), LHS.move(), RHS.move());
+        LHS = Actions.ActOnBinOp(CurScope, OpToken.getLocation(),
+                                 OpToken.getKind(), LHS.release(),
+                                 RHS.release());
       else
         LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc,
-                                         LHS.move(), TernaryMiddle.move(),
-                                         RHS.move());
+                                         LHS.release(), TernaryMiddle.release(),
+                                         RHS.release());
     }
   }
 }
@@ -443,7 +444,7 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
     SourceLocation LParenLoc = Tok.getLocation();
     SourceLocation RParenLoc;
     Res = ParseParenExpression(ParenExprType, CastTy, RParenLoc);
-    if (Res.isInvalid()) return Res.move();
+    if (Res.isInvalid()) return Res.result();
     
     switch (ParenExprType) {
     case SimpleExpr:   break;    // Nothing else to do.
@@ -458,12 +459,13 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
       // TODO: For cast expression with CastTy.
       Res = ParseCastExpression(false);
       if (!Res.isInvalid())
-        Res = Actions.ActOnCastExpr(LParenLoc, CastTy, RParenLoc, Res.move());
-      return Res.move();
+        Res = Actions.ActOnCastExpr(LParenLoc, CastTy, RParenLoc,
+                                    Res.release());
+      return Res.result();
     }
 
     // These can be followed by postfix-expr pieces.
-    return ParsePostfixExpressionSuffix(Res.move());
+    return ParsePostfixExpressionSuffix(Res.result());
   }
 
     // primary-expression
@@ -475,7 +477,7 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
     ConsumeToken();
     
     // These can be followed by postfix-expr pieces.
-    return ParsePostfixExpressionSuffix(Res.move());
+    return ParsePostfixExpressionSuffix(Res.result());
 
   case tok::kw_true:
   case tok::kw_false:
@@ -493,26 +495,26 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
     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.move());
+    return ParsePostfixExpressionSuffix(Res.result());
   }
   case tok::char_constant:     // constant: character-constant
     Res = Actions.ActOnCharacterConstant(Tok);
     ConsumeToken();
     // These can be followed by postfix-expr pieces.
-    return ParsePostfixExpressionSuffix(Res.move());
+    return ParsePostfixExpressionSuffix(Res.result());
   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.move());
+    return ParsePostfixExpressionSuffix(Res.result());
   case tok::string_literal:    // primary-expression: string-literal
   case tok::wide_string_literal:
     Res = ParseStringLiteralExpression();
-    if (Res.isInvalid()) return Res.move();
+    if (Res.isInvalid()) return Res.result();
     // This can be followed by postfix-expr pieces (e.g. "foo"[1]).
-    return ParsePostfixExpressionSuffix(Res.move());
+    return ParsePostfixExpressionSuffix(Res.result());
   case tok::kw___builtin_va_arg:
   case tok::kw___builtin_offsetof:
   case tok::kw___builtin_choose_expr:
@@ -527,8 +529,8 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
     SourceLocation SavedLoc = ConsumeToken();
     Res = ParseCastExpression(true);
     if (!Res.isInvalid())
-      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.move());
-    return Res.move();
+      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.release());
+    return Res.result();
   }
   case tok::amp:           // unary-expression: '&' cast-expression
   case tok::star:          // unary-expression: '*' cast-expression
@@ -541,8 +543,8 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
     SourceLocation SavedLoc = ConsumeToken();
     Res = ParseCastExpression(false);
     if (!Res.isInvalid())
-      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.move());
-    return Res.move();
+      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.release());
+    return Res.result();
   }
 
   case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU]
@@ -551,8 +553,8 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
     SourceLocation SavedLoc = ConsumeToken();
     Res = ParseCastExpression(false);
     if (!Res.isInvalid())
-      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.move());
-    return Res.move();
+      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, Res.release());
+    return Res.result();
   }
   case tok::kw_sizeof:     // unary-expression: 'sizeof' unary-expression
                            // unary-expression: 'sizeof' '(' type-name ')'
@@ -567,12 +569,12 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
       Diag(Tok, diag::err_expected_ident);
       return ExprResult(true);
     }
-    
+
     Diag(AmpAmpLoc, diag::ext_gnu_address_of_label);
     Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(),
                                  Tok.getIdentifierInfo());
     ConsumeToken();
-    return Res.move();
+    return Res.result();
   }
   case tok::kw_const_cast:
   case tok::kw_dynamic_cast:
@@ -580,15 +582,15 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
   case tok::kw_static_cast:
     Res = ParseCXXCasts();
     // These can be followed by postfix-expr pieces.
-    return ParsePostfixExpressionSuffix(Res.move());
+    return ParsePostfixExpressionSuffix(Res.result());
   case tok::kw_typeid:
     Res = ParseCXXTypeid();
     // This can be followed by postfix-expr pieces.
-    return ParsePostfixExpressionSuffix(Res.move());
+    return ParsePostfixExpressionSuffix(Res.result());
   case tok::kw_this:
     Res = ParseCXXThis();
     // This can be followed by postfix-expr pieces.
-    return ParsePostfixExpressionSuffix(Res.move());
+    return ParsePostfixExpressionSuffix(Res.result());
 
   case tok::kw_char:
   case tok::kw_wchar_t:
@@ -616,14 +618,14 @@ Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) {
 
     Res = ParseCXXTypeConstructExpression(DS);
     // This can be followed by postfix-expr pieces.
-    return ParsePostfixExpressionSuffix(Res.move());
+    return ParsePostfixExpressionSuffix(Res.result());
   }
 
   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.move());
+    return ParsePostfixExpressionSuffix(Res.result());
 
   case tok::coloncolon: // [C++] new-expression or [C++] delete-expression
     // If the next token is neither 'new' nor 'delete', the :: would have been
@@ -689,7 +691,7 @@ Parser::ExprResult Parser::ParsePostfixExpressionSuffix(ExprResult LHSArg) {
   while (1) {
     switch (Tok.getKind()) {
     default:  // Not a postfix-expression suffix.
-      return LHS.move();
+      return LHS.result();
     case tok::l_square: {  // postfix-expression: p-e '[' expression ']'
       Loc = ConsumeBracket();
       OwningExprResult Idx(Actions, ParseExpression());
@@ -697,8 +699,8 @@ Parser::ExprResult Parser::ParsePostfixExpressionSuffix(ExprResult LHSArg) {
       SourceLocation RLoc = Tok.getLocation();
 
       if (!LHS.isInvalid() && !Idx.isInvalid() && Tok.is(tok::r_square)) {
-        LHS = Actions.ActOnArraySubscriptExpr(CurScope, LHS.move(), Loc,
-                                              Idx.move(), RLoc);
+        LHS = Actions.ActOnArraySubscriptExpr(CurScope, LHS.release(), Loc,
+                                              Idx.release(), RLoc);
       } else
         LHS = ExprResult(true);
 
@@ -724,7 +726,7 @@ Parser::ExprResult Parser::ParsePostfixExpressionSuffix(ExprResult LHSArg) {
       if (!LHS.isInvalid() && Tok.is(tok::r_paren)) {
         assert((ArgExprs.size() == 0 || ArgExprs.size()-1 == CommaLocs.size())&&
                "Unexpected number of commas!");
-        LHS = Actions.ActOnCallExpr(CurScope, LHS.move(), Loc, 
+        LHS = Actions.ActOnCallExpr(CurScope, LHS.release(), Loc,
                                     ArgExprs.take(),
                                     ArgExprs.size(), &CommaLocs[0],
                                     Tok.getLocation());
@@ -744,7 +746,7 @@ Parser::ExprResult Parser::ParsePostfixExpressionSuffix(ExprResult LHSArg) {
       }
       
       if (!LHS.isInvalid()) {
-        LHS = Actions.ActOnMemberReferenceExpr(LHS.move(), OpLoc, OpKind,
+        LHS = Actions.ActOnMemberReferenceExpr(LHS.release(), OpLoc, OpKind,
                                                Tok.getLocation(),
                                                *Tok.getIdentifierInfo());
       }
@@ -755,7 +757,7 @@ Parser::ExprResult Parser::ParsePostfixExpressionSuffix(ExprResult LHSArg) {
     case tok::minusminus:  // postfix-expression: postfix-expression '--'
       if (!LHS.isInvalid()) {
         LHS = Actions.ActOnPostfixUnaryOp(CurScope, Tok.getLocation(), 
-                                          Tok.getKind(), LHS.move());
+                                          Tok.getKind(), LHS.release());
       }
       ConsumeToken();
       break;
@@ -803,16 +805,16 @@ Parser::ExprResult Parser::ParseSizeofAlignofExpression() {
     // 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.move());
+    Operand = ParsePostfixExpressionSuffix(Operand.result());
   }
   
   // If we get here, the operand to the sizeof/alignof was an expresion.
   if (!Operand.isInvalid())
     Operand = Actions.ActOnSizeOfAlignOfExpr(OpTok.getLocation(),
                                              OpTok.is(tok::kw_sizeof),
-                                             /*isType=*/false, Operand.move(),
-                                             SourceRange());
-  return Operand.move();
+                                             /*isType=*/false,
+                                             Operand.release(), SourceRange());
+  return Operand.result();
 }
 
 /// ParseBuiltinPrimaryExpression
@@ -864,7 +866,7 @@ Parser::ExprResult Parser::ParseBuiltinPrimaryExpression() {
       Diag(Tok, diag::err_expected_rparen);
       return ExprResult(true);
     }
-    Res = Actions.ActOnVAArg(StartLoc, Expr.move(), Ty, ConsumeParen());
+    Res = Actions.ActOnVAArg(StartLoc, Expr.release(), Ty, ConsumeParen());
     break;
   }
   case tok::kw___builtin_offsetof: {
@@ -913,9 +915,9 @@ Parser::ExprResult Parser::ParseBuiltinPrimaryExpression() {
         Res = ParseExpression();
         if (Res.isInvalid()) {
           SkipUntil(tok::r_paren);
-          return Res.move();
+          return Res.result();
         }
-        Comps.back().U.