Add --modules=node support

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:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
 import 'package:analyzer/src/task/dart.dart' show PublicNamespaceBuilder;
 
 import 'ast_builder.dart' show AstBuilder;
 import 'reify_coercions.dart' show CoercionReifier, Tuple2;
 
 // TODO(jmesserly): import from its own package
 import '../js/js_ast.dart' as JS;
 import '../js/js_ast.dart' show js;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
-import '../compiler.dart' show AbstractCompiler;
+import '../compiler.dart'
+    show AbstractCompiler, corelibOrder, getCorelibModuleName;
 import '../info.dart';
 import '../options.dart' show CodegenOptions;
 import '../utils.dart';
 
 import 'code_generator.dart';
 import 'js_field_storage.dart';
 import 'js_interop.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
 import 'js_module_item_order.dart';
@@ skipping 35 matching lines @@
   Expression _cascadeTarget;
 
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   /// In an async* function, this represents the stream controller parameter.
   JS.TemporaryId _asyncStarController;
 
   /// Imported libraries, and the temporaries used to refer to them.
   final _imports = new Map<LibraryElement, JS.TemporaryId>();
-  final _exports = new Set<String>();
+  final _exports = <String, String>{};
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashMap<String, JS.TemporaryId>();
   final _moduleItems = <JS.Statement>[];
   final _temps = new HashMap<Element, JS.TemporaryId>();
   final _qualifiedIds = new List<Tuple2<Element, JS.MaybeQualifiedId>>();
 
   /// The name for the library's exports inside itself.
   /// `exports` was chosen as the most similar to ES module patterns.
   final _dartxVar = new JS.Identifier('dartx');
   final _exportsVar = new JS.TemporaryId('exports');
@@ skipping 82 matching lines @@
       var id = elementIdPairs.e1;
       id.setQualified(!_loader.isLoaded(element));
     }
 
     var moduleBuilder = new ModuleBuilder(options.moduleFormat);
 
     _exports.forEach(moduleBuilder.addExport);
 
     var items = <JS.ModuleItem>[];
     if (!_isDartRuntime) {
+      if (currentLibrary.source.isInSystemLibrary) {
+        // Force the import order of runtime libs.
+        // TODO(ochafik): Reduce this to a minimum.
+        for (var lib in corelibOrder.reversed) {
+          // TODO(ochafik): Use uris instead in corelibOrder.
+          moduleBuilder.addImport(getCorelibModuleName(lib), null);
+        }
+      }
       moduleBuilder.addImport('dart/_runtime', _runtimeLibVar);
 
       var dartxImport =
           js.statement("let # = #.dartx;", [_dartxVar, _runtimeLibVar]);
       items.add(dartxImport);
     }
     items.addAll(_moduleItems);
 
     _imports.forEach((LibraryElement lib, JS.TemporaryId temp) {
       moduleBuilder.addImport(compiler.getModuleName(lib.source.uri), temp,
@@ skipping 60 matching lines @@
             .where((s) => !currentLibNames.containsKey(s))
             .map((s) => js.string(s, "'")));
       }
       if (hide != null) {
         hiddenNames.addAll(hide.hiddenNames.map((i) => js.string(i.name, "'")));
       }
       args.add(new JS.ArrayInitializer(shownNames));
       args.add(new JS.ArrayInitializer(hiddenNames));
     }
 
-    // When we compile _runtime.js, we need to source export_ from _utils.js:
     _moduleItems.add(js.statement('dart.export(#);', [args]));
   }
 
   JS.Identifier _initSymbol(JS.Identifier id) {
     var s =
         js.statement('const # = $_SYMBOL(#);', [id, js.string(id.name, "'")]);
     _moduleItems.add(s);
     return id;
   }
 
@@ skipping 253 matching lines @@
       var genericInst = _emitTypeName(dynType, lowerGeneric: true);
       return js.statement('{ #; let # = #; }', [genericDef, name, genericInst]);
     }
     return body;
   }
 
   JS.Statement _emitGenericClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$name\$';
     var typeParams = _typeFormalsOf(type).map((p) => p.name);
