tools/gn: don't allow trailing junk or non-literals in "value" conversion

tools/gn/parser.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/parser.h"
 
 #include "base/logging.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/operators.h"
 #include "tools/gn/token.h"
@@ skipping 156 matching lines @@
     {nullptr, nullptr, -1},                                       // COMMA
     {nullptr, nullptr, -1},                // UNCLASSIFIED_COMMENT
     {nullptr, nullptr, -1},                // LINE_COMMENT
     {nullptr, nullptr, -1},                // SUFFIX_COMMENT
     {&Parser::BlockComment, nullptr, -1},  // BLOCK_COMMENT
 };
 
 Parser::Parser(const std::vector<Token>& tokens, Err* err)
     : err_(err), cur_(0) {
   for (const auto& token : tokens) {
-    switch(token.type()) {
+    switch (token.type()) {
       case Token::LINE_COMMENT:
         line_comment_tokens_.push_back(token);
         break;
       case Token::SUFFIX_COMMENT:
         suffix_comment_tokens_.push_back(token);
         break;
       default:
         // Note that BLOCK_COMMENTs (top-level standalone comments) are passed
         // through the real parser.
         tokens_.push_back(token);
         break;
     }
   }
 }
 
 Parser::~Parser() {
 }
 
 // static
 scoped_ptr<ParseNode> Parser::Parse(const std::vector<Token>& tokens,
                                     Err* err) {
   Parser p(tokens, err);
   return p.ParseFile();
 }
 
 // static
 scoped_ptr<ParseNode> Parser::ParseExpression(const std::vector<Token>& tokens,
                                               Err* err) {
   Parser p(tokens, err);
-  return p.ParseExpression().Pass();
+  scoped_ptr<ParseNode> expr = p.ParseExpression();
+  if (!p.at_end() && !err->has_error()) {
+    *err = Err(p.cur_token(), "Trailing garbage");
+    return nullptr;
+  }
+  return expr.Pass();
+}
+
+// static
+scoped_ptr<ParseNode> Parser::ParseValue(const std::vector<Token>& tokens,
+                                         Err* err) {
+  for (const Token& token : tokens) {
+    switch (token.type()) {
+      case Token::INTEGER:
+      case Token::STRING:
+      case Token::TRUE_TOKEN:
+      case Token::FALSE_TOKEN:
+      case Token::LEFT_BRACKET:
+      case Token::RIGHT_BRACKET:
+      case Token::COMMA:
+        continue;
+      default:
+        *err = Err(token, "Invalid token in literal value");
+        return nullptr;
+    }
+  }
+
+  return ParseExpression(tokens, err);
 }
 
 bool Parser::IsAssignment(const ParseNode* node) const {
   return node && node->AsBinaryOp() &&
          (node->AsBinaryOp()->op().type() == Token::EQUAL ||
           node->AsBinaryOp()->op().type() == Token::PLUS_EQUALS ||
           node->AsBinaryOp()->op().type() == Token::MINUS_EQUALS);
 }
 
 bool Parser::IsStatementBreak(Token::Type token_type) const {
@@ skipping 489 matching lines @@
         break;
       }
     }
 
     // Suffix comments were assigned in reverse, so if there were multiple on
     // the same node, they need to be reversed.
     if ((*i)->comments() && !(*i)->comments()->suffix().empty())
       const_cast<ParseNode*>(*i)->comments_mutable()->ReverseSuffix();
   }
 }