gn: Don't do an out-of-bound access if a file ends after 'else'

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 <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 370 matching lines @@
   Token::Type types[1] = { type };
   return Consume(types, 1, error_message);
 }
 
 Token Parser::Consume(Token::Type* types,
                       size_t num_types,
                       const char* error_message) {
   if (has_error()) {
     // Don't overwrite current error, but make progress through tokens so that
     // a loop that's expecting a particular token will still terminate.
-    cur_++;
+    if (!at_end())

[Nico, 2016/08/25 16:07:49]

this is unrelated but seems like a good change so that cur_ doesn't overflow :-P

+      cur_++;
     return Token(Location(), Token::INVALID, base::StringPiece());
   }
   if (at_end()) {
     const char kEOFMsg[] = "I hit EOF instead.";
     if (tokens_.empty())
       *err_ = Err(Location(), error_message, kEOFMsg);
     else
       *err_ = Err(tokens_[tokens_.size() - 1], error_message, kEOFMsg);
     return Token(Location(), Token::INVALID, base::StringPiece());
   }
@@ skipping 299 matching lines @@
     return BlockComment(Consume());
   } else {
     // TODO(scottmg): Is this too strict? Just drop all the testing if we want
     // to allow "pointless" expressions and return ParseExpression() directly.
     std::unique_ptr<ParseNode> stmt = ParseExpression();
     if (stmt) {
       if (stmt->AsFunctionCall() || IsAssignment(stmt.get()))
         return stmt;
     }
     if (!has_error()) {
-      Token token = at_end() ? tokens_[tokens_.size() - 1] : cur_token();
+      Token token = cur_or_last_token();

[Nico, 2016/08/25 16:07:49]

this is just extract-function

       *err_ = Err(token, "Expecting assignment or function call.");
     }
     return std::unique_ptr<ParseNode>();
   }
 }
 
 std::unique_ptr<BlockNode> Parser::ParseBlock(
     Token begin_brace,
     BlockNode::ResultMode result_mode) {
   if (has_error())
@@ skipping 26 matching lines @@
   condition->set_if_true(ParseBlock(
       Consume(Token::LEFT_BRACE, "Expected '{' to start 'if' block."),
       BlockNode::DISCARDS_RESULT));
   if (Match(Token::ELSE)) {
     if (LookAhead(Token::LEFT_BRACE)) {
       condition->set_if_false(ParseBlock(Consume(),
                                          BlockNode::DISCARDS_RESULT));
     } else if (LookAhead(Token::IF)) {
       condition->set_if_false(ParseStatement());
     } else {
-      *err_ = Err(cur_token(), "Expected '{' or 'if' after 'else'.");
+      *err_ = Err(cur_or_last_token(), "Expected '{' or 'if' after 'else'.");

[Nico, 2016/08/25 16:07:49]

this is the fix

       return std::unique_ptr<ParseNode>();
     }
   }
   if (has_error())
     return std::unique_ptr<ParseNode>();
   return std::move(condition);
 }
 
 void Parser::TraverseOrder(const ParseNode* root,
                            std::vector<const ParseNode*>* pre,
@@ skipping 99 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();
   }
 }