-    if (isPublic(name)) _exports.add(genericName);
+    if (isPublic(name)) _addExport(genericName);
     return js.statement('const # = dart.generic(function(#) { #; return #; });',
         [genericName, typeParams, body, name]);
   }
 
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
   bool _deferIfNeeded(DartType type, ClassElement current) {
     if (type is ParameterizedType) {
       var typeArguments = type.typeArguments;
       for (var typeArg in typeArguments) {
@@ skipping 743 matching lines @@
 
     if (node.isGetter || node.isSetter) {
       // Add these later so we can use getter/setter syntax.
       _properties.add(node);
       return null;
     }
 
     var body = <JS.Statement>[];
     _flushLibraryProperties(body);
 
-    var name = _getJSExportName(node.element) ?? node.name.name;
+    var name = node.name.name;
 
     var fn = _visit(node.functionExpression);
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
       fn = _simplifyPassThroughArrowFunCallBody(fn);
     }
 
     var id = new JS.Identifier(name);
     body.add(annotate(new JS.FunctionDeclaration(id, fn), node.element));
     if (!_isDartRuntime) {
       body.add(_emitFunctionTagged(id, node.element.type, topLevel: true)
           .toStatement());
     }
 
-    if (isPublic(name)) _addExport(name);
+    if (isPublic(name)) {
+      _addExport(name, _getJSExportName(node.element) ?? name);
+    }
     return _statement(body);
   }
 
   bool _isInlineJSFunction(FunctionExpression functionExpression) {
     var body = functionExpression.body;
     if (body is ExpressionFunctionBody) {
       return _isJSInvocation(body.expression);
     } else if (body is BlockFunctionBody) {
       if (body.block.statements.length == 1) {
         var stat = body.block.statements.single;
@@ skipping 412 matching lines @@
         var genericName = _emitTopLevelName(element, suffix: '\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
     return _emitTopLevelName(element);
   }
 
   JS.Expression _emitTopLevelName(Element e, {String suffix: ''}) {
     var libName = _libraryName(e.library);
-    var nameExpr = _propertyName((_getJSExportName(e) ?? e.name) + suffix);
 
     // Always qualify:
     // * mutable top-level fields
     // * elements from other libraries
     bool mutableTopLevel = e is TopLevelVariableElement &&
         !e.isConst &&
         !_isFinalJSDecl(e.computeNode());
     bool fromAnotherLibrary = e.library != currentLibrary;
+    var nameExpr;
+    if (fromAnotherLibrary) {
+      nameExpr = _propertyName((_getJSExportName(e) ?? e.name) + suffix);
+    } else {
+      nameExpr = _propertyName(e.name + suffix);
+    }
     if (mutableTopLevel || fromAnotherLibrary) {
       return new JS.PropertyAccess(libName, nameExpr);
     }
 
     var id = new JS.MaybeQualifiedId(libName, nameExpr);
     _qualifiedIds.add(new Tuple2(e, id));
     return id;
   }
 
   @override
@@ skipping 357 matching lines @@
     return new JS.Yield(_visit(node.expression));
   }
 
   @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     for (var v in node.variables.variables) {
       _loader.loadDeclaration(v, v.element);
     }
   }
 
-  _addExport(String name) {
-    if (!_exports.add(name)) throw 'Duplicate top level name found: $name';
+  /// Emits static fields.
+  ///
+  /// Instance fields are emitted in [_initializeFields].
+  ///
+  /// These are generally treated the same as top-level fields, see
+  /// [visitTopLevelVariableDeclaration].
+  @override
+  visitFieldDeclaration(FieldDeclaration node) {
+    if (!node.isStatic) return;
+
+    for (var f in node.fields.variables) {
+      _loader.loadDeclaration(f, f.element);
+    }
+  }
+
+  _addExport(String name, [String exportName]) {
+    if (_exports.containsKey(name)) {
+      throw 'Duplicate top level name found: $name';
+    }
+    _exports[name] = exportName ?? name;
   }
 
   @override
   JS.Statement visitVariableDeclarationStatement(
       VariableDeclarationStatement node) {
     // Special case a single variable with an initializer.
     // This helps emit cleaner code for things like:
     //     var result = []..add(1)..add(2);
     if (node.variables.variables.length == 1) {
       var v = node.variables.variables.single;
@@ skipping 88 matching lines @@
       // later on when we emit lazy fields. That seems busted.
       jsInit = _visitInitializer(field);
       eagerInit = false;
     }
 
     // Treat `final x = JS('', '...')` as a const (non-lazy) to help compile
     // runtime helpers.
     var isJSTopLevel = field.isFinal && _isFinalJSDecl(field);
     if (isJSTopLevel) eagerInit = true;
 
-    var fieldName = _getJSExportName(element) ?? field.name.name;
-    if (field.isConst && eagerInit || isJSTopLevel) {
+    var fieldName = field.name.name;
+    var exportName = fieldName;
+    if (element is TopLevelVariableElement) {
+      exportName = _getJSExportName(element) ?? fieldName;
+    }
+    if ((field.isConst && eagerInit && element is TopLevelVariableElement) ||
+        isJSTopLevel) {
       // constant fields don't change, so we can generate them as `let`
       // but add them to the module's exports. However, make sure we generate
       // anything they depend on first.
-      if (isPublic(fieldName)) _addExport(fieldName);
+
+      if (isPublic(fieldName)) _addExport(fieldName, exportName);
       var declKeyword = field.isConst || field.isFinal ? 'const' : 'let';
       return annotateVariable(
           js.statement(
               '$declKeyword # = #;', [new JS.Identifier(fieldName), jsInit]),
           field.element);
     }
 
     if (eagerInit && !JS.invalidStaticFieldName(fieldName)) {
       return annotateVariable(
           js.statement('# = #;', [_visit(field.name), jsInit]), field.element);
@@ skipping 1283 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);
 }