Fixes 2 tests and a crash

frog/parser.dart

 // Copyright (c) 2011, 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.
 
 // TODO(jimhug): Error recovery needs major work!
 /**
  * A simple recursive descent parser for the dart language.
  *
  * This parser is designed to be more permissive than the official
  * Dart grammar.  It is expected that many grammar errors would be
@@ skipping 1048 matching lines @@
 
       case TokenKind.SUPER:
         _eat(TokenKind.SUPER);
         return new SuperExpression(_makeSpan(start));
 
       case TokenKind.CONST:
         _eat(TokenKind.CONST);
         if (_peekKind(TokenKind.LBRACK) || _peekKind(TokenKind.INDEX)) {
           return finishListLiteral(start, true, null);
         } else if (_peekKind(TokenKind.LBRACE)) {
-          return finishMapLiteral(start, true, null);
+          return finishMapLiteral(start, true, null, null);
         } else if (_peekKind(TokenKind.LT)) {
           return finishTypedLiteral(start, true);
         } else {
           return finishNewExpression(start, true);
         }
 
       case TokenKind.NEW:
         _eat(TokenKind.NEW);
         return finishNewExpression(start, false);
 
       case TokenKind.LPAREN:
         return _parenOrLambda();
 
       case TokenKind.LBRACK:
       case TokenKind.INDEX:
         return finishListLiteral(start, false, null);
       case TokenKind.LBRACE:
-        return finishMapLiteral(start, false, null);
+        return finishMapLiteral(start, false, null, null);
 
       // Literals
       case TokenKind.NULL:
         _eat(TokenKind.NULL);
         return _makeLiteral(Value.fromNull(_makeSpan(start)));
 
       // TODO(jimhug): Make Literal creation less wasteful - no dup span/text.
       case TokenKind.TRUE:
         _eat(TokenKind.TRUE);
         return _makeLiteral(Value.fromBool(true, _makeSpan(start)));
@@ skipping 239 matching lines @@
   finishNewExpression(int start, bool isConst) {
     var type = type();
     var name = null;
     if (_maybeEat(TokenKind.DOT)) {
       name = identifier();
     }
     var args = arguments();
     return new NewExpression(isConst, type, name, args, _makeSpan(start));
   }
 
-  finishListLiteral(int start, bool isConst, TypeReference type) {
+  finishListLiteral(int start, bool isConst, TypeReference itemType) {
     if (_maybeEat(TokenKind.INDEX)) {
       // This is an empty array.
-      return new ListExpression(isConst, type, [], _makeSpan(start));
+      return new ListExpression(isConst, itemType, [], _makeSpan(start));
     }
 
     var values = [];
     _eat(TokenKind.LBRACK);
     while (!_maybeEat(TokenKind.RBRACK)) {
       values.add(expression());
       if (_recover && !_recoverTo(TokenKind.RBRACK, TokenKind.COMMA)) break;
       if (!_maybeEat(TokenKind.COMMA)) {
         _eat(TokenKind.RBRACK);
         break;
       }
     }
-    return new ListExpression(isConst, type, values, _makeSpan(start));
+    return new ListExpression(isConst, itemType, values, _makeSpan(start));
   }
 
-  finishMapLiteral(int start, bool isConst, TypeReference type) {
+  finishMapLiteral(int start, bool isConst,
+      TypeReference keyType, TypeReference valueType) {
     var items = [];
     _eat(TokenKind.LBRACE);
     while (!_maybeEat(TokenKind.RBRACE)) {
       // This is deliberately overly permissive - checked in later pass.
       items.add(expression());
       _eat(TokenKind.COLON);
       items.add(expression());
       if (_recover && !_recoverTo(TokenKind.RBRACE, TokenKind.COMMA)) break;
       if (!_maybeEat(TokenKind.COMMA)) {
         _eat(TokenKind.RBRACE);
         break;
       }
     }
-    return new MapExpression(isConst, type, items, _makeSpan(start));
+    return new MapExpression(isConst, keyType, valueType, items,
+      _makeSpan(start));
   }
 
   finishTypedLiteral(int start, bool isConst) {
     var span = _makeSpan(start);
-    var typeToBeNamedLater = new NameTypeReference(false, null, null, span);
-    var genericType = addTypeArguments(typeToBeNamedLater, 0);
+
+    final typeToBeNamedLater = new NameTypeReference(false, null, null, span);
+    final genericType = addTypeArguments(typeToBeNamedLater, 0);
+    final typeArgs = genericType.typeArguments;
 
     if (_peekKind(TokenKind.LBRACK) || _peekKind(TokenKind.INDEX)) {
-      genericType.baseType = new TypeReference(span, world.listType);
-      return finishListLiteral(start, isConst, genericType);
+      if (typeArgs.length != 1) {
+        world.error('exactly one type argument expected for list',
+          genericType.span);
+      }
+      return finishListLiteral(start, isConst, typeArgs[0]);
     } else if (_peekKind(TokenKind.LBRACE)) {
-      genericType.baseType = new TypeReference(span, world.mapType);
-      final typeArgs = genericType.typeArguments;
-      // TODO(sigmund): Would be nice to allow arbitrary keys here (this is
-      // currently not allowed by the spec).
+      var keyType, valueType;
       if (typeArgs.length == 1) {
-        genericType.typeArguments =
-            [new TypeReference(span, world.stringType), typeArgs[0]];
+        keyType = null;
+        valueType = typeArgs[0];
       } else if (typeArgs.length == 2) {
         var keyType = typeArgs[0];
-        if (keyType is! NameTypeReference || keyType.name.name != "String") {
-          world.error('the key type of a map literal is implicitly "String"',
-              keyType.span);
-        } else {
-          // making key explicit is just a warning.
-          world.warning(
-              'a map literal takes one type argument specifying the value type',
-              keyType.span);
-        }
+        // making key explicit is just a warning.
+        world.warning(
+            'a map literal takes one type argument specifying the value type',
+            keyType.span);
+        valueType = typeArgs[1];
       } // o.w. the type system will detect the mismatch in type arguments.
-      return finishMapLiteral(start, isConst, genericType);
+      return finishMapLiteral(start, isConst, keyType, valueType);
     } else {
       _errorExpected('array or map literal');
     }
   }
 
   ///////////////////////////////////////////////////////////////////
   // Some auxilary productions.
   ///////////////////////////////////////////////////////////////////
   _readModifiers() {
     var modifiers = null;
@@ skipping 277 matching lines @@
   int _pos = 0;
   next() {
     var token = tokens[_pos];
     ++_pos;
     if (_pos == tokens.length) {
       parser.tokenizer = previousTokenizer;
     }
     return token;
   }
 }