gn: attach comments to parse tree

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 <string>
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/operators.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/string_utils.h"
 
 namespace {
 
 std::string IndentFor(int value) {
-  std::string ret;
-  for (int i = 0; i < value; i++)
-    ret.append(" ");
-  return ret;
+  return std::string(value, ' ');
 }
 
 }  // namespace
 
+Comments::Comments() {
+}
+
+Comments::~Comments() {
+}
+
 ParseNode::ParseNode() {
 }
 
 ParseNode::~ParseNode() {
 }
 
 const AccessorNode* ParseNode::AsAccessor() const { return NULL; }
 const BinaryOpNode* ParseNode::AsBinaryOp() const { return NULL; }
 const BlockNode* ParseNode::AsBlock() const { return NULL; }
 const ConditionNode* ParseNode::AsConditionNode() const { return NULL; }
 const FunctionCallNode* ParseNode::AsFunctionCall() const { return NULL; }
 const IdentifierNode* ParseNode::AsIdentifier() const { return NULL; }
 const ListNode* ParseNode::AsList() const { return NULL; }
 const LiteralNode* ParseNode::AsLiteral() const { return NULL; }
 const UnaryOpNode* ParseNode::AsUnaryOp() const { return NULL; }
 
+Comments* ParseNode::comments_mutable() {
+  if (!comments_)
+    comments_.reset(new Comments);
+  return comments_.get();
+}
+
+void ParseNode::PrintComments(std::ostream& out, int indent) const {
+  if (comments_) {
+    std::string ind = IndentFor(indent + 1);
+    for (std::vector<Token>::const_iterator i(comments_->before().begin());
+         i != comments_->before().end();
+         ++i) {
+      out << ind << "+BEFORE_COMMENT(\"" << i->value() << "\")\n";
+    }
+    for (std::vector<Token>::const_iterator i(comments_->suffix().begin());
+         i != comments_->suffix().end();
+         ++i) {
+      out << ind << "+SUFFIX_COMMENT(\"" << i->value() << "\")\n";
+    }
+    for (std::vector<Token>::const_iterator i(comments_->after().begin());
+         i != comments_->after().end();
+         ++i) {
+      out << ind << "+AFTER_COMMENT(\"" << i->value() << "\")\n";
+    }
+  }
+}
+
 // AccessorNode ---------------------------------------------------------------
 
 AccessorNode::AccessorNode() {
 }
 
 AccessorNode::~AccessorNode() {
 }
 
 const AccessorNode* AccessorNode::AsAccessor() const {
   return this;
@@ skipping 17 matching lines @@
   return LocationRange();
 }
 
 Err AccessorNode::MakeErrorDescribing(const std::string& msg,
                                       const std::string& help) const {
   return Err(GetRange(), msg, help);
 }
 
 void AccessorNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "ACCESSOR\n";
+  PrintComments(out, indent);
   out << IndentFor(indent + 1) << base_.value() << "\n";
   if (index_)
     index_->Print(out, indent + 1);
   else if (member_)
     member_->Print(out, indent + 1);
 }
 
 Value AccessorNode::ExecuteArrayAccess(Scope* scope, Err* err) const {
   Value index_value = index_->Execute(scope, err);
   if (err->has_error())
@@ skipping 95 matching lines @@
   return left_->GetRange().Union(right_->GetRange());
 }
 
 Err BinaryOpNode::MakeErrorDescribing(const std::string& msg,
                                       const std::string& help) const {
   return Err(op_, msg, help);
 }
 
 void BinaryOpNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "BINARY(" << op_.value() << ")\n";
+  PrintComments(out, indent);
   left_->Print(out, indent + 1);
   right_->Print(out, indent + 1);
 }
 
 // BlockNode ------------------------------------------------------------------
 
 BlockNode::BlockNode(bool has_scope) : has_scope_(has_scope) {
 }
 
 BlockNode::~BlockNode() {
@@ skipping 29 matching lines @@
   return LocationRange();
 }
 
 Err BlockNode::MakeErrorDescribing(const std::string& msg,
                                    const std::string& help) const {
   return Err(GetRange(), msg, help);
 }
 
 void BlockNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "BLOCK\n";
+  PrintComments(out, indent);
   for (size_t i = 0; i < statements_.size(); i++)
     statements_[i]->Print(out, indent + 1);
 }
 
 Value BlockNode::ExecuteBlockInScope(Scope* our_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];
     if (cur->AsList() || cur->AsLiteral() || cur->AsUnaryOp() ||
         cur->AsIdentifier()) {
@@ skipping 56 matching lines @@
   return if_token_.range().Union(if_true_->GetRange());
 }
 
 Err ConditionNode::MakeErrorDescribing(const std::string& msg,
                                        const std::string& help) const {
   return Err(if_token_, msg, help);
 }
 
 void ConditionNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "CONDITION\n";
+  PrintComments(out, indent);
   condition_->Print(out, indent + 1);
   if_true_->Print(out, indent + 1);
   if (if_false_)
     if_false_->Print(out, indent + 1);
 }
 
 // FunctionCallNode -----------------------------------------------------------
 
 FunctionCallNode::FunctionCallNode() {
 }
@@ skipping 17 matching lines @@
   return function_.range().Union(args_->GetRange());
 }
 
 Err FunctionCallNode::MakeErrorDescribing(const std::string& msg,
                                           const std::string& help) const {
   return Err(function_, msg, help);
 }
 
 void FunctionCallNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "FUNCTION(" << function_.value() << ")\n";
+  PrintComments(out, indent);
   args_->Print(out, indent + 1);
   if (block_)
     block_->Print(out, indent + 1);
 }
 
 // IdentifierNode --------------------------------------------------------------
 
 IdentifierNode::IdentifierNode() {
 }
 
@@ skipping 24 matching lines @@
   return value_.range();
 }
 
 Err IdentifierNode::MakeErrorDescribing(const std::string& msg,
                                         const std::string& help) const {
   return Err(value_, msg, help);
 }
 
 void IdentifierNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "IDENTIFIER(" << value_.value() << ")\n";
+  PrintComments(out, indent);
 }
 
 // ListNode -------------------------------------------------------------------
 
 ListNode::ListNode() {
 }
 
 ListNode::~ListNode() {
   STLDeleteContainerPointers(contents_.begin(), contents_.end());
 }
@@ skipping 26 matching lines @@
   return LocationRange(begin_token_.location(), end_token_.location());
 }
 
 Err ListNode::MakeErrorDescribing(const std::string& msg,
                                   const std::string& help) const {
   return Err(begin_token_, msg, help);
 }
 
 void ListNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "LIST\n";
+  PrintComments(out, indent);
   for (size_t i = 0; i < contents_.size(); i++)
     contents_[i]->Print(out, indent + 1);
 }
 
 // LiteralNode -----------------------------------------------------------------
 
 LiteralNode::LiteralNode() {
 }
 
 LiteralNode::LiteralNode(const Token& token) : value_(token) {
@@ skipping 35 matching lines @@
   return value_.range();
 }
 
 Err LiteralNode::MakeErrorDescribing(const std::string& msg,
                                      const std::string& help) const {
   return Err(value_, msg, help);
 }
 
 void LiteralNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "LITERAL(" << value_.value() << ")\n";
+  PrintComments(out, indent);
 }
 
 // UnaryOpNode ----------------------------------------------------------------
 
 UnaryOpNode::UnaryOpNode() {
 }
 
 UnaryOpNode::~UnaryOpNode() {
 }
 
@@ skipping 12 matching lines @@
   return op_.range().Union(operand_->GetRange());
 }
 
 Err UnaryOpNode::MakeErrorDescribing(const std::string& msg,
                                      const std::string& help) const {
   return Err(op_, msg, help);
 }
 
 void UnaryOpNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "UNARY(" << op_.value() << ")\n";
+  PrintComments(out, indent);
   operand_->Print(out, indent + 1);
 }