gn format: fix comments at end of blocks

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"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "tools/gn/err.h"
 #include "tools/gn/token.h"
 #include "tools/gn/value.h"
 
 class AccessorNode;
 class BinaryOpNode;
 class BlockNode;
 class ConditionNode;
 class FunctionCallNode;
 class IdentifierNode;
 class ListNode;
 class LiteralNode;
 class Scope;
 class UnaryOpNode;
 class BlockCommentNode;
+class EndNode;

[brettw, 2014/09/26 21:37:34]

Can you sort this list?

[scottmg, 2014/09/26 21:47:32]

Done.

 
 class Comments {
  public:
   Comments();
   virtual ~Comments();
 
   const std::vector<Token>& before() const { return before_; }
   void append_before(Token c) {
     before_.push_back(c);
   }
@@ skipping 37 matching lines @@
   virtual const AccessorNode* AsAccessor() const;
   virtual const BinaryOpNode* AsBinaryOp() const;
   virtual const BlockNode* AsBlock() const;
   virtual const ConditionNode* AsConditionNode() const;
   virtual const FunctionCallNode* AsFunctionCall() const;
   virtual const IdentifierNode* AsIdentifier() const;
   virtual const ListNode* AsList() const;
   virtual const LiteralNode* AsLiteral() const;
   virtual const UnaryOpNode* AsUnaryOp() const;
   virtual const BlockCommentNode* AsBlockComment() const;
+  virtual const EndNode* AsEnd() const;
 
   virtual Value Execute(Scope* scope, Err* err) const = 0;
 
   virtual LocationRange GetRange() const = 0;
 
   // Returns an error with the given messages and the range set to something
   // that indicates this node.
   virtual Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const = 0;
@@ skipping 124 matching lines @@
 
   virtual const BlockNode* AsBlock() const OVERRIDE;
   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
   virtual LocationRange GetRange() const OVERRIDE;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const OVERRIDE;
   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
-  void set_end_token(const Token& t) { end_token_ = t; }
+  void set_end(scoped_ptr<EndNode> e) { end_ = e.Pass(); }
+  const EndNode* End() const { return end_.get(); }
 
   const std::vector<ParseNode*>& statements() const { return statements_; }
   void append_statement(scoped_ptr<ParseNode> s) {
     statements_.push_back(s.release());
   }
 
   // Doesn't create a nested scope.
   Value ExecuteBlockInScope(Scope* our_scope, Err* err) const;
 
  private:
   bool has_scope_;
 
-  // Tokens corresponding to { and }, if any (may be NULL).
+  // Tokens corresponding to { and }, if any (may be NULL). The end is stored
+  // in a custom parse node so that it can have comments hung off of it.
   Token begin_token_;
-  Token end_token_;
+  scoped_ptr<EndNode> end_;
 
   // Owning pointers, use unique_ptr when we can use C++11.
   std::vector<ParseNode*> statements_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockNode);
 };
 
 // ConditionNode ---------------------------------------------------------------
 
 class ConditionNode : public ParseNode {
@@ skipping 105 matching lines @@
 
   virtual const ListNode* AsList() const OVERRIDE;
   virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
   virtual LocationRange GetRange() const OVERRIDE;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const OVERRIDE;
   virtual void Print(std::ostream& out, int indent) const OVERRIDE;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
-  void set_end_token(const Token& t) { end_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_; }
 
  private:
-  // Tokens corresponding to the [ and ].
+  // 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_;
-  Token end_token_;
+  scoped_ptr<EndNode> end_;
 
   // Owning pointers, use unique_ptr when we can use C++11.
   std::vector<const ParseNode*> contents_;
 
   DISALLOW_COPY_AND_ASSIGN(ListNode);
 };
 
 // LiteralNode -----------------------------------------------------------------
 
 class LiteralNode : public ParseNode {
@@ skipping 71 matching lines @@
 
   const Token& comment() const { return comment_; }
   void set_comment(const Token& t) { comment_ = t; }
 
  private:
   Token comment_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockCommentNode);
 };
 
+// EndNode ---------------------------------------------------------------------
+
+class EndNode : public IdentifierNode {

[brettw, 2014/09/26 21:37:34]

Can you document here what this is for? It's not self-explanatory.

It's weird it inherits from identifier since this isn't an identifier. I guess
you just want a node with a token, but I think it would be more clear to
duplicate this, and also provide a more reasonable implementation of Execute
(just return Value() I guess).

[scottmg, 2014/09/26 21:47:32]

Done.
Yes, that was just unnecessary expedience, made it a plain ParseNode with its
own implementation.

+ public:
+  EndNode();
+  EndNode(const Token& token);
+  virtual ~EndNode();
+
+  virtual const IdentifierNode* AsIdentifier() const OVERRIDE;
+  virtual const EndNode* AsEnd() const OVERRIDE;
+  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+};
+
 #endif  // TOOLS_GN_PARSE_TREE_H_