canonicalize const

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;
@@ skipping 55 matching lines @@
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   ConstantEvaluator _constEvaluator;
 
   final _exports = new Set<String>();
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashMap<String, JSTemporary>();
   final _extensionMethodNames = new HashSet<String>();
-  final _pendingSymbols = <JS.Identifier>[];
+  final _pendingStatements = <JS.Statement>[];
   final _temps = new HashMap<Element, JSTemporary>();
 
   /// The name for the library's exports inside itself.
   /// This much be a constant because we interpolate it into template strings,
   /// and otherwise it would break caching for them.
   /// `exports` was chosen as the most similar to ES module patterns.
   final JSTemporary _exportsVar = new JSTemporary('exports');
   final JSTemporary _namedArgTemp = new JSTemporary('opts');
 
   /// Classes we have not emitted yet. Values can be [ClassDeclaration] or
@@ skipping 62 matching lines @@
       js.statement("(function(#) { 'use strict'; #; })(# || (# = #));", [
         _exportsVar,
         body,
         name,
         name,
         defaultValue
       ])
     ]);
   }
 
-  JS.Statement _initSymbol(JS.Identifier id) =>
-      js.statement('let # = $_SYMBOL(#);', [id, js.string(id.name, "'")]);
+  JS.Identifier _initSymbol(JS.Identifier id) {
+    var s = js.statement('let # = $_SYMBOL(#);', [id, js.string(id.name, "'")]);
+    _pendingStatements.add(s);
+    return id;
+  }
 
   // TODO(jmesserly): this is a temporary workaround for `Symbol` in core,
   // until we have better name tracking.
   String get _SYMBOL {
     var name = currentLibrary.name;
     if (name == 'dart.core' || name == 'dart._internal') return 'dart.JsSymbol';
     return 'Symbol';
   }
 
   @override
   JS.Statement visitCompilationUnit(CompilationUnit node) {
     var source = node.element.source;
 
     _constEvaluator = new ConstantEvaluator(source, types);
 
     // TODO(jmesserly): scriptTag, directives.
     var body = <JS.Statement>[];
     for (var child in node.declarations) {
       // Attempt to group adjacent fields/properties.
       if (child is! TopLevelVariableDeclaration) _flushLazyFields(body);
       if (child is! FunctionDeclaration) _flushLibraryProperties(body);
 
       var code = _visit(child);
       if (code != null) {
-        if (_pendingSymbols.isNotEmpty) {
-          body.addAll(_pendingSymbols.map(_initSymbol));
-          _pendingSymbols.clear();
+        if (_pendingStatements.isNotEmpty) {
+          body.addAll(_pendingStatements);
+          _pendingStatements.clear();
         }
         body.add(code);
       }
     }
 
     // Flush any unwritten fields/properties.
     _flushLazyFields(body);
     _flushLibraryProperties(body);
 
-    assert(_pendingSymbols.isEmpty);
+    assert(_pendingStatements.isEmpty);
     return _statement(body);
   }
 
   bool isPublic(String name) => !name.startsWith('_');
 
   /// Conversions that we don't handle end up here.
   @override
   visitConversion(Conversion node) {
     throw 'Unlowered conversion ${node.runtimeType}: $node';
   }
@@ skipping 1263 matching lines @@
   visitConstructorName(ConstructorName node) {
     var typeName = _visit(node.type);
     if (node.name != null) {
       return js.call('#.#', [typeName, _emitMemberName(node.name.name)]);
     }
     return typeName;
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
-    return js.call(
+    var newExpr = js.call(
         'new #(#)', [_visit(node.constructorName), _visit(node.argumentList)]);
+    if (node.isConst) return _const(node, newExpr);
+    return newExpr;
   }
 
   /// True if this type is built-in to JS, and we use the values unwrapped.
   /// For these types we generate a calling convention via static
   /// "extension methods". This allows types to be extended without adding
   /// extensions directly on the prototype.
   bool _isJSBuiltinType(DartType t) =>
       typeIsPrimitiveInJS(t) || rules.isStringType(t);
 
   bool typeIsPrimitiveInJS(DartType t) => rules.isIntType(t) ||
@@ skipping 140 matching lines @@
     //   LocalVariableElementImpl, so we could repurpose to mean "temp".
     // * add a new property to LocalVariableElementImpl.
     // * create a new subtype of LocalVariableElementImpl to mark a temp.
     var id =
         new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1));
     id.staticElement = new LocalVariableElementImpl.forNode(id);
     id.staticType = type;
     return id;
   }
 
+  JS.Expression _const(Expression node, JS.Expression expr, [String nameHint]) {
+    var value = js.call('dart.const(#)', expr);
+
+    // If we're inside a method or function, capture the value into a
+    // global temporary, so we don't do the expensive canonicalization step.
+    var ancestor = node.getAncestor((n) => n is FunctionBody ||
+        (n is FieldDeclaration && n.staticKeyword == null));
+    if (ancestor == null) return value;
+
+    if (nameHint == null) {
+      nameHint = 'const_' + getStaticType(node).name;
+    }
+
+    // TODO(jmesserly): enable this once we fix
+    // https://github.com/dart-lang/dev_compiler/issues/131
+    /*var temp = new JSTemporary(nameHint);
+    _pendingStatements.add(js.statement('let # = #;', [temp, value]));
+    return temp;*/
+    assert(nameHint != null); // so it's not marked unused
+    return value;
+  }
+
   bool _isTemporary(Element node) => node.nameOffset == -1;
 
   /// 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)`.
   ///
@@ skipping 439 matching lines @@
   @override
   visitDoubleLiteral(DoubleLiteral node) => js.number(node.value);
 
   @override
   visitNullLiteral(NullLiteral node) => new JS.LiteralNull();
 
   @override
   visitSymbolLiteral(SymbolLiteral node) {
     // TODO(vsm): When we canonicalize, we need to treat private symbols
     // correctly.
-    // TODO(vsm): Make this core.Symbol instead.
-    var name = js.escapedString(node.components.join('.'));
-    var symbol = js.call('new _internal.Symbol(#)', name);
-    return js.commentExpression('Unimplemented const', symbol);
+    var name = js.string(node.components.join('.'), "'");
+    var nameHint = 'symbol_' + node.components.join('_');
+    return _const(node, js.call('new core.Symbol(#)', name), nameHint);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
     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);
-    }
+    if (node.constKeyword != null) return _const(node, 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) {
       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);
     }
     // TODO(jmesserly): add generic types args.
     var map = js.call('dart.map(#)', [mapArguments]);
-    if (node.constKeyword != null) {
-      map = js.commentExpression('Unimplemented const', map);
-    }
+    if (node.constKeyword != null) return _const(node, 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 118 matching lines @@
   ///
   /// Unary minus looks like: `x['unary-']()`. Note that [unary] must be passed
   /// for this transformation to happen, otherwise binary minus is assumed.
   ///
   /// Equality is a bit special, it is generated via the Dart `equals` runtime
   /// helper, that checks for null. The user defined method is called '=='.
   ///
   JS.Expression _emitMemberName(String name,
       {DartType type, bool unary: false, bool isStatic: false}) {
     if (name.startsWith('_')) {
-      return _privateNames.putIfAbsent(name, () {
-        var t = new JSTemporary(name);
-        _pendingSymbols.add(t);
-        return t;
-      });
+      return _privateNames.putIfAbsent(
+          name, () => _initSymbol(new JSTemporary(name)));
     }
 
     // Check for extension method:
     var extLibrary = _findExtensionLibrary(name, type);
 
     if (name == '[]') {
       name = 'get';
     } else if (name == '[]=') {
       name = 'set';
     } else if (name == '-' && unary) {
@@ skipping 34 matching lines @@
     return extLibrary;
   }
 
   JS.Expression _extensionMethodName(String name, LibraryElement library) {
     var extName = '\$$name';
     if (library == currentLibrary) {
       // TODO(jacobr): need to do a better job ensuring that extension method
       // name symbols do not conflict with other symbols before we can let
       // user defined libraries define extension methods.
       if (_extensionMethodNames.add(extName)) {
-        _pendingSymbols.add(new JS.Identifier(extName));
+        _initSymbol(new JS.Identifier(extName));
         _addExport(extName);
       }
       return new JS.Identifier(extName);
     }
     return js.call('#.#', [_libraryName(library), _propertyName(extName)]);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
@@ skipping 82 matching lines @@
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 bool _isJsPeerInterface(DartObjectImpl value) =>
     value.type.name == 'JsPeerInterface';
 
 // 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;