frog: use type annotation in map and list literals

frog/gen.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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 2129 matching lines @@
     // If the user calls "new Interface()" we want the result type to be the
     // interface, not the class.
     var target = new Value.type(type, typeRef.span);
     return m.invoke(this, node, target, _makeArgs(node.arguments));
   }
 
   visitListExpression(ListExpression node) {
     // TODO(jimhug): Use node.type or other type inference here.
     var argsCode = [];
     var argValues = [];
+    var type = null;
+    if (node.type !== null) {
+      // The parser makes node.type a list type, we extract its type argument.
+      type = method.resolveType(node.type, true).typeArgsInOrder[0];
+      if (node.isConst && (type is ParameterType || type.hasTypeParams)) {
+        world.error('type parameter cannot be used in const list literals');
+      }
+    }
     for (var item in node.values) {
-      var arg = visitValue(item);
+      var arg = type === null ? visitValue(item) : visitTypedValue(item, type);

[Jennifer Messerly, 2011/12/08 02:13:26]

I'd move this check into visitTypedValue. Especially since you do the same thing
later :)

Also style nit: we aren't using ===, !== anywhere else for null comparions. Any
reason to change?

[Siggi Cherem (dart-lang), 2011/12/08 23:02:15]

Done
No reason - seems that our code needs some cleanup (there are still some left
behind)... addressing in a follow up CL.

       argValues.add(arg);
       if (node.isConst) {
         if (!arg.isConst) {
           world.error('const list can only contain const values', item.span);
           argsCode.add(arg.code);
         } else {
           argsCode.add(arg.canonicalCode);
         }
       } else {
         argsCode.add(arg.code);
@@ skipping 20 matching lines @@
 
   visitMapExpression(MapExpression node) {
     // Special case the empty non-const map.
     if (node.items.length == 0 && !node.isConst) {
       return world.mapType.getConstructor('').invoke(this, node,
         new Value.type(world.mapType, node.span), Arguments.EMPTY);
     }
 
     var argValues = [];
     var argsCode = [];
+    var type = null;
+    if (node.type !== null) {
+      // node.type is a map type, extract the type argument for the values.
+      type = method.resolveType(node.type, true).typeArgsInOrder[1];
+      if (node.isConst && (type is ParameterType || type.hasTypeParams)) {
+        world.error('type parameter cannot be used in const map literals');
+      }
+    }
     for (int i = 0; i < node.items.length; i += 2) {
       // TODO(jimhug): Use node.type or other type inference here.
-      // TODO(jimhug): Would be nice to allow arbitrary keys here.
+      // TODO(jimhug): Would be nice to allow arbitrary keys here (this is
+      // currently not allowed by the spec).
       var key = visitTypedValue(node.items[i], world.stringType);
       final valueItem = node.items[i+1];
-      var value = visitValue(valueItem);
+      var value = type === null ? visitValue(valueItem)
+          : visitTypedValue(valueItem, type);
       argValues.add(key);
       argValues.add(value);
 
       if (node.isConst) {
         if (!key.isConst || !value.isConst) {
           world.error('const map can only contain const values',
               valueItem.span);
           argsCode.add(key.code);
           argsCode.add(value.code);
         } else {
@@ skipping 260 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }