- Remove support for the old "get foo()" - style syntax.

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 2729 matching lines @@
   } else if (func.IsFactory()) {
     // The first parameter of a factory is the AbstractTypeArguments vector of
     // the type of the instance to be allocated.
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::TypeArgumentsParameter(),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction());
   const bool allow_explicit_default_values = true;
-  if (!func.IsGetterFunction()) {
+  if (func.IsGetterFunction()) {
+    // Populate function scope with the formal parameters. Since in this case
+    // we are compiling a getter this will at most populate the receiver.
+    AddFormalParamsToScope(&params, current_block_->scope);
+  } else {
     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.NumParameters() == params.parameters->length());
+
+    // Check whether the function has any field initializer formal parameters,
+    // which are not allowed in non-constructor functions.
+    if (params.has_field_initializer) {
+      for (int i = 0; i < params.parameters->length(); i++) {
+        ParamDesc& param = (*params.parameters)[i];
+        if (param.is_field_initializer) {
+          ErrorMsg(param.name_pos,
+                   "field initializer only allowed in constructors");
+        }
+      }
+    }
+    // Populate function scope with the formal parameters.
+    AddFormalParamsToScope(&params, current_block_->scope);
+
+    if (FLAG_enable_type_checks &&
+        (current_block_->scope->function_level() > 0)) {
+      // We are parsing, but not compiling, a local function.
+      // The instantiator may be required at run time for generic type checks.
+      if (IsInstantiatorRequired()) {
+        // Make sure that the receiver of the enclosing instance function
+        // (or implicit first parameter of an enclosing factory) is marked as
+        // captured if type checks are enabled, because they may access it to
+        // instantiate types.
+        CaptureInstantiator();
+      }
     }
   }
 
-  // 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.NumParameters() == params.parameters->length());
-
-  // Check whether the function has any field initializer formal parameters,
-  // which are not allowed in non-constructor functions.
-  if (params.has_field_initializer) {
-    for (int i = 0; i < params.parameters->length(); i++) {
-      ParamDesc& param = (*params.parameters)[i];
-      if (param.is_field_initializer) {
-        ErrorMsg(param.name_pos,
-                 "field initializer only allowed in constructors");
-      }
-    }
-  }
-  // Populate function scope with the formal parameters.
-  AddFormalParamsToScope(&params, current_block_->scope);
-
-  if (FLAG_enable_type_checks &&
-      (current_block_->scope->function_level() > 0)) {
-    // We are parsing, but not compiling, a local function.
-    // The instantiator may be required at run time for generic type checks.
-    if (IsInstantiatorRequired()) {
-      // Make sure that the receiver of the enclosing instance function
-      // (or implicit first parameter of an enclosing factory) is marked as
-      // captured if type checks are enabled, because they may access it to
-      // instantiate types.
-      CaptureInstantiator();
-    }
-  }
-
   OpenBlock();  // Open a nested scope for the outermost function block.
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     end_token_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     const intptr_t expr_pos = TokenPos();
@@ skipping 7668 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart