Eliminate support for old getter 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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 11 matching lines @@
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
 DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
 DEFINE_FLAG(bool, warn_legacy_map_literal, false,
             "Warning on legacy map literal syntax (single type argument)");
-DEFINE_FLAG(bool, warn_legacy_getters, false,
-            "Warning on legacy getter syntax");
 DEFINE_FLAG(bool, strict_function_literals, false,
             "enforce new function literal rules");
 DEFINE_FLAG(bool, fail_legacy_abstract, false,
             "error on explicit use of abstract on class members");
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
@@ skipping 2435 matching lines @@
     method->params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::PhaseParameter()),
         &Type::ZoneHandle(Type::SmiType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   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) {
-      if (FLAG_warn_legacy_getters) {
-        Warning("legacy getter syntax, remove parenthesis");
-      }
-      ConsumeToken();
-      ExpectToken(Token::kRPAREN);
-    }
   }
 
   // Now that we know the parameter list, we can distinguish between the
   // unary and binary operator -.
   if (method->has_operator) {
     if ((method->operator_token == Token::kSUB) &&
        (method->params.num_fixed_parameters == 1)) {
       // Patch up name for unary operator - so it does not clash with the
       // name for binary operator -.
       method->operator_token = Token::kNEGATE;
@@ skipping 1494 matching lines @@
       ConsumeToken();
     } else {
       UnexpectedToken();
     }
   }
   const intptr_t name_pos = TokenPos();
   const String* field_name = ExpectIdentifier("accessor name expected");
 
   const intptr_t accessor_pos = TokenPos();
   ParamList params;
-  if (FLAG_warn_legacy_getters &&
-      is_getter && (CurrentToken() == Token::kLPAREN)) {
-    Warning("legacy getter syntax, remove parenthesis");
-  }
-  // TODO(hausner): Remove the kLPAREN check once we remove old getter syntax.
-  if (!is_getter || (CurrentToken() == Token::kLPAREN)) {
+
+  if (!is_getter) {
     const bool allow_explicit_default_values = true;
     ParseFormalParameterList(allow_explicit_default_values, &params);
   }
   String& accessor_name = String::ZoneHandle();
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
     accessor_name = Field::GetterSymbol(*field_name);
   } else {
     expected_num_parameters = 1;
@@ skipping 5882 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart