Rename move_convert to move_arg and move_res. The new names are less misleading ...

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

diff --git a/include/clang/Parse/Ownership.h b/include/clang/Parse/Ownership.h
index a7d805d38e6b6b705b094e33b3468f890a9174a7..a04b81879e973e42ecaa5e98399437bed06d49bd 100644 (file)
--- a/include/clang/Parse/Ownership.h
+++ b/include/clang/Parse/Ownership.h
@@ -99,7 +99,7 @@
 // OwningResult object -> ResultMover -> OwningResult argument to
 // OwningPtr(OwningResult) -> OwningPtr -> PtrMover -> final OwningPtr
 // This conversion sequence is too complex to be allowed. Thus the special
-// move_convert functions, which help the compiler out with some explicit
+// move_* functions, which help the compiler out with some explicit
 // conversions.
 
 namespace clang
@@ -472,12 +472,12 @@ namespace clang
   // These are necessary because of ambiguity problems.
 
   template <ASTDestroyer Destroyer> inline
-  ASTOwningPtr<Destroyer> move_convert(ASTOwningResult<Destroyer> &ptr) {
+  ASTOwningPtr<Destroyer> move_arg(ASTOwningResult<Destroyer> &ptr) {
     return ASTOwningPtr<Destroyer>(ptr.ptr_move());
   }
 
   template <ASTDestroyer Destroyer> inline
-  ASTOwningResult<Destroyer> move_convert(ASTOwningPtr<Destroyer> &ptr) {
+  ASTOwningResult<Destroyer> move_res(ASTOwningPtr<Destroyer> &ptr) {
     return ASTOwningResult<Destroyer>(moving::ASTPtrMover<Destroyer>(ptr));
   }
 

diff --git a/lib/Parse/AstGuard.h b/lib/Parse/AstGuard.h
index a65caedeb348f797157dcd77b80ec0ca2c3c4af2..d755ea76c9d9fb4d812280c0e5210a3f82f4ac99 100644 (file)
--- a/lib/Parse/AstGuard.h
+++ b/lib/Parse/AstGuard.h
@@ -61,7 +61,7 @@ namespace clang
   typedef ASTVector<&Action::DeleteExpr, 12> ExprVector;
 
   template <ASTDestroyer Destroyer, unsigned N> inline
-  ASTMultiPtr<Destroyer> move_convert(ASTVector<Destroyer, N> &vec) {
+  ASTMultiPtr<Destroyer> move_arg(ASTVector<Destroyer, N> &vec) {
     return ASTMultiPtr<Destroyer>(vec.getActions(), vec.take(), vec.size());
   }
 }

diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index be929ae067860d78c3ff0061de83b8fa6dacfe65..319c03eecff3db78ca1bf43753b4b4162127a10a 100644 (file)
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -312,7 +312,7 @@ ParseInitDeclaratorListAfterFirstDeclarator(Declarator &D) {
         SkipUntil(tok::semi);
         return 0;
       }
-      Actions.AddInitializerToDecl(LastDeclInGroup, move_convert(Init));
+      Actions.AddInitializerToDecl(LastDeclInGroup, move_arg(Init));
     } else if (Tok.is(tok::l_paren)) {
       // Parse C++ direct initializer: '(' expression-list ')'
       SourceLocation LParenLoc = ConsumeParen();

diff --git a/lib/Parse/ParseInit.cpp b/lib/Parse/ParseInit.cpp
index ac13902c74406930ae7526c1e363380d0c276434..9b93c18795866edf1a9dc901b2a23bd8de717704 100644 (file)
--- a/lib/Parse/ParseInit.cpp
+++ b/lib/Parse/ParseInit.cpp
@@ -170,7 +170,7 @@ ParseInitializerWithPotentialDesignator(InitListDesignations &Designations,
 
       return ParseAssignmentExprWithObjCMessageExprStart(StartLoc,
                                                          SourceLocation(),
-                                                         0, move_convert(Idx));
+                                                         0, move_arg(Idx));
     }
 
     // Create designation if we haven't already.

diff --git a/lib/Parse/ParseObjc.cpp b/lib/Parse/ParseObjc.cpp
index ef0d4b201a6a1646faec39711d2c56e58fe26808..1c94dbb6aad72fd9caecfbb9d8bff0b5b7b6327b 100644 (file)
--- a/lib/Parse/ParseObjc.cpp
+++ b/lib/Parse/ParseObjc.cpp
@@ -1202,7 +1202,7 @@ Parser::OwningStmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) {
     }
   }
   ConsumeToken(); // consume ';'
-  return Actions.ActOnObjCAtThrowStmt(atLoc, move_convert(Res));
+  return Actions.ActOnObjCAtThrowStmt(atLoc, move_arg(Res));
 }
 
 /// objc-synchronized-statement:
@@ -1239,8 +1239,8 @@ Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) {
   BodyScope.Exit();
   if (SynchBody.isInvalid())
     SynchBody = Actions.ActOnNullStmt(Tok.getLocation());
-  return Actions.ActOnObjCAtSynchronizedStmt(atLoc, move_convert(Res),
-                                             move_convert(SynchBody));
+  return Actions.ActOnObjCAtSynchronizedStmt(atLoc, move_arg(Res),
+                                             move_arg(SynchBody));
 }
 
 ///  objc-try-catch-statement:
@@ -1313,8 +1313,8 @@ Parser::OwningStmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) {
         if (CatchBody.isInvalid())
           CatchBody = Actions.ActOnNullStmt(Tok.getLocation());
         CatchStmts = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc,
-          RParenLoc, move_convert(FirstPart), move_convert(CatchBody),
-          move_convert(CatchStmts));
+                        RParenLoc, move_arg(FirstPart), move_arg(CatchBody),
+                        move_arg(CatchStmts));
       } else {
         Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after)
           << "@catch clause";
@@ -1334,7 +1334,7 @@ Parser::OwningStmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) {
       if (FinallyBody.isInvalid())
         FinallyBody = Actions.ActOnNullStmt(Tok.getLocation());
       FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc,
-                                                   move_convert(FinallyBody));
+                                                   move_arg(FinallyBody));
       catch_or_finally_seen = true;
       break;
     }
@@ -1343,9 +1343,9 @@ Parser::OwningStmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) {
     Diag(atLoc, diag::err_missing_catch_finally);
     return StmtError();
   }
-  return Actions.ActOnObjCAtTryStmt(atLoc, move_convert(TryBody),
-                                    move_convert(CatchStmts),
-                                    move_convert(FinallyStmt));
+  return Actions.ActOnObjCAtTryStmt(atLoc, move_arg(TryBody),
+                                    move_arg(CatchStmts),
+                                    move_arg(FinallyStmt));
 }
 
 ///   objc-method-def: objc-method-proto ';'[opt] '{' body '}'
@@ -1387,7 +1387,7 @@ Parser::DeclTy *Parser::ParseObjCMethodDefinition() {
   BodyScope.Exit();
 
   // TODO: Pass argument information.
-  Actions.ActOnFinishFunctionBody(MDecl, move_convert(FnBody));
+  Actions.ActOnFinishFunctionBody(MDecl, move_arg(FnBody));
   return MDecl;
 }
 
@@ -1408,7 +1408,7 @@ Parser::OwningStmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc) {
   }
   // Otherwise, eat the semicolon.
   ExpectAndConsume(tok::semi, diag::err_expected_semi_after_expr);
-  return Actions.ActOnExprStmt(move_convert(Res));
+  return Actions.ActOnExprStmt(move_arg(Res));
 }
 
 Parser::OwningExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {
@@ -1459,7 +1459,7 @@ Parser::OwningExprResult Parser::ParseObjCMessageExpression() {
   }
 
   return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(),
-                                        0, move_convert(Res));
+                                        0, move_arg(Res));
 }
 
 /// ParseObjCMessageExpressionBody - Having parsed "'[' objc-receiver", parse

diff --git a/lib/Parse/ParseStmt.cpp b/lib/Parse/ParseStmt.cpp
index 6ca577347ddd9ef00d865b1f96431ab4ea3374ef..681b27f4648dafe32fcb53b31351179006b6f34b 100644 (file)
--- a/lib/Parse/ParseStmt.cpp
+++ b/lib/Parse/ParseStmt.cpp
@@ -118,7 +118,7 @@ Parser::ParseStatementOrDeclaration(bool OnlyStatement) {
       }
       // Otherwise, eat the semicolon.
       ExpectAndConsume(tok::semi, diag::err_expected_semi_after_expr);
-      return Actions.ActOnExprStmt(move_convert(Expr));
+      return Actions.ActOnExprStmt(move_arg(Expr));
     }
 
   case tok::kw_case:                // C99 6.8.1: labeled-statement
@@ -217,7 +217,7 @@ Parser::OwningStmtResult Parser::ParseLabeledStatement() {
 
   return Actions.ActOnLabelStmt(IdentTok.getLocation(),
                                 IdentTok.getIdentifierInfo(),
-                                ColonLoc, move_convert(SubStmt));
+                                ColonLoc, move_arg(SubStmt));
 }
 
 /// ParseCaseStatement
