frog: use type annotation in map and list literals

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { return this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 3739 matching lines @@
         $globals.world.error('const constructor expects const arguments', arg.get$span());
       }
     }
   }
   var target = new Value.type$ctor(type, typeRef.get$span());
   return m.invoke$4(this, node, target, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
   var argsCode = [];
   var argValues = [];
+  var type = null;
+  if (node.type != null) {
+    type = this.method.resolveType(node.type, true).get$typeArgsInOrder().$index(0);
+    if (node.isConst && ((type instanceof ParameterType) || type.get$hasTypeParams())) {
+      $globals.world.error('type parameter cannot be used in const list literals');
+    }
+  }
   var $$list = node.values;
   for (var $$i = 0;$$i < $$list.length; $$i++) {
     var item = $$list.$index($$i);
-    var arg = this.visitValue(item);
+    var arg = type == null ? this.visitValue(item) : this.visitTypedValue(item, type);
     argValues.add$1(arg);
     if (node.isConst) {
       if (!arg.get$isConst()) {
         $globals.world.error('const list can only contain const values', item.get$span());
         argsCode.add$1(arg.get$code());
       }
       else {
         argsCode.add$1(arg.get$canonicalCode());
       }
     }
@@ skipping 11 matching lines @@
     value = $globals.world.gen.globalForConst(ConstListValue.ConstListValue$factory(immutableList, argValues, ('const ' + code), result.get$code(), node.span), argValues);
   }
   return value;
 }
 MethodGenerator.prototype.visitMapExpression = function(node) {
   if (node.items.length == 0 && !node.isConst) {
     return $globals.world.mapType.getConstructor('').invoke$4(this, node, new Value.type$ctor($globals.world.mapType, node.span), Arguments.get$EMPTY());
   }
   var argValues = [];
   var argsCode = [];
+  var type = null;
+  if (node.type != null) {
+    type = this.method.resolveType(node.type, true).get$typeArgsInOrder().$index(1);
+    if (node.isConst && ((type instanceof ParameterType) || type.get$hasTypeParams())) {
+      $globals.world.error('type parameter cannot be used in const map literals');
+    }
+  }
   for (var i = 0;
    i < node.items.length; i += 2) {
     var key = this.visitTypedValue(node.items.$index(i), $globals.world.stringType);
     var valueItem = node.items.$index(i + 1);
-    var value = this.visitValue(valueItem);
+    var value = type == null ? this.visitValue(valueItem) : this.visitTypedValue(valueItem, type);
     argValues.add$1(key);
     argValues.add$1(value);
     if (node.isConst) {
       if (!key.get$isConst() || !value.get$isConst()) {
         $globals.world.error('const map can only contain const values', valueItem.get$span());
         argsCode.add$1(key.get$code());
         argsCode.add$1(value.get$code());
       }
       else {
         argsCode.add$1(key.get$canonicalCode());
@@ skipping 5547 matching lines @@
       break;
     }
   }
   return new MapExpression(isConst, type, items, this._makeSpan(start));
 }
 Parser.prototype.finishTypedLiteral = function(start, isConst) {
   var span = this._makeSpan(start);
   var typeToBeNamedLater = new NameTypeReference(false, null, null, span);
   var genericType = this.addTypeArguments(typeToBeNamedLater, 0);
   if (this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/)) {
+    genericType.set$baseType(new TypeReference(span, $globals.world.listType));
     return this.finishListLiteral(start, isConst, genericType);
   }
   else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
+    genericType.set$baseType(new TypeReference(span, $globals.world.mapType));
+    if ($ne(genericType.get$typeArguments().length, 1)) {
+      this._error('a map literal takes one type argument specfying the value type', $eq(genericType.get$typeArguments().length, 0) ? genericType.get$typeArguments().get$span() : genericType.get$typeArguments().$index(1).get$span());
+    }
+    genericType.set$typeArguments([new TypeReference(span, $globals.world.stringType), genericType.get$typeArguments().$index(0)]);
     return this.finishMapLiteral(start, isConst, genericType);
   }
   else {
     this._errorExpected('array or map literal');
   }
 }
 Parser.prototype._readModifiers = function() {
   var modifiers = null;
   while (true) {
     switch (this._peek()) {
@@ skipping 957 matching lines @@
 function GenericTypeReference(baseType, typeArguments, depth, span) {
   this.baseType = baseType;
   this.typeArguments = typeArguments;
   this.depth = depth;
   // Initializers done
   TypeReference.call(this, span);
 }
 $inherits(GenericTypeReference, TypeReference);
 GenericTypeReference.prototype.get$baseType = function() { return this.baseType; };
 GenericTypeReference.prototype.set$baseType = function(value) { return this.baseType = value; };
+GenericTypeReference.prototype.get$typeArguments = function() { return this.typeArguments; };
+GenericTypeReference.prototype.set$typeArguments = function(value) { return this.typeArguments = value; };
 GenericTypeReference.prototype.get$depth = function() { return this.depth; };
 GenericTypeReference.prototype.set$depth = function(value) { return this.depth = value; };
 GenericTypeReference.prototype.visit = function(visitor) {
   return visitor.visitGenericTypeReference(this);
 }
 GenericTypeReference.prototype.visit$1 = GenericTypeReference.prototype.visit;
 // ********** Code for FunctionTypeReference **************
 function FunctionTypeReference(isFinal, func, span) {
   this.isFinal = isFinal;
   this.func = func;
@@ skipping 642 matching lines @@
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = new HashMapImplementation();
   this.members = new HashMapImplementation();
   this.factories = new FactoryMap();
   // Initializers done
   Type.call(this, name);
 }
 $inherits(ConcreteType, Type);
 ConcreteType.prototype.get$genericType = function() { return this.genericType; };
+ConcreteType.prototype.get$typeArguments = function() { return this.typeArguments; };
+ConcreteType.prototype.set$typeArguments = function(value) { return this.typeArguments = value; };
 ConcreteType.prototype.get$_parent = function() { return this._parent; };
 ConcreteType.prototype.set$_parent = function(value) { return this._parent = value; };
 ConcreteType.prototype.get$typeArgsInOrder = function() { return this.typeArgsInOrder; };
 ConcreteType.prototype.set$typeArgsInOrder = function(value) { return this.typeArgsInOrder = value; };
 ConcreteType.prototype.get$isList = function() {
   return this.genericType.get$isList();
 }
 ConcreteType.prototype.get$isClass = function() {
   return this.genericType.isClass;
 }
@@ skipping 2092 matching lines @@
   $globals._MAGENTA_COLOR = '\u001b[35m';
   $globals._NO_COLOR = '\u001b[0m';
   $globals._RED_COLOR = '\u001b[31m';
 }
 var const$0 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var const$2 = new EmptyQueueException()/*const EmptyQueueException()*/;
 var const$3 = new _DeletedKeySentinel()/*const _DeletedKeySentinel()*/;
 var $globals = {};
 $static_init();
 main();