Add "." accessors to 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"
 
 // grammar:
 //
 // file       := (statement)*
 // statement  := block | if | assignment
 // block      := '{' statement* '}'
 // if         := 'if' '(' expr ')' statement [ else ]
 // else       := 'else' (if | statement)*
 // assignment := ident {'=' | '+=' | '-='} expr
 
 enum Precedence {
-  PRECEDENCE_ASSIGNMENT = 1,
+  PRECEDENCE_ASSIGNMENT = 1,  // Lowest precedence.
   PRECEDENCE_OR = 2,
   PRECEDENCE_AND = 3,
   PRECEDENCE_EQUALITY = 4,
   PRECEDENCE_RELATION = 5,
   PRECEDENCE_SUM = 6,
   PRECEDENCE_PREFIX = 7,
   PRECEDENCE_CALL = 8,
+  PRECEDENCE_DOT = 9,         // Highest precedence.
 };
 
-// The top-level for blocks/ifs is still recursive descent, the expression
-// parser is a Pratt parser. The basic idea there is to have the precedences
-// (and associativities) encoded relative to each other and only parse up
-// until you hit something of that precedence. There's a dispatch table in
-// expressions_ at the top of parser.cc that describes how each token
-// dispatches if it's seen as either a prefix or infix operator, and if it's
-// infix, what its precedence is.
+// The top-level for blocks/ifs is recursive descent, the expression parser is
+// a Pratt parser. The basic idea there is to have the precedences (and
+// associativities) encoded relative to each other and only parse up until you
+// hit something of that precedence. There's a dispatch table in expressions_
+// at the top of parser.cc that describes how each token dispatches if it's
+// seen as either a prefix or infix operator, and if it's infix, what its
+// precedence is.
 //
 // Refs:
 // - http://javascript.crockford.com/tdop/tdop.html
 // - http://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/
 
 // Indexed by Token::Type.
 ParserHelper Parser::expressions_[] = {
   {NULL, NULL, -1},                                             // INVALID
   {&Parser::Literal, NULL, -1},                                 // INTEGER
   {&Parser::Literal, NULL, -1},                                 // STRING
   {&Parser::Literal, NULL, -1},                                 // TRUE_TOKEN
   {&Parser::Literal, NULL, -1},                                 // FALSE_TOKEN
   {NULL, &Parser::Assignment, PRECEDENCE_ASSIGNMENT},           // EQUAL
   {NULL, &Parser::BinaryOperator, PRECEDENCE_SUM},              // PLUS
   {NULL, &Parser::BinaryOperator, PRECEDENCE_SUM},              // MINUS
   {NULL, &Parser::Assignment, PRECEDENCE_ASSIGNMENT},           // PLUS_EQUALS
   {NULL, &Parser::Assignment, PRECEDENCE_ASSIGNMENT},           // MINUS_EQUALS
   {NULL, &Parser::BinaryOperator, PRECEDENCE_EQUALITY},         // EQUAL_EQUAL
   {NULL, &Parser::BinaryOperator, PRECEDENCE_EQUALITY},         // NOT_EQUAL
   {NULL, &Parser::BinaryOperator, PRECEDENCE_RELATION},         // LESS_EQUAL
   {NULL, &Parser::BinaryOperator, PRECEDENCE_RELATION},         // GREATER_EQUAL
   {NULL, &Parser::BinaryOperator, PRECEDENCE_RELATION},         // LESS_THAN
   {NULL, &Parser::BinaryOperator, PRECEDENCE_RELATION},         // GREATER_THAN
   {NULL, &Parser::BinaryOperator, PRECEDENCE_AND},              // BOOLEAN_AND
   {NULL, &Parser::BinaryOperator, PRECEDENCE_OR},               // BOOLEAN_OR
   {&Parser::Not, NULL, -1},                                     // BANG
+  {NULL, &Parser::DotOperator, PRECEDENCE_DOT},                 // DOT
   {&Parser::Group, NULL, -1},                                   // LEFT_PAREN
   {NULL, NULL, -1},                                             // RIGHT_PAREN
   {&Parser::List, &Parser::Subscript, PRECEDENCE_CALL},         // LEFT_BRACKET
   {NULL, NULL, -1},                                             // RIGHT_BRACKET
   {NULL, NULL, -1},                                             // LEFT_BRACE
   {NULL, NULL, -1},                                             // RIGHT_BRACE
   {NULL, NULL, -1},                                             // IF
   {NULL, NULL, -1},                                             // ELSE
   {&Parser::Name, &Parser::IdentifierOrCall, PRECEDENCE_CALL},  // IDENTIFIER
   {NULL, NULL, -1},                                             // COMMA
@@ skipping 229 matching lines @@
   assign->set_left(left.Pass());
   assign->set_right(value.Pass());
   return assign.PassAs<ParseNode>();
 }
 
 scoped_ptr<ParseNode> Parser::Subscript(scoped_ptr<ParseNode> left,
                                         Token token) {
   // TODO: Maybe support more complex expressions like a[0][0]. This would
   // require work on the evaluator too.
   if (left->AsIdentifier() == NULL) {
-    *err_ = Err(left.get(), "May only subscript simple identifiers");
+    *err_ = Err(left.get(), "May only subscript identifiers.",
+        "The thing on the left hand side of the [] must be an identifier\n"
+        "and not an expression. If you need this, you'll have to assign the\n"
+        "value to a temporary before subscripting. Sorry.");
     return scoped_ptr<ParseNode>();
   }
   scoped_ptr<ParseNode> value = ParseExpression();
   Consume(Token::RIGHT_BRACKET, "Expecting ']' after subscript.");
   scoped_ptr<AccessorNode> accessor(new AccessorNode);
   accessor->set_base(left->AsIdentifier()->value());
   accessor->set_index(value.Pass());
   return accessor.PassAs<ParseNode>();
 }
 
+scoped_ptr<ParseNode> Parser::DotOperator(scoped_ptr<ParseNode> left,
+                                          Token token) {
+  if (left->AsIdentifier() == NULL) {
+    *err_ = Err(left.get(), "May only use \".\" for identifiers.",
+        "The thing on the left hand side of the dot must be an identifier\n"
+        "and not an expression. If you need this, you'll have to assign the\n"
+        "value to a temporary first. Sorry.");
+    return scoped_ptr<ParseNode>();
+  }
+
+  scoped_ptr<ParseNode> right = ParseExpression(PRECEDENCE_DOT);
+  if (!right || !right->AsIdentifier()) {
+    *err_ = Err(token, "Expected identifier for right-hand-side of \".\"",
+        "Good: a.cookies\nBad: a.42\nLooks good but still bad: a.cookies()");
+    return scoped_ptr<ParseNode>();
+  }
+
+  scoped_ptr<AccessorNode> accessor(new AccessorNode);
+  accessor->set_base(left->AsIdentifier()->value());
+  accessor->set_member(scoped_ptr<IdentifierNode>(
+      static_cast<IdentifierNode*>(right.release())));
+  return accessor.PassAs<ParseNode>();
+}
+
 // Does not Consume the start or end token.
 scoped_ptr<ListNode> Parser::ParseList(Token::Type stop_before,
                                        bool allow_trailing_comma) {
   scoped_ptr<ListNode> list(new ListNode);
   list->set_begin_token(cur_token());
   bool just_got_comma = false;
   while (!LookAhead(stop_before)) {
     just_got_comma = false;
     // Why _OR? We're parsing things that are higher precedence than the ,
     // that separates the items of the list. , should appear lower than
@@ skipping 84 matching lines @@
   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))
     condition->set_if_false(ParseStatement().Pass());
   if (has_error())
     return scoped_ptr<ParseNode>();
   return condition.PassAs<ParseNode>();
 }