Check for duplicate library names

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, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 37 matching lines @@
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
 const DSEND = 'dsend';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   final AbstractCompiler compiler;
   final CompilerOptions options;
   final TypeRules rules;
   final LibraryInfo libraryInfo;
 
+  /// Entry point uri
+  final Uri root;
+
   /// The global extension type table.
   final HashSet<ClassElement> _extensionTypes;
 
   /// Information that is precomputed for this library, indicates which fields
   /// need storage slots.
   final HashSet<FieldElement> _fieldsNeedingStorage;
 
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
 
@@ skipping 17 matching lines @@
   final _namedArgTemp = new JS.TemporaryId('opts');
 
   ConstFieldVisitor _constField;
 
   ModuleItemLoadOrder _loader;
 
   JSCodegenVisitor(AbstractCompiler compiler, this.libraryInfo,
       this._extensionTypes, this._fieldsNeedingStorage)
       : compiler = compiler,
         options = compiler.options,
-        rules = compiler.rules {
+        rules = compiler.rules,
+        root = compiler.entryPointUri {
     _loader = new ModuleItemLoadOrder(_emitModuleItem);
   }
 
   LibraryElement get currentLibrary => libraryInfo.library;
   TypeProvider get types => rules.provider;
 
   JS.Program emitLibrary(LibraryUnit library) {
     String jsDefaultValue = null;
 
     // Modify the AST to make coercions explicit.
     new CoercionReifier(library, compiler).reify();
 
     var unit = library.library;
     if (unit.directives.isNotEmpty) {
       var libraryDir = unit.directives.first;
       if (libraryDir is LibraryDirective) {
         var jsName = findAnnotation(libraryDir.element, _isJsNameAnnotation);
         jsDefaultValue = getConstantField(jsName, 'name', types.stringType);
       }
     }
-    if (jsDefaultValue == null) jsDefaultValue = '{}';
 
     // TODO(jmesserly): visit scriptTag, directives?
 
     _loader.collectElements(currentLibrary, library.partsThenLibrary);
 
     for (var unit in library.partsThenLibrary) {
       _constField = new ConstFieldVisitor(types, unit);
 
       for (var decl in unit.declarations) {
         if (decl is TopLevelVariableDeclaration) {
@@ skipping 27 matching lines @@
     _qualifiedIds.forEach(unqualifyIfNeeded);
     _qualifiedGenericIds.forEach(unqualifyIfNeeded);
 
     if (_exports.isNotEmpty) _moduleItems.add(js.comment('Exports:'));
 
     // TODO(jmesserly): make these immutable in JS?
     for (var name in _exports) {
       _moduleItems.add(js.statement('#.# = #;', [_exportsVar, name, name]));
     }
 
-    var name = new JS.Identifier(jsLibraryName(currentLibrary));
+    var jsPath = js.string(jsOutputBase(currentLibrary, root), "'");
 
     // 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 params = [_exportsVar];
+    var processImport = (LibraryElement library, JS.TemporaryId temp,
+        List list) {
+      params.add(temp);
+      list.add(js.string(jsOutputBase(library, root), "'"));
+    };
+
+    var imports = [];
+    _imports.forEach((library, temp) {
+      if (_loader.libraryIsLoaded(library)) {
+        processImport(library, temp, imports);
+      }
+    });
+
+    var lazyImports = [];
+    _imports.forEach((library, temp) {
+      if (!_loader.libraryIsLoaded(library)) {
+        processImport(library, temp, lazyImports);
+      }
+    });
+
+    var module =
+        js.call("function(#) { 'use strict'; #; }", [params, _moduleItems]);
+
     var program = [
-      js.statement('var # = dart.defineLibrary(#, #);', [
-        name,
-        name,
-        js.call(jsDefaultValue)
+      js.statement("dart.library(#, #, #, #, #)", [
+        jsPath,
+        jsDefaultValue != null ? jsDefaultValue : new JS.LiteralNull(),
+        js.commentExpression(
+            "Imports", new JS.ArrayInitializer(imports, multiline: true)),
+        js.commentExpression("Lazy imports",
+            new JS.ArrayInitializer(lazyImports, multiline: true)),
+        module
       ])
     ];
 
-    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 = _loader.libraryIsLoaded(library) ? 'import' : 'lazyImport';
-      program.add(js.statement('var # = dart.#(#);', [name, helper, name]));
-    });
-
-    program.add(js.statement("(function(#) { 'use strict'; #; })(#);", [
-      params,
-      _moduleItems,
-      args
-    ]));
-
     return new JS.Program(program);
   }
 
   void _emitModuleItem(AstNode node) {
     // Attempt to group adjacent fields/properties.
     if (node is! VariableDeclaration) _flushLazyFields(_moduleItems);
     if (node is! FunctionDeclaration) _flushLibraryProperties(_moduleItems);
 
     var code = _visit(node);
     if (code != null) _moduleItems.add(code);
@@ skipping 2463 matching lines @@
     t = fillDynamicTypeArgs(t, rules.provider);
     t.interfaces.forEach(_addExtensionType);
     t.mixins.forEach(_addExtensionType);
     _addExtensionType(t.superclass);
   }
 
   String generateLibrary(LibraryUnit unit, LibraryInfo info) {
     var fields = findFieldsNeedingStorage(unit);
     var codegen = new JSCodegenVisitor(compiler, info, _extensionTypes, fields);
     var module = codegen.emitLibrary(unit);
-    var dir = path.join(outDir, jsOutputPath(info, root));
+    var dir = path.join(outDir, jsOutputPath(info.library, root));
     return writeJsLibrary(module, dir, emitSourceMaps: options.emitSourceMaps);
   }
 }
 
 /// 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.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
 
 /// Shorthand for identifier-like property names.
 /// For now, we emit them as strings and the printer restores them to
 /// identifiers if it can.
 // TODO(jmesserly): avoid the round tripping through quoted form.
 JS.LiteralString _propertyName(String name) => js.string(name, "'");
 
 /// Path to file that will be generated for [info]. In case it's url is a
 /// `file:` url, we use [root] to determine the relative path from the entry
 /// point file.
-String jsOutputPath(LibraryInfo info, Uri root) {
-  var uri = info.library.source.uri;
-  var filepath = '${path.withoutExtension(uri.path)}.js';
+String jsOutputPath(LibraryElement library, Uri root) {
+  return '${jsOutputBase(library, root)}.js';
+}
+
+String jsOutputBase(LibraryElement library, Uri root) {
+  var uri = library.source.uri;
+  var filepath = path.withoutExtension(uri.path);
   if (uri.scheme == 'dart') {
     filepath = 'dart/$filepath';
   } else if (uri.scheme == 'file') {
     filepath = path.relative(filepath, from: path.dirname(root.path));
   } else {
     assert(uri.scheme == 'package');
     // filepath is good here, we want the output to start with a directory
     // matching the package name.
   }
   return filepath;
@@ skipping 12 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }