Support new getter syntax (no formal parameter list)

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 2086 matching lines @@
   // the type of the instance to be allocated.
   if (!func.is_static() && !func.IsClosureFunction()) {
     ASSERT(current_class().raw() == func.owner());
     params.AddReceiver(ReceiverType(TokenPos()));
   } else if (func.IsFactory()) {
     params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::TypeArgumentsParameter()),
         &Type::ZoneHandle(Type::DynamicType()));
   }
-  ASSERT(CurrentToken() == Token::kLPAREN);
+  ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction());
   const bool allow_explicit_default_values = true;
-  ParseFormalParameterList(allow_explicit_default_values, &params);
+  if (!func.IsGetterFunction()) {
+    ParseFormalParameterList(allow_explicit_default_values, &params);
+  } else {
+    // TODO(hausner): Remove this once we no longer support the old
+    // getter syntax with explicit empty parameter list.
+    if (CurrentToken() == Token::kLPAREN) {
+      ConsumeToken();
+      ExpectToken(Token::kRPAREN);
+    }
+  }
 
   // The number of parameters and their type are not yet set in local functions,
   // since they are not 'top-level' parsed.
   if (func.IsLocalFunction()) {
     AddFormalParamsToFunction(&params, func);
   }
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumberOfParameters() == params.parameters->length());
 
@@ skipping 134 matching lines @@
               ExpectIdentifier("identifier expected after '.'");
         }
       }
     }
   }
 }
 
 
 void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
   TRACE_PARSER("ParseMethodOrConstructor");
-  ASSERT(CurrentToken() == Token::kLPAREN);
+  ASSERT(CurrentToken() == Token::kLPAREN || method->IsGetter());
   intptr_t method_pos = this->TokenPos();
   ASSERT(method->type != NULL);
   ASSERT(method->name_pos > 0);
   ASSERT(current_member_ == method);
 
   if (method->has_var) {
     ErrorMsg(method->name_pos, "keyword var not allowed for methods");
   }
   if (method->has_final) {
     ErrorMsg(method->name_pos, "'final' not allowed for methods");
@@ skipping 41 matching lines @@
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::PhaseParameter()),
         &Type::ZoneHandle(Type::IntInterface()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
-  ParseFormalParameterList(allow_explicit_default_values, &method->params);
+  if (!method->IsGetter()) {
+    ParseFormalParameterList(allow_explicit_default_values, &method->params);
+  } else {
+    // TODO(hausner): Remove this once the old getter syntax with
+    // empty parameter list is no longer supported.
+    if (CurrentToken() == Token::kLPAREN) {
+      ConsumeToken();
+      ExpectToken(Token::kRPAREN);
+    }
+  }
 
   // Now that we know the parameter list, we can distinguish between the
   // unary and binary operator -.
   if (method->has_operator &&
       ((method->name->Equals(Token::Str(Token::kNEGATE))) ||
       method->name->Equals("-")) &&
       (method->params.num_fixed_parameters == 1)) {
     // Patch up name for unary operator - so it does not clash with the
     // name for binary operator -.
     *method->name = Symbols::New("unary-");
@@ skipping 470 matching lines @@
     }
   } else if ((CurrentToken() == Token::kGET) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     member.kind = RawFunction::kGetterFunction;
     member.name_pos = this->TokenPos();
     member.name = ExpectIdentifier("identifier expected");
-    if (CurrentToken() != Token::kLPAREN) {
-      ErrorMsg("'(' expected");
-    }
     // If the result type was not specified, it will be set to DynamicType.
   } else if ((CurrentToken() == Token::kSET) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON))  {
     ConsumeToken();
     member.kind = RawFunction::kSetterFunction;
     member.name_pos = this->TokenPos();
     member.name = ExpectIdentifier("identifier expected");
@@ skipping 26 matching lines @@
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = TokenPos();
     ConsumeToken();
   } else {
     ErrorMsg("identifier expected");
   }
 
   ASSERT(member.name != NULL);
-  if (CurrentToken() == Token::kLPAREN) {
+  if (CurrentToken() == Token::kLPAREN || member.IsGetter()) {
     if (members->is_interface() && member.has_static) {
       if (member.has_factory) {
         ErrorMsg("factory constructors are not allowed in interfaces");
       } else {
         ErrorMsg("static methods are not allowed in interfaces");
       }
     }
     // Constructor or method.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(Type::DynamicType());
@@ skipping 6160 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart