Add support for computed property names in object literals

src/preparser.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/func-name-inferrer.h"
 #include "src/hashmap.h"
 #include "src/scopes.h"
@@ skipping 751 matching lines @@
                                       int literal_index,
                                       int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteralProperty(bool is_getter,
                                                PreParserExpression value,
                                                int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteralProperty(PreParserExpression key,
-                                               PreParserExpression value) {
+                                               PreParserExpression value,
+                                               bool is_computed_name) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteral(PreParserExpressionList properties,
                                        int literal_index,
                                        int boilerplate_properties,
                                        bool has_function,
                                        int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewVariableProxy(void* generator_variable) {
@@ skipping 706 matching lines @@
   return factory()->NewArrayLiteral(values, literal_index, pos);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseObjectLiteral(
     bool* ok) {
   // ObjectLiteral ::
   // '{' ((
   //       ((IdentifierName | String | Number) ':' AssignmentExpression) |
-  //       (('get' | 'set') (IdentifierName | String | Number) FunctionLiteral)
+  //       (('get' | 'set') (IdentifierName | String | Number) FunctionLiteral)|
+  //       ('[' AssignmentExpression ']' ':' AssignmentExpression)
   //      ) ',')* '}'
   // (Except that trailing comma is not required and not allowed.)
 
   int pos = peek_position();
   typename Traits::Type::PropertyList properties =
       this->NewPropertyList(4, zone_);
   int number_of_boilerplate_properties = 0;
   bool has_function = false;
+  bool has_computed_names = false;
 
   ObjectLiteralChecker checker(this, strict_mode());
 
   Expect(Token::LBRACE, CHECK_OK);
 
   while (peek() != Token::RBRACE) {
     if (fni_ != NULL) fni_->Enter();
 
-    typename Traits::Type::Literal key = this->EmptyLiteral();
+    bool is_computed_name = false;
+    ExpressionT key = this->EmptyLiteral();
     Token::Value next = peek();
     int next_pos = peek_position();
 
     switch (next) {
       case Token::FUTURE_RESERVED_WORD:
       case Token::FUTURE_STRICT_RESERVED_WORD:
       case Token::IDENTIFIER: {
         bool is_getter = false;
         bool is_setter = false;
         IdentifierT id =
             ParseIdentifierNameOrGetOrSet(&is_getter, &is_setter, CHECK_OK);
         if (fni_ != NULL) this->PushLiteralName(fni_, id);
 
         if ((is_getter || is_setter) && peek() != Token::COLON) {
           // Special handling of getter and setter syntax:
           // { ... , get foo() { ... }, ... , set foo(v) { ... v ... } , ... }
           // We have already read the "get" or "set" keyword.
           Token::Value next = Next();
           if (next != i::Token::IDENTIFIER &&
               next != i::Token::FUTURE_RESERVED_WORD &&
               next != i::Token::FUTURE_STRICT_RESERVED_WORD &&
               next != i::Token::NUMBER &&
               next != i::Token::STRING &&
               !Token::IsKeyword(next)) {
+            // FIXME(wingo): Add support for computed property names here, as in
+            // get [AssignmentExpression]() { .. }.
             ReportUnexpectedToken(next);
             *ok = false;
             return this->EmptyLiteral();
           }
           // Validate the property.
           PropertyKind type = is_getter ? kGetterProperty : kSetterProperty;
           checker.CheckProperty(next, type, CHECK_OK);
           IdentifierT name = this->GetSymbol(scanner_);
           typename Traits::Type::FunctionLiteral value =
               this->ParseFunctionLiteral(
                   name, scanner()->location(),
                   false,  // reserved words are allowed here
                   false,  // not a generator
                   RelocInfo::kNoPosition, FunctionLiteral::ANONYMOUS_EXPRESSION,
                   CHECK_OK);
           // Allow any number of parameters for compatibilty with JSC.
           // Specification only allows zero parameters for get and one for set.
           typename Traits::Type::ObjectLiteralProperty property =
               factory()->NewObjectLiteralProperty(is_getter, value, next_pos);
-          if (this->IsBoilerplateProperty(property)) {
+          if (!has_computed_names && this->IsBoilerplateProperty(property)) {
             number_of_boilerplate_properties++;
           }
           properties->Add(property, zone());
           if (peek() != Token::RBRACE) {
             // Need {} because of the CHECK_OK macro.
             Expect(Token::COMMA, CHECK_OK);
           }
 
           if (fni_ != NULL) {
             fni_->Infer();
@@ skipping 17 matching lines @@
         }
         key = factory()->NewLiteral(string, next_pos);
         break;
       }
       case Token::NUMBER: {
         Consume(Token::NUMBER);
         key = this->ExpressionFromLiteral(Token::NUMBER, next_pos, scanner_,
                                           factory());
         break;
       }
+      case Token::LBRACK: {
+        Consume(Token::LBRACK);
+        has_computed_names = true;
+        is_computed_name = true;

[Michael Starzinger, 2014/06/13 08:14:18]

Shouldn't the detection of this syntax live behind a flag for now?

[rossberg, 2014/06/13 15:19:24]

I agree, we should have --harmony-object-literals (which later might also
include short method forms).

[wingo, 2014/06/16 08:32:27]

Done.

+        key = this->ParseAssignmentExpression(true, CHECK_OK);
+        Expect(Token::RBRACK, CHECK_OK);
+        break;
+      }
       default:
         if (Token::IsKeyword(next)) {
           Consume(next);
           IdentifierT string = this->GetSymbol(scanner_);
           key = factory()->NewLiteral(string, next_pos);
         } else {
           Token::Value next = Next();
           ReportUnexpectedToken(next);
           *ok = false;
           return this->EmptyLiteral();
         }
     }
 
     // Validate the property
-    checker.CheckProperty(next, kValueProperty, CHECK_OK);
+    if (!is_computed_name) {
+      checker.CheckProperty(next, kValueProperty, CHECK_OK);
+    }
 
     Expect(Token::COLON, CHECK_OK);
     ExpressionT value = this->ParseAssignmentExpression(true, CHECK_OK);
 
     typename Traits::Type::ObjectLiteralProperty property =
-        factory()->NewObjectLiteralProperty(key, value);
+        factory()->NewObjectLiteralProperty(key, value, is_computed_name);
 
     // Mark top-level object literals that contain function literals and
     // pretenure the literal so it can be added as a constant function
     // property. (Parser only.)
     this->CheckFunctionLiteralInsideTopLevelObjectLiteral(scope_, value,
                                                           &has_function);
 
     // Count CONSTANT or COMPUTED properties to maintain the enumeration order.
-    if (this->IsBoilerplateProperty(property)) {
+    if (!has_computed_names && this->IsBoilerplateProperty(property)) {
       number_of_boilerplate_properties++;
     }
     properties->Add(property, zone());
 
     // TODO(1240767): Consider allowing trailing comma.
     if (peek() != Token::RBRACE) {
       // Need {} because of the CHECK_OK macro.
       Expect(Token::COMMA, CHECK_OK);
     }
 
@@ skipping 523 matching lines @@
       parser()->ReportMessage("accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H