Optimize const construction

lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 811 matching lines @@
 
     // Create static fields for each enum value
     for (var i = 0; i < fields.length; ++i) {
       result.add(js.statement('#.# = dart.const(new #(#));',
           [id, fields[i].name, id, js.number(i)]));
     }
 
     // Create static values list
     var values = new JS.ArrayInitializer(new List<JS.Expression>.from(
         fields.map((f) => js.call('#.#', [id, f.name]))));
-    result.add(js.statement('#.values = dart.const(dart.list(#, #));',
+    result.add(js.statement('#.values = dart.constList(#, #);',
         [id, values, _emitType(type)]));
 
     return _statement(result);
   }
 
   /// Wraps a possibly generic class in its type arguments.
   JS.Statement _defineClassTypeArguments(TypeDefiningElement element,
       List<TypeParameterElement> formals, JS.Statement body) {
     assert(formals.isNotEmpty);
     var genericCall = js.call('dart.generic((#) => { #; return #; })',
@@ skipping 2583 matching lines @@
 
     variable ??= new JS.TemporaryId(name);
 
     id.staticElement = new TemporaryVariableElement.forNode(id, variable);
     id.staticType = type;
     DynamicInvoke.set(id, type.isDynamic);
     addTemporaryVariable(id.staticElement, nullable: nullable);
     return id;
   }
 
-  JS.Expression _emitConst(JS.Expression expr()) {
+  JS.Expression _cacheConst(JS.Expression expr()) {
     var savedTypeParams = _typeParamInConst;
     _typeParamInConst = [];
 
-    var jsExpr = js.call('dart.const(#)', expr());
+    var jsExpr = expr();
 
     bool usesTypeParams = _typeParamInConst.isNotEmpty;
     _typeParamInConst = savedTypeParams;
 
     // TODO(jmesserly): if it uses type params we can still hoist it up as far
     // as it will go, e.g. at the level the generic class is defined where type
     // params are available.
     if (_currentFunction == null || usesTypeParams) return jsExpr;
 
     var temp = new JS.TemporaryId('const');
     _moduleItems.add(js.statement('let #;', [temp]));
     return js.call('# || (# = #)', [temp, temp, jsExpr]);
   }
+  
+  JS.Expression _emitConst(JS.Expression expr()) => 
+      _cacheConst(() => js.call('dart.const(#)', expr()));
 
   /// Returns a new expression, which can be be used safely *once* on the
   /// left hand side, and *once* on the right side of an assignment.
   /// For example: `expr1[expr2] += y` can be compiled as
   /// `expr1[expr2] = expr1[expr2] + y`.
   ///
   /// The temporary scope will ensure `expr1` and `expr2` are only evaluated
   /// once: `((x1, x2) => x1[x2] = x1[x2] + y)(expr1, expr2)`.
   ///
   /// If the expression does not end up using `x1` or `x2` more than once, or
@@ skipping 685 matching lines @@
       // TODO(vsm): When we canonicalize, we need to treat private symbols
       // correctly.
       var name = js.string(node.components.join('.'), "'");
       return js.call('#.new(#)', [_emitType(types.symbolType), name]);
     }
     return _emitConst(emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
+    var isConst = node.constKeyword != null;
     JS.Expression emitList() {
       JS.Expression list = new JS.ArrayInitializer(
           _visitList(node.elements) as List<JS.Expression>);
       ParameterizedType type = node.staticType;
       var elementType = type.typeArguments.single;
       // TODO(jmesserly): analyzer will usually infer `List<Object>` because
       // that is the least upper bound of the element types. So we rarely
       // generate a plain `List<dynamic>` anymore.
-      if (!elementType.isDynamic) {
+      if (!elementType.isDynamic || isConst) {
         // dart.list helper internally depends on _interceptors.JSArray.
         _declareBeforeUse(_jsArray);
-        list = js.call('dart.list(#, #)', [list, _emitType(elementType)]);
+        var typeRep = _emitType(elementType);
+        var helper = (isConst) ? 'constList' : 'list';
+        list = js.call('dart.${helper}(#, #)', [list, typeRep]);
       }
       return list;
     }
-    if (node.constKeyword != null) return _emitConst(emitList);
+    if (isConst) return _cacheConst(emitList);
     return emitList();
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     // TODO(jmesserly): we can likely make these faster.
     JS.Expression emitMap() {
       var entries = node.entries;
       var mapArguments = null;
       var typeArgs = node.typeArguments;
@@ skipping 372 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';