Implement type checking of list literals (issue 220).

runtime/lib/literal_factory.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.
-// Immutable map class for compiler generated map literals.
 
-class _LiteralMapFactory {
-  // [elements] contains n key-value pairs. The keys are at position
-  // 2*n, the values at position 2*n+1.
+// Factory class constructing mutable List and Map objects from parser generated
+// list and map literals.
+
+class _LiteralFactory {
+  // [elements] contains elements that are not yet type checked.
+  factory List<E>.fromLiteral(int location,
+                              String element_type,
+                              List elements) {
+    var len = elements.length;
+    var list = new GrowableObjectArray<E>.withCapacity(len);
+    for (int i = 0; i < len; i++) {
+      // In checked mode only, rethrow an eventual type error with a more user

[hausner, 2011/11/23 17:34:34]

eventual -> potential

[regis, 2011/11/23 19:29:44]

Done.

+      // friendly error message.
+      try {

[hausner, 2011/11/23 17:34:34]

Instead of doing the type check here, could the parser add a type check AstNode
to the element expression node, so that the type is checked right after the
element is evaluated?

[regis, 2011/11/23 19:29:44]

What would the advantage be? I would not be able to intercept the type error,
since it would happen in the caller of this factory.
I'll submit as is and revisit, since the script of the error may not be the
correct one and your suggestion may fix it.

+        list.backingArray[i] = elements[i];
+      } catch (TypeError error) {
+        TypeError._throwNew(location,
+                            elements[i],
+                            element_type,
+                            "list literal element at index ${i}");
+      }
+    }
+    list.length = len;
+    return list;
+  }
+
+  // [elements] contains n key-value pairs.
+  // The keys are at position 2*n and are already type checked by the parser
+  // in checked mode.
+  // The values are at position 2*n+1 and are not yet type checked.
   factory Map<K, V>.fromLiteral(int location,
                                 String value_type,
                                 List elements) {
     var map = new LinkedHashMap<String, V>();
     var len = elements.length;
     for (int i = 1; i < len; i += 2) {
       // The type of the key has been checked in the parser already.
-      if (elements[i] is !V) {
+      // In checked mode only, rethrow the type error with a more user friendly
+      // error message.
+      try {
+        map[elements[i-1]] = elements[i];
+      } catch (TypeError error) {
         TypeError._throwNew(location,
                             elements[i],
                             value_type,
                             "map literal value at index ${i ~/ 2}");
       }
-      map[elements[i-1]] = elements[i];
     }
     return map;
   }
 }