Add warning flag for legacy 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 15 matching lines @@
             "Named constructors may not clash with other members");
 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_dynamic, false,
             "Warning on legacy type Dynamic)");
+DEFINE_FLAG(bool, warn_legacy_getters, false,
+            "Warning on legacy getter syntax");
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
 // --enable-checked-mode and --checked both enable checked mode which is
 // equivalent to setting --enable-asserts and --enable-type-checks.
 DEFINE_FLAG_HANDLER(CheckedModeHandler,
                     enable_checked_mode,
@@ skipping 2387 matching lines @@
   }
   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)) {
@@ skipping 1538 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;
-  // TODO(hausner): Remove the ( check once we remove old getter syntax.
+  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)) {
     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 {
@@ skipping 1856 matching lines @@
   condition = InsertClosureCallNodes(condition);
   condition = new UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
   return new IfNode(condition_pos,
                     condition,
                     NodeAsSequenceNode(condition_pos, assert_throw, NULL),
                     NULL);
 }
 
 
-// TODO(hausner): This structure can be simplified once the old catch
-// syntax is removed. All catch parameters in the new syntax are final.
 struct CatchParamDesc {
   CatchParamDesc()
       : token_pos(0), type(NULL), var(NULL) { }
   intptr_t token_pos;
   const AbstractType* type;
   const String* var;
 };
 
 
 // Populate local scope of the catch block with the catch parameters.
@@ skipping 3844 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart