GN: Replace vector<ParseNode*> with vector<unique_ptr<ParseNode>> in parse_tree.h.

tools/gn/command_format.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 
 #include <sstream>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 163 matching lines @@
   int AssessPenalty(const std::string& output);
 
   // Tests if any lines exceed the maximum width.
   bool ExceedsMaximumWidth(const std::string& output);
 
   // Format a list of values using the given style.
   // |end| holds any trailing comments to be printed just before the closing
   // bracket.
   template <class PARSENODE>  // Just for const covariance.
   void Sequence(SequenceStyle style,
-                const std::vector<PARSENODE*>& list,
+                const std::vector<std::unique_ptr<PARSENODE>>& list,
                 const ParseNode* end,
                 bool force_multiline);
 
   // Returns the penalty.
   int FunctionCall(const FunctionCallNode* func_call,
                    const std::string& suffix);
 
   // Create a clone of this Printer in a similar state (other than the output,
   // but including margins, etc.) to be used for dry run measurements.
   void InitializeSub(Printer* sub);
 
   template <class PARSENODE>
-  bool ListWillBeMultiline(const std::vector<PARSENODE*>& list,
+  bool ListWillBeMultiline(const std::vector<std::unique_ptr<PARSENODE>>& list,
                            const ParseNode* end);
 
   std::string output_;           // Output buffer.
   std::vector<Token> comments_;  // Pending end-of-line comments.
   int margin() const { return stack_.back().margin; }
 
   int penalty_depth_;
   int GetPenaltyForLineBreak() const {
     return penalty_depth_ * kPenaltyLineBreak;
   }
@@ skipping 170 matching lines @@
 
   if (block->comments()) {
     for (const auto& c : block->comments()->before()) {
       TrimAndPrintToken(c);
       Newline();
     }
   }
 
   size_t i = 0;
   for (const auto& stmt : block->statements()) {
-    Expr(stmt, kPrecedenceLowest, std::string());
+    Expr(stmt.get(), kPrecedenceLowest, std::string());
     Newline();
     if (stmt->comments()) {
       // Why are before() not printed here too? before() are handled inside
       // Expr(), as are suffix() which are queued to the next Newline().
       // However, because it's a general expression handler, it doesn't insert
       // the newline itself, which only happens between block statements. So,
       // the after are handled explicitly here.
       for (const auto& c : stmt->comments()->after()) {
         TrimAndPrintToken(c);
         Newline();
       }
     }
     if (i < block->statements().size() - 1 &&
-        (ShouldAddBlankLineInBetween(block->statements()[i],
-                                     block->statements()[i + 1]))) {
+        (ShouldAddBlankLineInBetween(block->statements()[i].get(),
+                                     block->statements()[i + 1].get()))) {
       Newline();
     }
     ++i;
   }
 
   if (block->comments()) {
     for (const auto& c : block->comments()->after()) {
       TrimAndPrintToken(c);
       Newline();
     }
@@ skipping 227 matching lines @@
   }
 
   Print(at_end);
 
   penalty_depth_--;
   return penalty;
 }
 
 template <class PARSENODE>
 void Printer::Sequence(SequenceStyle style,
-                       const std::vector<PARSENODE*>& list,
+                       const std::vector<std::unique_ptr<PARSENODE>>& list,
                        const ParseNode* end,
                        bool force_multiline) {
   if (style == kSequenceStyleList)
     Print("[");
   else if (style == kSequenceStyleBracedBlock)
     Print("{");
 
   if (style == kSequenceStyleBlock || style == kSequenceStyleBracedBlock)
     force_multiline = true;
 
   force_multiline |= ListWillBeMultiline(list, end);
 
   if (list.size() == 0 && !force_multiline) {
     // No elements, and not forcing newlines, print nothing.
   } else if (list.size() == 1 && !force_multiline) {
     Print(" ");
-    Expr(list[0], kPrecedenceLowest, std::string());
+    Expr(list[0].get(), kPrecedenceLowest, std::string());
     CHECK(!list[0]->comments() || list[0]->comments()->after().empty());
     Print(" ");
   } else {
     stack_.push_back(IndentState(margin() + kIndentSize,
                                  style == kSequenceStyleList,
                                  false));
     size_t i = 0;
     for (const auto& x : list) {
       Newline();
       // If:
       // - we're going to output some comments, and;
       // - we haven't just started this multiline list, and;
       // - there isn't already a blank line here;
       // Then: insert one.
       if (i != 0 && x->comments() && !x->comments()->before().empty() &&
           !HaveBlankLine()) {
         Newline();
       }
       bool body_of_list = i < list.size() - 1 || style == kSequenceStyleList;
       bool want_comma =
           body_of_list && (style == kSequenceStyleList && !x->AsBlockComment());
-      Expr(x, kPrecedenceLowest, want_comma ? "," : std::string());
+      Expr(x.get(), kPrecedenceLowest, want_comma ? "," : std::string());
       CHECK(!x->comments() || x->comments()->after().empty());
       if (body_of_list) {
         if (i < list.size() - 1 &&
-            ShouldAddBlankLineInBetween(list[i], list[i + 1]))
+            ShouldAddBlankLineInBetween(list[i].get(), list[i + 1].get()))
           Newline();
       }
       ++i;
     }
 
     // Trailing comments.
     if (end->comments() && !end->comments()->before().empty()) {
       if (list.size() >= 2)
         Newline();
       for (const auto& c : end->comments()->before()) {
@@ skipping 22 matching lines @@
 int Printer::FunctionCall(const FunctionCallNode* func_call,
                           const std::string& suffix) {
   int start_line = CurrentLine();
   int start_column = CurrentColumn();
   Print(func_call->function().value());
   Print("(");
 
   bool have_block = func_call->block() != nullptr;
   bool force_multiline = false;
 
-  const std::vector<const ParseNode*>& list = func_call->args()->contents();
+  const auto& list = func_call->args()->contents();
   const ParseNode* end = func_call->args()->End();
 
   if (end && end->comments() && !end->comments()->before().empty())
     force_multiline = true;
 
   // If there's before line comments, make sure we have a place to put them.
   for (const auto& i : list) {
     if (i->comments() && !i->comments()->before().empty())
       force_multiline = true;
   }
@@ skipping 12 matching lines @@
   bool continuation_requires_indent =
       list.size() != 1 || !list[0]->AsBinaryOp();
 
   // 1: Same line.
   Printer sub1;
   InitializeSub(&sub1);
   sub1.stack_.push_back(
       IndentState(CurrentColumn(), continuation_requires_indent, false));
   int penalty_one_line = 0;
   for (size_t i = 0; i < list.size(); ++i) {
-    penalty_one_line += sub1.Expr(list[i], kPrecedenceLowest,
+    penalty_one_line += sub1.Expr(list[i].get(), kPrecedenceLowest,
                                   i < list.size() - 1 ? ", " : std::string());
   }
   sub1.Print(terminator);
   penalty_one_line += AssessPenalty(sub1.String());
   // This extra penalty prevents a short second argument from being squeezed in
   // after a first argument that went multiline (and instead preferring a
   // variant below).
   penalty_one_line +=
       (CountLines(sub1.String()) - 1) * kPenaltyBrokenLineOnOneLiner;
 
   // 2: Starting on same line, broken at commas.
   Printer sub2;
   InitializeSub(&sub2);
   sub2.stack_.push_back(
       IndentState(CurrentColumn(), continuation_requires_indent, false));
   int penalty_multiline_start_same_line = 0;
   for (size_t i = 0; i < list.size(); ++i) {
-    penalty_multiline_start_same_line += sub2.Expr(
-        list[i], kPrecedenceLowest, i < list.size() - 1 ? "," : std::string());
+    penalty_multiline_start_same_line +=
+        sub2.Expr(list[i].get(), kPrecedenceLowest,
+                  i < list.size() - 1 ? "," : std::string());
     if (i < list.size() - 1) {
       sub2.Newline();
     }
   }
   sub2.Print(terminator);
   penalty_multiline_start_same_line += AssessPenalty(sub2.String());
 
   // 3: Starting on next line, broken at commas.
   Printer sub3;
   InitializeSub(&sub3);
   sub3.stack_.push_back(IndentState(margin() + kIndentSize * 2,
                                     continuation_requires_indent, false));
   sub3.Newline();
   int penalty_multiline_start_next_line = 0;
   for (size_t i = 0; i < list.size(); ++i) {
     if (i == 0) {
       penalty_multiline_start_next_line +=
           std::abs(sub3.CurrentColumn() - start_column) *
           kPenaltyHorizontalSeparation;
     }
-    penalty_multiline_start_next_line += sub3.Expr(
-        list[i], kPrecedenceLowest, i < list.size() - 1 ? "," : std::string());
+    penalty_multiline_start_next_line +=
+        sub3.Expr(list[i].get(), kPrecedenceLowest,
+                  i < list.size() - 1 ? "," : std::string());
     if (i < list.size() - 1) {
       sub3.Newline();
     }
   }
   sub3.Print(terminator);
   penalty_multiline_start_next_line += AssessPenalty(sub3.String());
 
   int penalty = penalty_multiline_start_next_line;
   bool fits_on_current_line = false;
   if (penalty_one_line < penalty_multiline_start_next_line ||
@@ skipping 23 matching lines @@
 
     for (size_t i = 0; i < list.size(); ++i) {
       const auto& x = list[i];
       if (i > 0) {
         if (fits_on_current_line && !force_multiline)
           Print(" ");
         else
           Newline();
       }
       bool want_comma = i < list.size() - 1 && !x->AsBlockComment();
-      Expr(x, kPrecedenceLowest, want_comma ? "," : std::string());
+      Expr(x.get(), kPrecedenceLowest, want_comma ? "," : std::string());
       CHECK(!x->comments() || x->comments()->after().empty());
       if (i < list.size() - 1) {
         if (!want_comma)
           Newline();
       }
     }
 
     // Trailing comments.
     if (end->comments() && !end->comments()->before().empty()) {
       if (!list.empty())
@@ skipping 27 matching lines @@
 }
 
 void Printer::InitializeSub(Printer* sub) {
   sub->stack_ = stack_;
   sub->comments_ = comments_;
   sub->penalty_depth_ = penalty_depth_;
   sub->Print(std::string(CurrentColumn(), 'x'));
 }
 
 template <class PARSENODE>
-bool Printer::ListWillBeMultiline(const std::vector<PARSENODE*>& list,
-                                  const ParseNode* end) {
+bool Printer::ListWillBeMultiline(
+    const std::vector<std::unique_ptr<PARSENODE>>& list,
+    const ParseNode* end) {
   if (list.size() > 1)
     return true;
 
   if (end && end->comments() && !end->comments()->before().empty())
     return true;
 
   // If there's before line comments, make sure we have a place to put them.
   for (const auto& i : list) {
     if (i->comments() && !i->comments()->before().empty())
       return true;
@@ skipping 153 matching lines @@
       }
     } else {
       printf("%s", output_string.c_str());
     }
   }
 
   return 0;
 }
 
 }  // namespace commands