Stop supporting map literals with 1 type argument

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_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;
 }
 
 // --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 8581 matching lines @@
 
 AstNode* Parser::ParseMapLiteral(intptr_t type_pos,
                                  bool is_const,
                                  const AbstractTypeArguments& type_arguments) {
   TRACE_PARSER("ParseMapLiteral");
   ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACE);
   const intptr_t literal_pos = TokenPos();
   ConsumeToken();
 
   AbstractType& value_type = Type::ZoneHandle(Type::DynamicType());

[regis, 2013/01/18 23:43:59]

You can now move this line down. Same as key_type.

[hausner, 2013/01/19 00:02:12]

value_type is used below, in 8698. Leaving as is, as discussed offline.

   AbstractTypeArguments& map_type_arguments =
       AbstractTypeArguments::ZoneHandle(type_arguments.raw());
   // If no type argument vector is provided, leave it as null, which is
   // equivalent to using dynamic as the type argument for the value type.
   if (!map_type_arguments.IsNull()) {
     ASSERT(map_type_arguments.Length() > 0);
     // Map literals take two type arguments.
-    if (map_type_arguments.Length() < 2) {
-      // TODO(hausner): Remove legacy syntax support.
-      // We temporarily accept a single type argument.
-      if (FLAG_warn_legacy_map_literal) {
-        Warning(type_pos,
-                "a map literal takes two type arguments specifying "
-                "the key type and the value type");
-      }
-      TypeArguments& type_array = TypeArguments::Handle(TypeArguments::New(2));
-      type_array.SetTypeAt(0, Type::Handle(Type::StringType()));
-      type_array.SetTypeAt(1, value_type);
-      map_type_arguments = type_array.raw();
-    } else if (map_type_arguments.Length() > 2) {
+    if (map_type_arguments.Length() != 2) {
       ErrorMsg(type_pos,
                "a map literal takes two type arguments specifying "
                "the key type and the value type");
-    } else {
-      const AbstractType& key_type =
-          AbstractType::Handle(map_type_arguments.TypeAt(0));
-      value_type = map_type_arguments.TypeAt(1);
-      if (!key_type.IsStringType()) {
-        ErrorMsg(type_pos, "the key type of a map literal must be 'String'");
-      }
+    }
+    const AbstractType& key_type =
+        AbstractType::Handle(map_type_arguments.TypeAt(0));
+    value_type = map_type_arguments.TypeAt(1);
+    if (!key_type.IsStringType()) {
+      ErrorMsg(type_pos, "the key type of a map literal must be 'String'");
     }
     if (is_const && !value_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant map literal cannot include "
                "a type variable");
     }
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
@@ skipping 1001 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart