fixes #157, renaming local library identifiers if needed.

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 50 matching lines @@
   final HashSet<FieldElement> _fieldsNeedingStorage;
 
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
 
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   ConstantEvaluator _constEvaluator;
 
+  /// Imported libraries, and the temporaries used to refer to them.
+  final _imports = new Map<LibraryElement, JS.TemporaryId>();
   final _exports = new Set<String>();
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashMap<String, JS.TemporaryId>();
   final _extensionMethodNames = new HashSet<String>();
   final _pendingStatements = <JS.Statement>[];
   final _temps = new HashMap<Element, JS.TemporaryId>();
 
   /// 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 _exportsVar = new JS.TemporaryId('exports');
   final _namedArgTemp = new JS.TemporaryId('opts');
 
   /// Classes we have not emitted yet. Values can be [ClassDeclaration] or
   /// [ClassTypeAlias].
   final _pendingClasses = new HashMap<Element, CompilationUnitMember>();
 
   /// Memoized results of [_lazyClass].
   final _lazyClassMemo = new HashMap<Element, bool>();
@@ skipping 42 matching lines @@
 
     assert(_pendingClasses.isEmpty);
 
     if (_exports.isNotEmpty) body.add(js.comment('Exports:'));
 
     // TODO(jmesserly): make these immutable in JS?
     for (var name in _exports) {
       body.add(js.statement('#.# = #;', [_exportsVar, name, name]));
     }
 
-    var name = jsLibraryName(libraryInfo.library);
+    var name = new JS.Identifier(jsLibraryName(currentLibrary));
 
-    var defaultValue = js.call(jsDefaultValue);
-    return new JS.Program([
-      js.statement('var #;', name),
-      js.statement("(function(#) { 'use strict'; #; })(# || (# = #));", [
-        _exportsVar,
-        body,
+    // TODO(jmesserly): it would be great to run the renamer on the body,
+    // then figure out if we really need each of these parameters.
+    // See ES6 modules: https://github.com/dart-lang/dev_compiler/issues/34
+    var program = [
+      js.statement('var # = dart.defineLibrary(#, #);', [
         name,
         name,
-        defaultValue
+        js.call(jsDefaultValue)
       ])
-    ]);
+    ];
+
+    var params = [_exportsVar];
+    var args = [name];
+    _imports.forEach((library, temp) {
+      var name = new JS.Identifier(temp.name);
+      params.add(temp);
+      args.add(name);
+      var helper = _libraryMightNotBeLoaded(library) ? 'lazyImport' : 'import';
+      program.add(js.statement('var # = dart.#(#);', [name, helper, name]));
+    });
+
+    program.add(js.statement(
+        "(function(#) { 'use strict'; #; })(#);", [params, body, args]));
+
+    return new JS.Program(program);
   }
 
   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.
@@ skipping 303 matching lines @@
   /// 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);
+    return _libraryMightNotBeLoaded(library);
+  }
 
+  bool _libraryMightNotBeLoaded(LibraryElement library) {
     // 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 = corelibOrder.indexOf(library.name);
       if (classOrder == -1) classOrder = corelibOrder.length;
 
       var currentOrder = corelibOrder.indexOf(currentLibrary.name);
@@ skipping 603 matching lines @@
     }
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (element is PropertyAccessorElement) element = accessor.variable;
     var name = element.name;
 
     // library member
     if (element.enclosingElement is CompilationUnitElement &&
-        (element.library != libraryInfo.library ||
+        (element.library != currentLibrary ||
             element is TopLevelVariableElement && !element.isConst)) {
       var memberName = _emitMemberName(name, isStatic: true);
       return js.call('#.#', [_libraryName(element.library), memberName]);
     }
 
     // Unqualified class member. This could mean implicit-this, or implicit
     // call to a static from the same class.
     if (element is ClassMemberElement && element is! ConstructorElement) {
       bool isStatic = element.isStatic;
       var type = element.enclosingElement.type;
@@ skipping 1121 matching lines @@
 
   @override
   visitNullLiteral(NullLiteral node) => new JS.LiteralNull();
 
   @override
   visitSymbolLiteral(SymbolLiteral node) {
     // TODO(vsm): When we canonicalize, we need to treat private symbols
     // correctly.
     var name = js.string(node.components.join('.'), "'");
     var nameHint = 'symbol_' + node.components.join('_');
-    return _const(node, js.call('new core.Symbol(#)', name), nameHint);
+    return _const(
+        node, new JS.New(_emitTypeName(types.symbolType), [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)]);
     }
@@ skipping 228 matching lines @@
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
   /// Choose a canonical name from the library element.
   /// This never uses the library's name (the identifier in the `library`
   /// declaration) as it doesn't have any meaningful rules enforced.
   JS.Identifier _libraryName(LibraryElement library) {
-    if (library == libraryInfo.library) return _exportsVar;
-    return new JS.Identifier(jsLibraryName(library));
+    if (library == currentLibrary) return _exportsVar;
+    return _imports.putIfAbsent(
+        library, () => new JS.TemporaryId(jsLibraryName(library)));
   }
 
   DartType getStaticType(Expression e) => rules.getStaticType(e);
 }
 
 class JSGenerator extends CodeGenerator {
   final CompilerOptions options;
 
   /// For fast lookup of extension methods, we first check the name, then do a
   /// (possibly expensive) subtype test to see if it matches one of the types
@@ skipping 63 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;