gn format: Have format sort sources

tools/gn/parse_tree.h

 // 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.
 
 #ifndef TOOLS_GN_PARSE_TREE_H_
 #define TOOLS_GN_PARSE_TREE_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 14 matching lines @@
 class LiteralNode;
 class Scope;
 class UnaryOpNode;
 
 class Comments {
  public:
   Comments();
   virtual ~Comments();
 
   const std::vector<Token>& before() const { return before_; }
-  void append_before(Token c) {
-    before_.push_back(c);
-  }
+  void append_before(Token c) { before_.push_back(c); }
+  void clear_before() { before_.clear(); }
 
   const std::vector<Token>& suffix() const { return suffix_; }
-  void append_suffix(Token c) {
-    suffix_.push_back(c);
-  }
+  void append_suffix(Token c) { suffix_.push_back(c); }
   // Reverse the order of the suffix comments. When walking the tree in
   // post-order we append suffix comments in reverse order, so this fixes them
   // up.
   void ReverseSuffix();
 
   const std::vector<Token>& after() const { return after_; }
-  void append_after(Token c) {
-    after_.push_back(c);
-  }
+  void append_after(Token c) { after_.push_back(c); }
 
  private:
   // Whole line comments before the expression.
   std::vector<Token> before_;
 
   // End-of-line comments after this expression.
   std::vector<Token> suffix_;
 
   // For top-level expressions only, after_ lists whole-line comments
   // following the expression.
@@ skipping 91 matching lines @@
 
   // Index is the expression inside the []. Will be null if member is set.
   const ParseNode* index() const { return index_.get(); }
   void set_index(scoped_ptr<ParseNode> i) { index_ = i.Pass(); }
 
   // The member is the identifier on the right hand side of the dot. Will be
   // null if the index is set.
   const IdentifierNode* member() const { return member_.get(); }
   void set_member(scoped_ptr<IdentifierNode> i) { member_ = i.Pass(); }
 
+  void SetNewLocation(int line_number);
+
  private:
   Value ExecuteArrayAccess(Scope* scope, Err* err) const;
   Value ExecuteScopeAccess(Scope* scope, Err* err) const;
 
   Token base_;
 
   // Either index or member will be set according to what type of access this
   // is.
   scoped_ptr<ParseNode> index_;
   scoped_ptr<IdentifierNode> member_;
@@ skipping 168 matching lines @@
   Value Execute(Scope* scope, Err* err) const override;
   LocationRange GetRange() const override;
   Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
   void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
+  void SetNewLocation(int line_number);
+
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(IdentifierNode);
 };
 
 // ListNode --------------------------------------------------------------------
 
 class ListNode : public ParseNode {
  public:
@@ skipping 10 matching lines @@
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(scoped_ptr<EndNode> e) { end_ = e.Pass(); }
   const EndNode* End() const { return end_.get(); }
 
   void append_item(scoped_ptr<ParseNode> s) {
     contents_.push_back(s.release());
   }
   const std::vector<const ParseNode*>& contents() const { return contents_; }
 
+  void SortAsStringsList();
+
   // During formatting, do we want this list to always be multliline? This is
   // used to make assignments to deps, sources, etc. always be multiline lists,
   // rather than collapsed to a single line when they're one element.
   bool prefer_multiline() const { return prefer_multiline_; }
   void set_prefer_multiline(bool prefer_multiline) {
     prefer_multiline_ = prefer_multiline;
   }
 
+  struct SortRange {
+    size_t begin;
+    size_t end;
+    SortRange(size_t begin, size_t end) : begin(begin), end(end) {}
+  };
+  // Only public for testing.
+  std::vector<SortRange> GetSortRanges() const;
+
  private:
   // Tokens corresponding to the [ and ]. The end token is stored in inside an
   // custom parse node so that it can have comments hung off of it.
   Token begin_token_;
   scoped_ptr<EndNode> end_;
   bool prefer_multiline_;
 
   // Owning pointers, use unique_ptr when we can use C++11.
   std::vector<const ParseNode*> contents_;
 
@@ skipping 12 matching lines @@
   Value Execute(Scope* scope, Err* err) const override;
   LocationRange GetRange() const override;
   Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
   void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
+  void SetNewLocation(int line_number);
+
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(LiteralNode);
 };
 
 // UnaryOpNode -----------------------------------------------------------------
 
 class UnaryOpNode : public ParseNode {
  public:
@@ skipping 74 matching lines @@
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(EndNode);
 };
 
 #endif  // TOOLS_GN_PARSE_TREE_H_