fix list initializers

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, 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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.dart'
     show StringToken, Token, TokenType;
 import 'package:path/path.dart' as path;
 
 import 'package:dev_compiler/src/codegen/ast_builder.dart' show AstBuilder;
 import 'package:dev_compiler/src/codegen/reify_coercions.dart'
     show CoercionReifier;
 
 // TODO(jmesserly): import from its own package
 import 'package:dev_compiler/src/js/js_ast.dart' as JS;
 import 'package:dev_compiler/src/js/js_ast.dart' show js;
 
 import 'package:dev_compiler/src/checker/rules.dart';
+import 'package:dev_compiler/src/dependency_graph.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/utils.dart';
 
 import 'code_generator.dart';
 import 'js_field_storage.dart';
 import 'js_names.dart' show JSTemporary, invalidJSStaticMethodName;
 import 'js_metalet.dart';
 import 'js_printer.dart' show writeJsLibrary;
 import 'side_effect_analysis.dart';
@@ skipping 395 matching lines @@
 
     if (type is InterfaceType) {
       result = _typeMightNotBeLoaded(type.superclass) ||
           type.mixins.any(_typeMightNotBeLoaded);
     } else if (type is FunctionType) {
       result = _typeMightNotBeLoaded(types.functionType);
     }
     return _lazyClassMemo[type.element] = result;
   }
 
-  /// Curated order to minimize lazy classes needed by dart:core and its
-  /// transitive SDK imports.
-  static const CORELIB_ORDER = const [
-    'dart.core',
-    'dart.collection',
-    'dart._internal'
-  ];
-
   /// Returns true if the class might not be loaded.
   ///
   /// If the class is from our library, this can happen because it's lazy.
   ///
   /// If the class is from a different library, it could happen if we're in
   /// a library cycle. In other words, if that different library depends back
   /// on this library via some transitive import path.
   ///
   /// If we could control the global import ordering, we could eliminate some
   /// of these cases, by ordering the imports of the cyclic libraries in an
   /// optimal way. For example, we could order the libraries in a cycle to
   /// minimize laziness. However, we currently assume we cannot control the
   /// order that the cycle of libraries will be loaded in.
   bool _typeMightNotBeLoaded(DartType type) {
     var library = type.element.library;
     if (library == currentLibrary) return _lazyClass(type);
 
     // The SDK is a special case: we optimize the order to prevent laziness.
     if (library.isInSdk) {
       // SDK is loaded before non-SDK libraies
       if (!currentLibrary.isInSdk) return false;
 
       // Compute the order of both SDK libraries. If unknown, assume it's after.
-      var classOrder = CORELIB_ORDER.indexOf(library.name);
-      if (classOrder == -1) classOrder = CORELIB_ORDER.length;
+      var classOrder = corelibOrder.indexOf(library.name);
+      if (classOrder == -1) classOrder = corelibOrder.length;
 
-      var currentOrder = CORELIB_ORDER.indexOf(currentLibrary.name);
-      if (currentOrder == -1) currentOrder = CORELIB_ORDER.length;
+      var currentOrder = corelibOrder.indexOf(currentLibrary.name);
+      if (currentOrder == -1) currentOrder = corelibOrder.length;
 
       // If the dart:* library we are currently compiling is loaded after the
       // class's library, then we know the class is available.
       if (classOrder != currentOrder) return currentOrder < classOrder;
 
       // If we don't know the order of the class's library or the current
       // library, do the normal cycle check. (Not all SDK libs are cycles.)
     }
 
     return _inLibraryCycle(library);
@@ skipping 1564 matching lines @@
   visitIntegerLiteral(IntegerLiteral node) => js.number(node.value);
 
   @override
   visitDoubleLiteral(DoubleLiteral node) => js.number(node.value);
 
   @override
   visitNullLiteral(NullLiteral node) => new JS.LiteralNull();
 
   @override
   visitListLiteral(ListLiteral node) {
-    // TODO(jmesserly): make this faster. We're wasting an array.
-    var list = js.call('new #.from(#)', [
-      _emitTypeName(node.staticType),
-      new JS.ArrayInitializer(_visitList(node.elements))
-    ]);
+    JS.Expression list = new JS.ArrayInitializer(_visitList(node.elements));
+
+    ParameterizedType type = node.staticType;
+    if (type.typeArguments.any((a) => a != types.dynamicType)) {
+      list = js.call('dart.setType(#, #)', [list, _emitTypeName(type)]);
+    }
     if (node.constKeyword != null) {
       list = js.commentExpression('Unimplemented const', list);
     }
     return list;
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
+    // TODO(jmesserly): we can likely make these faster.
     var entries = node.entries;
     var mapArguments = null;
-    if (entries.isEmpty) return js.call('dart.map()');
-
-    // Use JS object literal notation if possible, otherwise use an array.
-    // We could do this any time all keys are non-nullable String type.
-    // For now, support StringLiteral as the common non-nullable String case.
-    if (entries.every((e) => e.key is StringLiteral)) {
+    if (entries.isEmpty) {
+      mapArguments = [];
+    } else if (entries.every((e) => e.key is StringLiteral)) {
+      // Use JS object literal notation if possible, otherwise use an array.
+      // We could do this any time all keys are non-nullable String type.
+      // For now, support StringLiteral as the common non-nullable String case.
       var props = [];
       for (var e in entries) {
         props.add(new JS.Property(_visit(e.key), _visit(e.value)));
       }
       mapArguments = new JS.ObjectInitializer(props);
     } else {
       var values = [];
       for (var e in entries) {
         values.add(_visit(e.key));
         values.add(_visit(e.value));
       }
       mapArguments = new JS.ArrayInitializer(values);
     }
-    return js.call('dart.map(#)', [mapArguments]);
+    // TODO(jmesserly): add generic types args.
+    var map = js.call('dart.map(#)', [mapArguments]);
+    if (node.constKeyword != null) {
+      map = js.commentExpression('Unimplemented const', map);
+    }
+    return map;
   }
 
   @override
   JS.LiteralString visitSimpleStringLiteral(SimpleStringLiteral node) =>
       js.escapedString(node.value, node.isSingleQuoted ? "'" : '"');
 
   @override
   JS.Expression visitAdjacentStrings(AdjacentStrings node) =>
       _visitListToBinary(node.strings, '+');
 
@@ skipping 279 matching lines @@
   return filepath;
 }
 
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;