fix #626, add AMD module format and make it default

lib/src/compiler/module_builder.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.
 
 import 'package:path/path.dart' as path;
 
 import '../js_ast/js_ast.dart';
 import 'js_names.dart';
 
 /// Base class for compiling ES6 modules into various ES5 module patterns.
@@ skipping 87 matching lines @@
       js.string(module.name, "'"),
       new LiteralNull(),
       js.commentExpression(
           "Imports", new ArrayInitializer(importNames, multiline: true)),
       resultModule
     ]);
     return new Program(<ModuleItem>[moduleDef]);
   }
 }
 
-/// Generates node modules.
-class NodeModuleBuilder extends _ModuleBuilder {
+/// Generates commonjs modules (used by node.js).

[nweiz, 2016/08/16 22:14:54]

Nit: "CommonJS" and "Node.js"

[Jennifer Messerly, 2016/08/24 22:39:51]

Done.

+class CommonJSModuleBuilder extends _ModuleBuilder {
   Program build(Program module) {
     var importStatements = <Statement>[];
 
     // Collect imports/exports/statements.
     visitProgram(module);
 
     for (var import in imports) {
       // TODO(jmesserly): we could use destructuring once Atom supports it.
       var moduleVar =
           new TemporaryId(pathToJSIdentifier(import.from.valueWithoutQuotes));
@@ skipping 25 matching lines @@
 
     // TODO(vsm): See https://github.com/dart-lang/dev_compiler/issues/512
     // This extra level of indirection should be unnecessary.
     var block =
         js.statement("(function() { 'use strict'; #; })()", [statements]);
 
     return new Program([block]);
   }
 }
 
+/// Generates requirejs/AMD modules (popular for use in browser).
+class RequireJSModuleBuilder extends _ModuleBuilder {
+  Program build(Program module) {
+    var importStatements = <Statement>[];
+
+    // Collect imports/exports/statements.
+    visitProgram(module);
+
+    var dependencies = <LiteralString>[];
+    var fnParams = <Parameter>[];
+    for (var import in imports) {
+      // TODO(jmesserly): we could use destructuring once Atom supports it.

[vsm, 2016/08/16 21:23:23]

nit: atom / electron would use common, not requirejs.  :-)

[Jennifer Messerly, 2016/08/16 21:29:28]

thanks, I will clarify that comment. It's more "TODO we haven't bothered to use
destructuring anywhere yet because some impls didn't support it"

+      var moduleVar =
+          new TemporaryId(pathToJSIdentifier(import.from.valueWithoutQuotes));
+      fnParams.add(moduleVar);
+      dependencies.add(import.from);
+
+      // TODO(jmesserly): optimize for the common case of a single import.
+      for (var importName in import.namedImports) {
+        assert(!importName.isStar); // import * not supported yet.

[nweiz, 2016/08/16 22:14:54]

Not supported by what?

[Jennifer Messerly, 2016/08/24 22:39:51]

clarified comment. the compiler doesn't emit `import *`, so we don't need to
support it here

+        var asName = importName.asName ?? importName.name;
+        importStatements.add(js.statement(
+            'const # = #.#', [asName, moduleVar, importName.name.name]));
+      }
+    }
+    statements.insertAll(0, importStatements);
+
+    if (exports.isNotEmpty) {
+      var exportedProps = <Property>[];
+      for (var export in exports) {
+        var names = export.exportedNames;
+        assert(names != null); // export * not supported in legacy modules.

[nweiz, 2016/08/16 22:14:54]

This isn't a legacy module, right?

[Jennifer Messerly, 2016/08/24 22:39:51]

clarified comment. The compiler doesn't emit `export *` (because of legacy
modules), so we don't need to support it.

+        for (var name in names) {
+          exportedProps.add(new Property(js.string(name.name), name));
+        }
+      }
+      statements.add(js.comment('Exports:'));
+      statements.add(
+          new Return(new ObjectInitializer(exportedProps, multiline: true)));
+    }
+
+    var block = js.statement("define(#, function(#) { 'use strict'; #; });",
+        [new ArrayInitializer(dependencies), fnParams, statements]);
+
+    return new Program([block]);
+  }
+}
+
 /// Escape [name] to make it into a valid identifier.
 String pathToJSIdentifier(String name) {
   return toJSIdentifier(path.basenameWithoutExtension(name));
 }
 
 /// Escape [name] to make it into a valid identifier.
 String toJSIdentifier(String name) {
   if (name.length == 0) return r'$';
 
   // Escape any invalid characters
@@ skipping 13 matching lines @@
   // Ensure the identifier first character is not numeric and that the whole
   // identifier is not a keyword.
   if (result.startsWith(new RegExp('[0-9]')) || invalidVariableName(result)) {
     return '\$$result';
   }
   return result;
 }
 
 // Invalid characters for identifiers, which would need to be escaped.
 final _invalidCharInIdentifier = new RegExp(r'[^A-Za-z_$0-9]');