Use unique_ptr in CFXA_FM expressions

xfa/fxfa/fm2js/xfa_fmparse.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/fm2js/xfa_fmparse.h"
 
 #include <memory>
 #include <utility>
@@ skipping 174 matching lines @@
       CFX_WideString ws_TempString(m_pToken->m_wstring);
       Error(m_pToken->m_uLinenum, kFMErrUnexpectedExpression,
             ws_TempString.c_str());
       NextToken();
       break;
   }
   return expr;
 }
 
 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseVarExpression() {
   std::unique_ptr<CXFA_FMExpression> expr;

[Tom Sepez, 2016/11/29 17:39:46]

nit: can this move to line 207?

[npm, 2016/11/29 18:22:34]

Done.

   CFX_WideStringC ident;
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   if (m_pToken->m_type != TOKidentifier) {
     CFX_WideString ws_TempString(m_pToken->m_wstring);
     Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
           ws_TempString.c_str());
   } else {
     ident = m_pToken->m_wstring;
     NextToken();
   }
   if (m_pToken->m_type == TOKassign) {
     NextToken();
     expr = ParseExpExpression();
   }
   if (m_pErrorInfo->message.IsEmpty()) {

[Tom Sepez, 2016/11/29 17:39:46]

nit: I was having a hard time reading this.  I think we can make it simpler by
counting on the fact that we can return nullptrs (implicitly promoted) and that
we don't have to reset the expr, instead just let it go out of scope.

So I think the following is equivalent, but doublecheck:

  if (!m_pErrorInfo->message.IsEmpty())
    return nullptr;

  return pdfium::MakeUnique<CXFA_FMVarExpression>(line, ident, std::move(expr));

[npm, 2016/11/29 18:22:34]

Done.

     expr =
-        pdfium::MakeUnique<CXFA_FMVarExpression>(line, ident, expr.release());
+        pdfium::MakeUnique<CXFA_FMVarExpression>(line, ident, std::move(expr));
   } else {
     expr.reset();
   }
   return expr;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseSimpleExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression();
   while (m_pToken->m_type == TOKassign) {
     NextToken();
     std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression();
     if (m_pErrorInfo->message.IsEmpty()) {
       pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>(
-          line, TOKassign, pExp1.release(), pExp2.release());
+          line, TOKassign, std::move(pExp1), std::move(pExp2));
     } else {
       pExp1.reset();
     }
   }
   return pExp1;
 }
 
 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseExpExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseSimpleExpression();
   std::unique_ptr<CXFA_FMExpression> expr;
-  if (m_pErrorInfo->message.IsEmpty()) {
-    expr = pdfium::MakeUnique<CXFA_FMExpExpression>(line, pExp1.release());
-  } else {
+  if (m_pErrorInfo->message.IsEmpty())

[Tom Sepez, 2016/11/29 17:39:46]

nit: same trick here as above.

[npm, 2016/11/29 18:22:34]

Done.

+    expr = pdfium::MakeUnique<CXFA_FMExpExpression>(line, std::move(pExp1));
+  else
     expr.reset();
-  }
   return expr;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression>
 CXFA_FMParse::ParseLogicalOrExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseLogicalAndExpression();
   for (;;) {
     switch (m_pToken->m_type) {
       case TOKor:
       case TOKksor: {
         NextToken();
         std::unique_ptr<CXFA_FMSimpleExpression> e2(
             ParseLogicalAndExpression());
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMLogicalOrExpression>(
-              line, TOKor, e1.release(), e2.release());
+              line, TOKor, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       }
       default:
         break;
     }
     break;
   }
   return e1;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression>
 CXFA_FMParse::ParseLogicalAndExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseEqualityExpression();
   for (;;) {
     switch (m_pToken->m_type) {
       case TOKand:
       case TOKksand: {
         NextToken();
         std::unique_ptr<CXFA_FMSimpleExpression> e2 = ParseEqualityExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMLogicalAndExpression>(
-              line, TOKand, e1.release(), e2.release());
+              line, TOKand, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       }
       default:
         break;
     }
     break;
   }
   return e1;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression>
 CXFA_FMParse::ParseEqualityExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseRelationalExpression();
   for (;;) {
     std::unique_ptr<CXFA_FMSimpleExpression> e2;
     switch (m_pToken->m_type) {
       case TOKeq:
       case TOKkseq:
         NextToken();
         e2 = ParseRelationalExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>(
-              line, TOKeq, e1.release(), e2.release());
+              line, TOKeq, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       case TOKne:
       case TOKksne:
         NextToken();
         e2 = ParseRelationalExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMEqualityExpression>(
-              line, TOKne, e1.release(), e2.release());
+              line, TOKne, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression>
 CXFA_FMParse::ParseRelationalExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseAddtiveExpression();
   for (;;) {
     std::unique_ptr<CXFA_FMSimpleExpression> e2;
     switch (m_pToken->m_type) {
       case TOKlt:
       case TOKkslt:
         NextToken();
         e2 = ParseAddtiveExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>(
-              line, TOKlt, e1.release(), e2.release());
+              line, TOKlt, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       case TOKgt:
       case TOKksgt:
         NextToken();
         e2 = ParseAddtiveExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>(
-              line, TOKgt, e1.release(), e2.release());
+              line, TOKgt, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       case TOKle:
       case TOKksle:
         NextToken();
         e2 = ParseAddtiveExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>(
-              line, TOKle, e1.release(), e2.release());
+              line, TOKle, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       case TOKge:
       case TOKksge:
         NextToken();
         e2 = ParseAddtiveExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMRelationalExpression>(
-              line, TOKge, e1.release(), e2.release());
+              line, TOKge, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression>
 CXFA_FMParse::ParseAddtiveExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseMultiplicativeExpression();
   for (;;) {
     std::unique_ptr<CXFA_FMSimpleExpression> e2;
     switch (m_pToken->m_type) {
       case TOKplus:
         NextToken();
         e2 = ParseMultiplicativeExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>(
-              line, TOKplus, e1.release(), e2.release());
+              line, TOKplus, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       case TOKminus:
         NextToken();
         e2 = ParseMultiplicativeExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMAdditiveExpression>(
-              line, TOKminus, e1.release(), e2.release());
+              line, TOKminus, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression>
 CXFA_FMParse::ParseMultiplicativeExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> e1 = ParseUnaryExpression();
   for (;;) {
     std::unique_ptr<CXFA_FMSimpleExpression> e2;
     switch (m_pToken->m_type) {
       case TOKmul:
         NextToken();
         e2 = ParseUnaryExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>(
-              line, TOKmul, e1.release(), e2.release());
+              line, TOKmul, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       case TOKdiv:
         NextToken();
         e2 = ParseUnaryExpression();
         if (m_pErrorInfo->message.IsEmpty()) {
           e1 = pdfium::MakeUnique<CXFA_FMMultiplicativeExpression>(
-              line, TOKdiv, e1.release(), e2.release());
+              line, TOKdiv, std::move(e1), std::move(e2));
         } else {
           e1.reset();
         }
         continue;
       default:
         break;
     }
     break;
   }
   return e1;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseUnaryExpression() {
   std::unique_ptr<CXFA_FMSimpleExpression> expr;
   uint32_t line = m_pToken->m_uLinenum;
   switch (m_pToken->m_type) {
     case TOKplus:
       NextToken();
       expr = ParseUnaryExpression();
-      if (m_pErrorInfo->message.IsEmpty()) {
-        expr = pdfium::MakeUnique<CXFA_FMPosExpression>(line, expr.release());
-      } else {
+      if (m_pErrorInfo->message.IsEmpty())
+        expr = pdfium::MakeUnique<CXFA_FMPosExpression>(line, std::move(expr));
+      else
         expr.reset();
-      }
       break;
     case TOKminus:
       NextToken();
       expr = ParseUnaryExpression();
-      if (m_pErrorInfo->message.IsEmpty()) {
-        expr = pdfium::MakeUnique<CXFA_FMNegExpression>(line, expr.release());
-      } else {
+      if (m_pErrorInfo->message.IsEmpty())
+        expr = pdfium::MakeUnique<CXFA_FMNegExpression>(line, std::move(expr));
+      else
         expr.reset();
-      }
       break;
     case TOKksnot:
       NextToken();
       expr = ParseUnaryExpression();
-      if (m_pErrorInfo->message.IsEmpty()) {
-        expr = pdfium::MakeUnique<CXFA_FMNotExpression>(line, expr.release());
-      } else {
+      if (m_pErrorInfo->message.IsEmpty())
+        expr = pdfium::MakeUnique<CXFA_FMNotExpression>(line, std::move(expr));
+      else
         expr.reset();
-      }
       break;
     default:
       expr = ParsePrimaryExpression();
       break;
   }
   return expr;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression>
 CXFA_FMParse::ParsePrimaryExpression() {
@@ skipping 10 matching lines @@
                                                          m_pToken->m_wstring);
       NextToken();
       break;
     case TOKidentifier: {
       CFX_WideStringC wsIdentifier(m_pToken->m_wstring);
       NextToken();
       if (m_pToken->m_type == TOKlbracket) {
         std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
         if (s) {
           expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
-              line, nullptr, TOKdot, wsIdentifier, s.release());
+              line, nullptr, TOKdot, wsIdentifier, std::move(s));
         }
         NextToken();
       } else {
         expr =
             pdfium::MakeUnique<CXFA_FMIdentifierExpression>(line, wsIdentifier);
       }
     } break;
     case TOKif:
       expr = pdfium::MakeUnique<CXFA_FMIdentifierExpression>(
           line, m_pToken->m_wstring);
@@ skipping 40 matching lines @@
             }
           }
           if (m_pToken->m_type != TOKrparen) {
             CFX_WideString ws_TempString(m_pToken->m_wstring);
             Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
                   XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str());
           }
         }
         if (m_pErrorInfo->message.IsEmpty()) {
           expr = pdfium::MakeUnique<CXFA_FMCallExpression>(
-              line, expr.release(), std::move(expressions), false);
+              line, std::move(expr), std::move(expressions), false);
           NextToken();
           if (m_pToken->m_type != TOKlbracket)
             continue;
 
           std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
           if (s) {
             expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
-                line, expr.release(), TOKcall, FX_WSTRC(L""), s.release());
+                line, std::move(expr), TOKcall, L"", std::move(s));
           } else {
             expr.reset();
           }
         } else {
           expr.reset();
         }
       } break;
       case TOKdot:
         NextToken();
         if (m_pToken->m_type == TOKidentifier) {
@@ skipping 20 matching lines @@
                 CFX_WideString ws_TempString(m_pToken->m_wstring);
                 Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
                       XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str());
               }
             }
             if (m_pErrorInfo->message.IsEmpty()) {
               std::unique_ptr<CXFA_FMSimpleExpression> pIdentifier =
                   pdfium::MakeUnique<CXFA_FMIdentifierExpression>(tempLine,
                                                                   tempStr);
               pExpCall = pdfium::MakeUnique<CXFA_FMCallExpression>(
-                  line, pIdentifier.release(), std::move(expressions), true);
+                  line, std::move(pIdentifier), std::move(expressions), true);
               expr = pdfium::MakeUnique<CXFA_FMMethodCallExpression>(
-                  line, expr.release(), pExpCall.release());
+                  line, std::move(expr), std::move(pExpCall));
               NextToken();
               if (m_pToken->m_type != TOKlbracket)
                 continue;
 
               std::unique_ptr<CXFA_FMSimpleExpression> s =
                   ParseIndexExpression();
               if (s) {
                 expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
-                    line, expr.release(), TOKcall, FX_WSTRC(L""), s.release());
+                    line, std::move(expr), TOKcall, L"", std::move(s));
               } else {
                 expr.reset();
               }
             } else {
               expr.reset();
             }
           } else if (m_pToken->m_type == TOKlbracket) {
             std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
             if (!(m_pErrorInfo->message.IsEmpty()))
               return nullptr;
 
             expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
-                tempLine, expr.release(), TOKdot, tempStr, s.release());
+                tempLine, std::move(expr), TOKdot, tempStr, std::move(s));
           } else {
             std::unique_ptr<CXFA_FMSimpleExpression> s =
                 pdfium::MakeUnique<CXFA_FMIndexExpression>(
                     tempLine, ACCESSOR_NO_INDEX, nullptr, false);
             expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
-                line, expr.release(), TOKdot, tempStr, s.release());
+                line, std::move(expr), TOKdot, tempStr, std::move(s));
             continue;
           }
         } else {
           CFX_WideString ws_TempString(m_pToken->m_wstring);
           Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
                 ws_TempString.c_str());
           return expr;
         }
         break;
       case TOKdotdot:
         NextToken();
         if (m_pToken->m_type == TOKidentifier) {
           CFX_WideStringC tempStr = m_pToken->m_wstring;
           uint32_t tempLine = m_pToken->m_uLinenum;
           NextToken();
           if (m_pToken->m_type == TOKlbracket) {
             std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
             if (!(m_pErrorInfo->message.IsEmpty())) {
               return nullptr;
             }
             expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>(
-                tempLine, expr.release(), TOKdotdot, tempStr, s.release());
+                tempLine, std::move(expr), TOKdotdot, tempStr, std::move(s));
           } else {
             std::unique_ptr<CXFA_FMSimpleExpression> s =
                 pdfium::MakeUnique<CXFA_FMIndexExpression>(
                     tempLine, ACCESSOR_NO_INDEX, nullptr, false);
             expr = pdfium::MakeUnique<CXFA_FMDotDotAccessorExpression>(
-                line, expr.release(), TOKdotdot, tempStr, s.release());
+                line, std::move(expr), TOKdotdot, tempStr, std::move(s));
             continue;
           }
         } else {
           CFX_WideString ws_TempString(m_pToken->m_wstring);
           Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
                 ws_TempString.c_str());
           return expr;
         }
         break;
       case TOKdotscream:
         NextToken();
         if (m_pToken->m_type == TOKidentifier) {
           CFX_WideStringC tempStr = m_pToken->m_wstring;
           uint32_t tempLine = m_pToken->m_uLinenum;
           NextToken();
           if (m_pToken->m_type == TOKlbracket) {
             std::unique_ptr<CXFA_FMSimpleExpression> s = ParseIndexExpression();
             if (!(m_pErrorInfo->message.IsEmpty()))
               return nullptr;
 
             expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
-                tempLine, expr.release(), TOKdotscream, tempStr, s.release());
+                tempLine, std::move(expr), TOKdotscream, tempStr, std::move(s));
           } else {
             std::unique_ptr<CXFA_FMSimpleExpression> s =
                 pdfium::MakeUnique<CXFA_FMIndexExpression>(
                     tempLine, ACCESSOR_NO_INDEX, nullptr, false);
             expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
-                line, expr.release(), TOKdotscream, tempStr, s.release());
+                line, std::move(expr), TOKdotscream, tempStr, std::move(s));
             continue;
           }
         } else {
           CFX_WideString ws_TempString(m_pToken->m_wstring);
           Error(m_pToken->m_uLinenum, kFMErrExpectedIdentifier,
                 ws_TempString.c_str());
           return expr;
         }
         break;
       case TOKdotstar: {
         std::unique_ptr<CXFA_FMSimpleExpression> s =
             pdfium::MakeUnique<CXFA_FMIndexExpression>(line, ACCESSOR_NO_INDEX,
                                                        nullptr, false);
         expr = pdfium::MakeUnique<CXFA_FMDotAccessorExpression>(
-            line, expr.release(), TOKdotstar, FX_WSTRC(L"*"), s.release());
+            line, std::move(expr), TOKdotstar, L"*", std::move(s));
       } break;
       default:
         return expr;
     }
     NextToken();
   }
   return expr;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseIndexExpression() {
   std::unique_ptr<CXFA_FMSimpleExpression> pExp;
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   std::unique_ptr<CXFA_FMSimpleExpression> s;
   XFA_FM_AccessorIndex accessorIndex = ACCESSOR_NO_RELATIVEINDEX;
   if (m_pToken->m_type == TOKmul) {
     pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex,
-                                                      s.release(), true);
+                                                      std::move(s), true);
     NextToken();
     if (m_pToken->m_type != TOKrbracket) {
       CFX_WideString ws_TempString(m_pToken->m_wstring);
       Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
             XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str());
       pExp.reset();
     }
     return pExp;
   }
   if (m_pToken->m_type == TOKplus) {
     accessorIndex = ACCESSOR_POSITIVE_INDEX;
     NextToken();
   } else if (m_pToken->m_type == TOKminus) {
     accessorIndex = ACCESSOR_NEGATIVE_INDEX;
     NextToken();
   }
   s = ParseSimpleExpression();
   if (m_pToken->m_type != TOKrbracket) {
     CFX_WideString ws_TempString(m_pToken->m_wstring);
     Error(m_pToken->m_uLinenum, kFMErrExpectedToken,
           XFA_FM_KeywordToString(TOKrparen), ws_TempString.c_str());
   } else {
     pExp = pdfium::MakeUnique<CXFA_FMIndexExpression>(line, accessorIndex,
-                                                      s.release(), false);
+                                                      std::move(s), false);
   }
   return pExp;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression> CXFA_FMParse::ParseParenExpression() {
   Check(TOKlparen);
 
   if (m_pToken->m_type == TOKrparen) {
     Error(m_pToken->m_uLinenum, kFMErrExpectedNonEmptyExpression);
     NextToken();
     return nullptr;
   }
 
   uint32_t line = m_pToken->m_uLinenum;
   std::unique_ptr<CXFA_FMSimpleExpression> pExp1 = ParseLogicalOrExpression();
 
   while (m_pToken->m_type == TOKassign) {
     NextToken();
     std::unique_ptr<CXFA_FMSimpleExpression> pExp2 = ParseLogicalOrExpression();
     if (m_pErrorInfo->message.IsEmpty()) {
       pExp1 = pdfium::MakeUnique<CXFA_FMAssignExpression>(
-          line, TOKassign, pExp1.release(), pExp2.release());
+          line, TOKassign, std::move(pExp1), std::move(pExp2));
     } else {
       pExp1.reset();
     }
   }
   Check(TOKrparen);
   return pExp1;
 }
 
 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseBlockExpression() {
   uint32_t line = m_pToken->m_uLinenum;
@@ skipping 78 matching lines @@
       Check(TOKendif);
       break;
     default:
       CFX_WideString ws_TempString(m_pToken->m_wstring);
       Error(m_pToken->m_uLinenum, kFMErrExpectedEndIf, ws_TempString.c_str());
       NextToken();
       break;
   }
   std::unique_ptr<CXFA_FMIfExpression> pExp;
   if (m_pErrorInfo->message.IsEmpty()) {
-    pExp = pdfium::MakeUnique<CXFA_FMIfExpression>(line, pExpression.release(),
-                                                   pIfExpression.release(),
-                                                   pElseExpression.release());
+    pExp = pdfium::MakeUnique<CXFA_FMIfExpression>(line, std::move(pExpression),
+                                                   std::move(pIfExpression),
+                                                   std::move(pElseExpression));
   }
   return pExp;
 }
 
 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseWhileExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   std::unique_ptr<CXFA_FMSimpleExpression> pCondition = ParseParenExpression();
   Check(TOKdo);
   std::unique_ptr<CXFA_FMExpression> pExpression = ParseBlockExpression();
   Check(TOKendwhile);
   std::unique_ptr<CXFA_FMExpression> expr;
   if (m_pErrorInfo->message.IsEmpty()) {
     expr = pdfium::MakeUnique<CXFA_FMWhileExpression>(
-        line, pCondition.release(), pExpression.release());
+        line, std::move(pCondition), std::move(pExpression));
   }
   return expr;
 }
 
 std::unique_ptr<CXFA_FMSimpleExpression>
 CXFA_FMParse::ParseSubassignmentInForExpression() {
   std::unique_ptr<CXFA_FMSimpleExpression> expr;
   switch (m_pToken->m_type) {
     case TOKidentifier:
       expr = ParseSimpleExpression();
@@ skipping 44 matching lines @@
   if (m_pToken->m_type == TOKstep) {
     NextToken();
     pStep = ParseSimpleExpression();
   }
   Check(TOKdo);
   std::unique_ptr<CXFA_FMExpression> pList = ParseBlockExpression();
   Check(TOKendfor);
   std::unique_ptr<CXFA_FMExpression> expr;
   if (m_pErrorInfo->message.IsEmpty()) {
     expr = pdfium::MakeUnique<CXFA_FMForExpression>(
-        line, wsVariant, pAssignment.release(), pAccessor.release(), iDirection,
-        pStep.release(), pList.release());
+        line, wsVariant, std::move(pAssignment), std::move(pAccessor),
+        iDirection, std::move(pStep), std::move(pList));
   }
   return expr;
 }
 
 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseForeachExpression() {
   std::unique_ptr<CXFA_FMExpression> expr;
   CFX_WideStringC wsIdentifier;
   std::vector<std::unique_ptr<CXFA_FMSimpleExpression>> pAccessors;
   std::unique_ptr<CXFA_FMExpression> pList;
   uint32_t line = m_pToken->m_uLinenum;
@@ skipping 21 matching lines @@
         break;
       NextToken();
     }
     Check(TOKrparen);
   }
   Check(TOKdo);
   pList = ParseBlockExpression();
   Check(TOKendfor);
   if (m_pErrorInfo->message.IsEmpty()) {
     expr = pdfium::MakeUnique<CXFA_FMForeachExpression>(
-        line, wsIdentifier, std::move(pAccessors), pList.release());
+        line, wsIdentifier, std::move(pAccessors), std::move(pList));
   }
   return expr;
 }
 
 std::unique_ptr<CXFA_FMExpression> CXFA_FMParse::ParseDoExpression() {
   uint32_t line = m_pToken->m_uLinenum;
   NextToken();
   std::unique_ptr<CXFA_FMExpression> expr = ParseBlockExpression();
   Check(TOKend);
   if (m_pErrorInfo->message.IsEmpty()) {
-    expr = pdfium::MakeUnique<CXFA_FMDoExpression>(line, expr.release());
+    expr = pdfium::MakeUnique<CXFA_FMDoExpression>(line, std::move(expr));
   } else {
     expr.reset();
   }
   return expr;
 }