Require two type arguments for map literals (issue 4522).

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 8049 matching lines @@
   const intptr_t literal_pos = TokenPos();
   ConsumeToken();
 
   AbstractType& value_type = Type::ZoneHandle(Type::DynamicType());
   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 a single type argument.
-    value_type = map_type_arguments.TypeAt(0);
-    if (map_type_arguments.Length() > 1) {
-      // We temporarily accept two type arguments, as long as the first one is
-      // type String.
-      if (map_type_arguments.Length() != 2) {
-        ErrorMsg(type_pos,
-                 "a map literal takes one type argument specifying "
-                 "the value type");
-      }
-      if (!value_type.IsStringInterface()) {
-        ErrorMsg(type_pos,
-                 "the key type of a map literal is implicitly 'String'");
-      }
+    // Map literals take two type arguments.
+    if (map_type_arguments.Length() < 2) {
+      // We temporarily accept a single type argument.
       Warning(type_pos,

[hausner, 2012/08/16 20:02:39]

As Peter notes, I would guard this with a separate flag, eg.
--warn_illegal_map_args or something.

[regis, 2012/08/16 20:11:00]

Done. I have hidden the warning behind --warn_legacy_syntax, renamed from
--warn_legacy_catch_syntax.

-              "a map literal takes one type argument specifying "
-              "the value type");
-      value_type = map_type_arguments.TypeAt(1);
-    } else {
+              "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::StringInterface()));
       type_array.SetTypeAt(1, value_type);
       map_type_arguments = type_array.raw();
+    } else 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.IsStringInterface()) {
+        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 979 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart