Support type annotations for list literals.

lib/compiler/implementation/scanner/listener.dart

Index: lib/compiler/implementation/scanner/listener.dart
diff --git a/lib/compiler/implementation/scanner/listener.dart b/lib/compiler/implementation/scanner/listener.dart
index 2c6bd2377d52c277fe55a599310486bb91568a22..69edb8da0e3504e9ffbfc0cd0bbfafd31eb2341f 100644
--- a/lib/compiler/implementation/scanner/listener.dart
+++ b/lib/compiler/implementation/scanner/listener.dart
@@ -1268,8 +1268,15 @@ class NodeListener extends ElementListener {
                          Token endToken) {
     NodeList elements = makeNodeList(count, beginToken, endToken, ',');
     NodeList typeArguments = popNode();
-    // TODO(ahe): Type arguments are discarded.
-    pushNode(new LiteralList(null, elements, constKeyword));
+    TypeAnnotation type = null;
+    if (typeArguments !== null) {
+      if (typeArguments.length() != 1) {

[ahe, 2012/08/23 13:06:35]

The method [length] is O(n). The method [length] should be renamed to
slowLength. So as a general rule, you shouldn't use length. In this case it
doesn't matter as the correct answer will be fast. However, I prefer avoid using
methods like this altogether as people may use them in other situations.

+        error('Type annotations for list literal should have a single type',

[ahe, 2012/08/23 13:06:35]

If this error should be reported here, it should be using [recoverableError].
However, the error should not be reported here as this can just as well be
checked in the resolver where we normally validate types.

The method [error] throws an exception and is not supposed to be used directly.

+              constKeyword.next);

[ahe, 2012/08/23 13:06:35]

This error position is wrong. First, there may be no constKeyword. Second, the
problem is either:

1. Too few type arguments (as in <>[]). However, that cannot currently happen.
But it might if we improve recovery in other parts of the parser. In this case,
the position is typeArguments.beginToken.

2. Too many type arguments (as in <int, int>[]). In this case, the position is
typeArguments.nodes.tail.head.

+      }
+      type = typeArguments.iterator().next();

[ahe, 2012/08/23 13:06:35]

Calling iterator always creates a new object. This is why we generally use the
fact that Links are linked lists. So this would be: typeArguments.nodes.head.

+    }

[ahe, 2012/08/23 13:06:35]

Unfortunately, you discarded the NodeList and now you need a special case for
printing the type arguments, and a special case for finding the the source
position corresponding to the type arguments.

+    pushNode(new LiteralList(type, elements, constKeyword));
   }
 
   void handleIndexedExpression(Token openSquareBracket,