@@ -271,9 +271,8 @@ Parser::OwningStmtResult Parser::ParseCaseStatement() {
   if (SubStmt.isInvalid())
     SubStmt = Actions.ActOnNullStmt(ColonLoc);
 
-  return Actions.ActOnCaseStmt(CaseLoc, move_convert(LHS), DotDotDotLoc,
-                               move_convert(RHS), ColonLoc,
-                               move_convert(SubStmt));
+  return Actions.ActOnCaseStmt(CaseLoc, move_arg(LHS), DotDotDotLoc,
+                               move_arg(RHS), ColonLoc, move_arg(SubStmt));
 }
 
 /// ParseDefaultStatement
@@ -304,7 +303,7 @@ Parser::OwningStmtResult Parser::ParseDefaultStatement() {
     return StmtError();
 
   return Actions.ActOnDefaultStmt(DefaultLoc, ColonLoc,
-                                  move_convert(SubStmt), CurScope);
+                                  move_arg(SubStmt), CurScope);
 }
 
 
@@ -390,17 +389,17 @@ Parser::OwningStmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) {
           SkipUntil(tok::semi);
           continue;
         }
-        
+
         // Add the __extension__ node to the AST.
         Res = Actions.ActOnUnaryOp(CurScope, ExtLoc, tok::kw___extension__, 
                                    Res.release());
         if (Res.isInvalid())
           continue;
-        
+
         // Eat the semicolon at the end of stmt and convert the expr into a
         // statement.
         ExpectAndConsume(tok::semi, diag::err_expected_semi_after_expr);
-        R = Actions.ActOnExprStmt(move_convert(Res));
+        R = Actions.ActOnExprStmt(move_arg(Res));
       }
     }
 
@@ -415,7 +414,7 @@ Parser::OwningStmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) {
   }
 
   SourceLocation RBraceLoc = ConsumeBrace();
-  return Actions.ActOnCompoundStmt(LBraceLoc, RBraceLoc, move_convert(Stmts),
+  return Actions.ActOnCompoundStmt(LBraceLoc, RBraceLoc, move_arg(Stmts),
                                    isStmtExpr);
 }
 
@@ -575,9 +574,8 @@ Parser::OwningStmtResult Parser::ParseIfStatement() {
   if (ElseStmt.isInvalid())
     ElseStmt = Actions.ActOnNullStmt(ElseStmtLoc);
 
-  return Actions.ActOnIfStmt(IfLoc, move_convert(CondExp),
-                             move_convert(ThenStmt), ElseLoc,
-                             move_convert(ElseStmt));
+  return Actions.ActOnIfStmt(IfLoc, move_arg(CondExp), move_arg(ThenStmt),
+                             ElseLoc, move_arg(ElseStmt));
 }
 
 /// ParseSwitchStatement
@@ -620,7 +618,7 @@ Parser::OwningStmtResult Parser::ParseSwitchStatement() {
 
   OwningStmtResult Switch(Actions);
   if (!Cond.isInvalid())
-    Switch = Actions.ActOnStartOfSwitchStmt(move_convert(Cond));
+    Switch = Actions.ActOnStartOfSwitchStmt(move_arg(Cond));
 
   // C99 6.8.4p3 - In C99, the body of the switch statement is a scope, even if
   // there is no compound stmt.  C90 does not have this clause.  We only do this
@@ -652,8 +650,8 @@ Parser::OwningStmtResult Parser::ParseSwitchStatement() {
   if (Cond.isInvalid())
     return StmtError();
 
-  return Actions.ActOnFinishSwitchStmt(SwitchLoc, move_convert(Switch),
-                                       move_convert(Body));
+  return Actions.ActOnFinishSwitchStmt(SwitchLoc, move_arg(Switch),
+                                       move_arg(Body));
 }
 
 /// ParseWhileStatement
@@ -722,8 +720,7 @@ Parser::OwningStmtResult Parser::ParseWhileStatement() {
   if (Cond.isInvalid() || Body.isInvalid())
     return StmtError();
 
-  return Actions.ActOnWhileStmt(WhileLoc, move_convert(Cond),
-                                move_convert(Body));
+  return Actions.ActOnWhileStmt(WhileLoc, move_arg(Cond), move_arg(Body));
 }
 
 /// ParseDoStatement
@@ -787,8 +784,7 @@ Parser::OwningStmtResult Parser::ParseDoStatement() {
   if (Cond.isInvalid() || Body.isInvalid())
     return StmtError();
 
-  return Actions.ActOnDoStmt(DoLoc, move_convert(Body), WhileLoc,
-                             move_convert(Cond));
+  return Actions.ActOnDoStmt(DoLoc, move_arg(Body), WhileLoc, move_arg(Cond));
 }
 
 /// ParseForStatement
@@ -870,7 +866,7 @@ Parser::OwningStmtResult Parser::ParseForStatement() {
 
     // Turn the expression into a stmt.
     if (!Value.isInvalid())
-      FirstPart = Actions.ActOnExprStmt(move_convert(Value));
+      FirstPart = Actions.ActOnExprStmt(move_arg(Value));
 
     if (Tok.is(tok::semi)) {
       ConsumeToken();
@@ -937,14 +933,14 @@ Parser::OwningStmtResult Parser::ParseForStatement() {
     return StmtError();
 
   if (!ForEach)
-    return Actions.ActOnForStmt(ForLoc, LParenLoc, move_convert(FirstPart),
-                              move_convert(SecondPart), move_convert(ThirdPart),
-                              RParenLoc, move_convert(Body));
+    return Actions.ActOnForStmt(ForLoc, LParenLoc, move_arg(FirstPart),
+                              move_arg(SecondPart), move_arg(ThirdPart),
+                              RParenLoc, move_arg(Body));
   else
     return Actions.ActOnObjCForCollectionStmt(ForLoc, LParenLoc,
-                                              move_convert(FirstPart),
-                                              move_convert(SecondPart),
-                                              RParenLoc, move_convert(Body));
+                                              move_arg(FirstPart),
+                                              move_arg(SecondPart),
+                                              RParenLoc, move_arg(Body));
 }
 
 /// ParseGotoStatement
@@ -972,7 +968,7 @@ Parser::OwningStmtResult Parser::ParseGotoStatement() {
       SkipUntil(tok::semi, false, true);
       return StmtError();
     }
-    Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, move_convert(R));
+    Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, move_arg(R));
   } else {
     Diag(Tok, diag::err_expected_ident);
     return StmtError();
@@ -1018,7 +1014,7 @@ Parser::OwningStmtResult Parser::ParseReturnStatement() {
       return StmtError();
     }
   }
-  return Actions.ActOnReturnStmt(ReturnLoc, move_convert(R));
+  return Actions.ActOnReturnStmt(ReturnLoc, move_arg(R));
 }
 
 /// FuzzyParseMicrosoftAsmStatement. When -fms-extensions is enabled, this
@@ -1157,8 +1153,8 @@ Parser::OwningStmtResult Parser::ParseAsmStatement(bool &msAsm) {
 
   return Actions.ActOnAsmStmt(AsmLoc, isSimple, isVolatile,
                               NumOutputs, NumInputs, &Names[0],
-                              move_convert(Constraints), move_convert(Exprs),
-                              move_convert(AsmString), move_convert(Clobbers),
+                              move_arg(Constraints), move_arg(Exprs),
+                              move_arg(AsmString), move_arg(Clobbers),
                               RParenLoc);
 }
 
@@ -1243,7 +1239,7 @@ Parser::DeclTy *Parser::ParseFunctionStatementBody(DeclTy *Decl,
   if (FnBody.isInvalid())
     FnBody = Actions.ActOnCompoundStmt(L, R, MultiStmtArg(Actions), false);
 
-  return Actions.ActOnFinishFunctionBody(Decl, move_convert(FnBody));
+  return Actions.ActOnFinishFunctionBody(Decl, move_arg(FnBody));
 }
 
 /// ParseCXXTryBlock - Parse a C++ try-block.
@@ -1277,8 +1273,8 @@ Parser::OwningStmtResult Parser::ParseCXXTryBlock() {
   if (Handlers.empty())
     return StmtError();
 
-  return Actions.ActOnCXXTryBlock(TryLoc, move_convert(TryBlock),
-                                  move_convert(Handlers));
+  return Actions.ActOnCXXTryBlock(TryLoc, move_arg(TryBlock),
+                                  move_arg(Handlers));
 }
 
 /// ParseCXXCatchBlock - Parse a C++ catch block, called handler in the standard
@@ -1329,6 +1325,5 @@ Parser::OwningStmtResult Parser::ParseCXXCatchBlock() {
   if (Block.isInvalid())
     return move(Block);
 
-  return Actions.ActOnCXXCatchBlock(CatchLoc, ExceptionDecl,
-                                    move_convert(Block));
+  return Actions.ActOnCXXCatchBlock(CatchLoc, ExceptionDecl, move_arg(Block));
 }

diff --git a/lib/Parse/Parser.cpp b/lib/Parse/Parser.cpp
index 799a2072f197a9ff1c8f6aeeb3a5d9b568be526d..6ae3bf038ffa55a0a3d5d05a2ab7b3475b770ae4 100644 (file)
--- a/lib/Parse/Parser.cpp
+++ b/lib/Parse/Parser.cpp
@@ -357,8 +357,7 @@ Parser::DeclTy *Parser::ParseExternalDeclaration() {
                      "top-level asm block");
 
     if (!Result.isInvalid())
-      return Actions.ActOnFileScopeAsmDecl(Tok.getLocation(),
-                                           move_convert(Result));
+      return Actions.ActOnFileScopeAsmDecl(Tok.getLocation(), move_arg(Result));
     return 0;
   }
   case tok::at: