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

tools/gn/parse_tree.cc

 // Copyright (c) 2013 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 "tools/gn/parse_tree.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <tuple>
@@ skipping 279 matching lines @@
   left_->Print(out, indent + 1);
   right_->Print(out, indent + 1);
 }
 
 // BlockNode ------------------------------------------------------------------
 
 BlockNode::BlockNode() {
 }
 
 BlockNode::~BlockNode() {
-  STLDeleteContainerPointers(statements_.begin(), statements_.end());
 }
 
 const BlockNode* BlockNode::AsBlock() const {
   return this;
 }
 
 Value BlockNode::Execute(Scope* scope, Err* err) const {
   for (size_t i = 0; i < statements_.size() && !err->has_error(); i++) {
     // Check for trying to execute things with no side effects in a block.
-    const ParseNode* cur = statements_[i];
+    const ParseNode* cur = statements_[i].get();
     if (cur->AsList() || cur->AsLiteral() || cur->AsUnaryOp() ||
         cur->AsIdentifier()) {
       *err = cur->MakeErrorDescribing(
           "This statement has no effect.",
           "Either delete it or do something with the result.");
       return Value();
     }
     cur->Execute(scope, err);
   }
   return Value();
@@ skipping 164 matching lines @@
   value_.set_location(
       Location(old.file(), line_number, old.column_number(), old.byte()));
 }
 
 // ListNode -------------------------------------------------------------------
 
 ListNode::ListNode() : prefer_multiline_(false) {
 }
 
 ListNode::~ListNode() {
-  STLDeleteContainerPointers(contents_.begin(), contents_.end());
 }
 
 const ListNode* ListNode::AsList() const {
   return this;
 }
 
 Value ListNode::Execute(Scope* scope, Err* err) const {
   Value result_value(this, Value::LIST);
   std::vector<Value>& results = result_value.list_value();
   results.reserve(contents_.size());
@@ skipping 34 matching lines @@
     end_->Print(out, indent + 1);
 }
 
 template <typename Comparator>
 void ListNode::SortList(Comparator comparator) {
   // Partitions first on BlockCommentNodes and sorts each partition separately.
   for (auto sr : GetSortRanges()) {
     bool skip = false;
     for (size_t i = sr.begin; i != sr.end; ++i) {
       // Bails out if any of the nodes are unsupported.
-      const ParseNode* node = contents_[i];
+      const ParseNode* node = contents_[i].get();
       if (!node->AsLiteral() && !node->AsIdentifier() && !node->AsAccessor()) {
         skip = true;
         continue;
       }
     }
     if (skip)
       continue;
     // Save the original line number so that we can re-assign ranges. We assume
     // they're contiguous lines because GetSortRanges() does so above. We need
     // to re-assign these line numbers primiarily because `gn format` uses them
     // to determine whether two nodes were initially separated by a blank line
     // or not.
     int start_line = contents_[sr.begin]->GetRange().begin().line_number();
-    const ParseNode* original_first = contents_[sr.begin];
+    const ParseNode* original_first = contents_[sr.begin].get();
     std::sort(contents_.begin() + sr.begin, contents_.begin() + sr.end,
-              comparator);
+              [&comparator](const std::unique_ptr<const ParseNode>& a,
+                            const std::unique_ptr<const ParseNode>& b) {
+                return comparator(a.get(), b.get());
+              });
     // If the beginning of the range had before comments, and the first node
     // moved during the sort, then move its comments to the new head of the
     // range.
-    if (original_first->comments() && contents_[sr.begin] != original_first) {
+    if (original_first->comments() &&
+        contents_[sr.begin].get() != original_first) {
       for (const auto& hc : original_first->comments()->before()) {
-        const_cast<ParseNode*>(contents_[sr.begin])
+        const_cast<ParseNode*>(contents_[sr.begin].get())
             ->comments_mutable()
             ->append_before(hc);
       }
       const_cast<ParseNode*>(original_first)
           ->comments_mutable()
           ->clear_before();
     }
     const ParseNode* prev = nullptr;
     for (size_t i = sr.begin; i != sr.end; ++i) {
-      const ParseNode* node = contents_[i];
+      const ParseNode* node = contents_[i].get();
       DCHECK(node->AsLiteral() || node->AsIdentifier() || node->AsAccessor());
       int line_number =
           prev ? prev->GetRange().end().line_number() + 1 : start_line;
       if (node->AsLiteral()) {
         const_cast<LiteralNode*>(node->AsLiteral())
             ->SetNewLocation(line_number);
       } else if (node->AsIdentifier()) {
         const_cast<IdentifierNode*>(node->AsIdentifier())
             ->SetNewLocation(line_number);
       } else if (node->AsAccessor()) {
@@ skipping 27 matching lines @@
 
 // Breaks the ParseNodes of |contents| up by ranges that should be separately
 // sorted. In particular, we break at a block comment, or an item that has an
 // attached "before" comment and is separated by a blank line from the item
 // before it. The assumption is that both of these indicate a separate 'section'
 // of a sources block across which items should not be inter-sorted.
 std::vector<ListNode::SortRange> ListNode::GetSortRanges() const {
   std::vector<SortRange> ranges;
   const ParseNode* prev = nullptr;
   size_t begin = 0;
-  for (size_t i = begin; i < contents_.size(); prev = contents_[i++]) {
-    if (IsSortRangeSeparator(contents_[i], prev)) {
+  for (size_t i = begin; i < contents_.size(); prev = contents_[i++].get()) {
+    if (IsSortRangeSeparator(contents_[i].get(), prev)) {
       if (i > begin) {
         ranges.push_back(SortRange(begin, i));
         // If |i| is an item with an attached comment, then we start the next
         // range at that point, because we want to include it in the sort.
         // Otherwise, it's a block comment which we skip over entirely because
         // we don't want to move or include it in the sort. The two cases are:
         //
         // sources = [
         //   "a",
         //   "b",
@@ skipping 189 matching lines @@
 
 Err EndNode::MakeErrorDescribing(const std::string& msg,
                                         const std::string& help) const {
   return Err(value_, msg, help);
 }
 
 void EndNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "END(" << value_.value() << ")\n";
   PrintComments(out, indent);
 }