fixes #219, able to compile multiple entry points

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;
 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/devc.dart' show AbstractCompiler;
+import 'package:dev_compiler/src/compiler.dart' show AbstractCompiler;
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart' show CodegenOptions;
 import 'package:dev_compiler/src/utils.dart';
 
 import 'code_generator.dart';
 import 'js_field_storage.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
 import 'js_module_item_order.dart';
 import 'js_printer.dart' show writeJsLibrary;
 import 'side_effect_analysis.dart';
 
 // Various dynamic helpers we call.
 // If renaming these, make sure to check other places like the
 // dart_runtime.js file and comments.
 // TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
 // import and generate calls to, rather than dart_runtime.js
 const DPUT = 'dput';
 const DLOAD = 'dload';
 const DINDEX = 'dindex';
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
 const DSEND = 'dsend';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor {
   final AbstractCompiler compiler;
   final CodegenOptions options;
   final TypeRules rules;
-  final LibraryInfo libraryInfo;
-
-  /// Entry point uri
-  final Uri root;
+  final LibraryElement currentLibrary;
 
   /// 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 21 matching lines @@
 
   ConstFieldVisitor _constField;
 
   ModuleItemLoadOrder _loader;
 
   /// _interceptors.JSArray<E>, used for List literals.
   ClassElement _jsArray;
 
   Map<String, DartType> _objectMembers;
 
-  JSCodegenVisitor(AbstractCompiler compiler, this.libraryInfo,
+  JSCodegenVisitor(AbstractCompiler compiler, this.currentLibrary,
       this._extensionTypes, this._fieldsNeedingStorage)
       : compiler = compiler,
         options = compiler.options.codegenOptions,
-        rules = compiler.rules,
-        root = compiler.entryPointUri {
+        rules = compiler.rules {
     _loader = new ModuleItemLoadOrder(_emitModuleItem);
 
     var context = compiler.context;
     var src = context.sourceFactory.forUri('dart:_interceptors');
     var interceptors = context.computeLibraryElement(src);
     _jsArray = interceptors.getType('JSArray');
 
     _objectMembers = getObjectMemberMap(types);
   }
 
-  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) {
@@ skipping 43 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 jsPath = js.string(jsOutputBase(currentLibrary, root), "'");
+    var jsPath = compiler.getModuleName(currentLibrary.source.uri);
 
     // 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, _runtimeLibVar];
     var processImport = (LibraryElement library, JS.TemporaryId temp,
         List list) {
       params.add(temp);
-      list.add(js.string(jsOutputBase(library, root), "'"));
+      list.add(js.string(compiler.getModuleName(library.source.uri), "'"));
     };
 
     var imports = [js.string('dart_runtime/dart')];
     _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 dartxImport =
         js.statement("let # = #.dartx;", [_dartxVar, _runtimeLibVar]);
 
     var module = js.call("function(#) { 'use strict'; #; #; }", [
       params,
       dartxImport,
       _moduleItems
     ]);
 
     var program = [
       js.statement("dart_library.library(#, #, #, #, #)", [
-        jsPath,
+        js.string(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
       ])
     ];
 
     return new JS.Program(program);
@@ skipping 2571 matching lines @@
   }
 
   void _addExtensionType(InterfaceType t) {
     if (t.isObject || !_extensionTypes.add(t.element)) return;
     t = fillDynamicTypeArgs(t, rules.provider);
     t.interfaces.forEach(_addExtensionType);
     t.mixins.forEach(_addExtensionType);
     _addExtensionType(t.superclass);
   }
 
-  String generateLibrary(LibraryUnit unit, LibraryInfo info) {
+  String generateLibrary(LibraryUnit unit) {
+    var library = unit.library.element.library;
     var fields = findFieldsNeedingStorage(unit);
-    var codegen = new JSCodegenVisitor(compiler, info, _extensionTypes, fields);
+    var codegen =
+        new JSCodegenVisitor(compiler, library, _extensionTypes, fields);
     var module = codegen.emitLibrary(unit);
-    var dir = path.join(outDir, jsOutputPath(info.library, root));
-    return writeJsLibrary(module, dir, emitSourceMaps: options.emitSourceMaps);
+    var out = compiler.getOutputPath(library.source.uri);
+    return writeJsLibrary(module, out, 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(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;
-}
-
 // 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;
@@ skipping 10 matching lines @@
 
 class _JsThisFinder extends JS.BaseVisitor {
   bool found = false;
   visitThis(JS.This node) {
     found = true;
   }
   visitNode(JS.Node node) {
     if (!found) super.visitNode(node);
   }
 }