Disable all support for legacy try-catch in the VM.

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"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/longjump.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/symbols.h"
 
 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_catch, false, "Warning on legacy catch syntax");
 DEFINE_FLAG(bool, warn_legacy_map_literal, false,
             "Warning on legacy map literal syntax (single type argument)");
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
 DEFINE_FLAG_HANDLER(CheckedModeHandler,
                     enable_checked_mode,
@@ skipping 5711 matching lines @@
         // New catch syntax for untyped exception variable:
         // catch(e) or catch (e,s).
         exception_param.is_final = true;
         exception_param.type =
             &AbstractType::ZoneHandle(Type::DynamicType());
         exception_param.token_pos = TokenPos();
         exception_param.var = ExpectIdentifier("identifier expected");
         if (CurrentToken() == Token::kCOMMA) {
           ConsumeToken();
           stack_trace_param.is_final = true;
-          // TODO(hausner): Make imlicit type be StackTrace, not Dynamic.
+          // TODO(hausner): Make implicit type be StackTrace, not Dynamic.
           stack_trace_param.type =
               &AbstractType::ZoneHandle(Type::DynamicType());
           stack_trace_param.token_pos = TokenPos();
           stack_trace_param.var = ExpectIdentifier("identifier expected");
         }
       } else {
-        // TODO(hausner): Remove legacy syntax support.
-        if (FLAG_warn_legacy_catch) {
-          Warning("legacy catch syntax");
-        }
-        ParseCatchParameter(&exception_param);
-        if (CurrentToken() == Token::kCOMMA) {
-          ConsumeToken();
-          ParseCatchParameter(&stack_trace_param);
-        }
+        // TODO(hausner): Improve error message and maybe also the
+        // structure of the code. Maybe you can get away with simply
+        // expecting an identifier followed by a comma or a right
+        // parenthesis?
+        ErrorMsg("identifier expected here, not type, final, or var");
       }
     } else {
       // on T catch(e) { ...
       ConsumeToken();  // on
       exception_param.is_final = true;
       exception_param.type = &AbstractType::ZoneHandle(
           ParseType(ClassFinalizer::kCanonicalizeWellFormed));
       ExpectToken(Token::kCATCH);
       ExpectToken(Token::kLPAREN);
       exception_param.token_pos = TokenPos();
@@ skipping 3594 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart