Add "." accessors to GN.

tools/gn/parser_unittest.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 <iostream>
 #include <sstream>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parser.h"
 #include "tools/gn/tokenizer.h"
 
 namespace {
 
 bool GetTokens(const InputFile* input, std::vector<Token>* result) {
   result->clear();
   Err err;
   *result = Tokenizer::Tokenize(input, &err);
   return !err.has_error();
 }
 
 void DoParserPrintTest(const char* input, const char* expected) {
   std::vector<Token> tokens;
   InputFile input_file(SourceFile("/test"));
   input_file.SetContents(input);
   ASSERT_TRUE(GetTokens(&input_file, &tokens));
 
   Err err;
   scoped_ptr<ParseNode> result = Parser::Parse(tokens, &err);
+  if (!result)
+    err.PrintToStdout();
   ASSERT_TRUE(result);
 
   std::ostringstream collector;
   result->Print(collector, 0);
 
   EXPECT_EQ(expected, collector.str());
 }
 
 void DoExpressionPrintTest(const char* input, const char* expected) {
   std::vector<Token> tokens;
@@ skipping 168 matching lines @@
 
 TEST(Parser, Assignment) {
   DoParserPrintTest("a=2",
                     "BLOCK\n"
                     " BINARY(=)\n"
                     "  IDENTIFIER(a)\n"
                     "  LITERAL(2)\n");
 }
 
 TEST(Parser, Accessor) {
-  DoParserPrintTest("a=b[2]",
+  // Accessor indexing.
+  DoParserPrintTest("a=b[c+2]",
                     "BLOCK\n"
                     " BINARY(=)\n"
                     "  IDENTIFIER(a)\n"
                     "  ACCESSOR\n"
                     "   b\n"  // AccessorNode is a bit weird in that it holds
                               // a Token, not a ParseNode for the base.
+                    "   BINARY(+)\n"
+                    "    IDENTIFIER(c)\n"
+                    "    LITERAL(2)\n");
+  DoParserErrorTest("a = b[1][0]", 1, 5);
+
+  // Member accessors.
+  DoParserPrintTest("a=b.c+2",
+                    "BLOCK\n"
+                    " BINARY(=)\n"
+                    "  IDENTIFIER(a)\n"
+                    "  BINARY(+)\n"
+                    "   ACCESSOR\n"
+                    "    b\n"
+                    "    IDENTIFIER(c)\n"
                     "   LITERAL(2)\n");
-  DoParserErrorTest("a = b[1][0]", 1, 5);
+  DoParserErrorTest("a = b.c.d", 1, 6);  // Can't nest accessors (currently).
+  DoParserErrorTest("a.b = 5", 1, 1);  // Can't assign to accessors (currently).
 }
 
 TEST(Parser, Condition) {
   DoParserPrintTest("if(1) { a = 2 }",
                     "BLOCK\n"
                     " CONDITION\n"
                     "  LITERAL(1)\n"
                     "  BLOCK\n"
                     "   BINARY(=)\n"
                     "    IDENTIFIER(a)\n"
@@ skipping 235 matching lines @@
   DoParserPrintTest(input, expected);
 }
 
 TEST(Parser, HangingIf) {
   DoParserErrorTest("if", 1, 1);
 }
 
 TEST(Parser, NegatingList) {
   DoParserErrorTest("executable(\"wee\") { sources =- [ \"foo.cc\" ] }", 1, 30);
 }