Fixes to {} handling in GN.

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 428 matching lines @@
   // TODO(scottmg): If this is measurably expensive, it could be done only
   // when necessary (when reformatting, or during tests). Comments are
   // separate from the parse tree at this point, so downstream code can remain
   // ignorant of them.
   AssignComments(file.get());
 
   return file.Pass();
 }
 
 scoped_ptr<ParseNode> Parser::ParseStatement() {
-  if (LookAhead(Token::LEFT_BRACE)) {
-    return ParseBlock();
-  } else if (LookAhead(Token::IF)) {
+  if (LookAhead(Token::IF)) {
     return ParseCondition();
   } else if (LookAhead(Token::BLOCK_COMMENT)) {
     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.
     scoped_ptr<ParseNode> stmt = ParseExpression();
     if (stmt) {
       if (stmt->AsFunctionCall() || IsAssignment(stmt.get()))
         return stmt.Pass();
@@ skipping 31 matching lines @@
 scoped_ptr<ParseNode> Parser::ParseCondition() {
   scoped_ptr<ConditionNode> condition(new ConditionNode);
   condition->set_if_token(Consume(Token::IF, "Expected 'if'"));
   Consume(Token::LEFT_PAREN, "Expected '(' after 'if'.");
   condition->set_condition(ParseExpression());
   if (IsAssignment(condition->condition()))
     *err_ = Err(condition->condition(), "Assignment not allowed in 'if'.");
   Consume(Token::RIGHT_PAREN, "Expected ')' after condition of 'if'.");
   condition->set_if_true(ParseBlock().Pass());
   if (Match(Token::ELSE)) {
-    if (!LookAhead(Token::LEFT_BRACE) && !LookAhead(Token::IF)) {
+    if (LookAhead(Token::LEFT_BRACE)) {
+      condition->set_if_false(ParseBlock().Pass());
+    } else if (LookAhead(Token::IF)) {
+      condition->set_if_false(ParseStatement().Pass());
+    } else {
       *err_ = Err(cur_token(), "Expected '{' or 'if' after 'else'.");
       return scoped_ptr<ParseNode>();
     }
-    condition->set_if_false(ParseStatement().Pass());
   }
   if (has_error())
     return scoped_ptr<ParseNode>();
   return condition.Pass();
 }
 
 void Parser::TraverseOrder(const ParseNode* root,
                            std::vector<const ParseNode*>* pre,
                            std::vector<const ParseNode*>* post) {
   if (root) {
@@ skipping 97 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();
   }
 }