Support generating inlined source maps and wrapping module contents within a JavaScript eval block …

pkg/dev_compiler/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:args/args.dart' show ArgParser, ArgResults;
 import 'package:path/path.dart' as path;
 
 import '../js_ast/js_ast.dart';
 import 'js_names.dart';
 
@@ skipping 28 matching lines @@
   if (format is String) {
     return [parseModuleFormat(format)];
   }
   return (format as List<String>).map(parseModuleFormat).toList();
 }
 
 /// Adds an option to the [argParser] for choosing the module format, optionally
 /// [allowMultiple] formats to be specified, with each emitted into a separate
 /// file.
 void addModuleFormatOptions(ArgParser argParser, {bool allowMultiple: false}) {
-  argParser.addOption('modules',
-      help: 'module pattern to emit',
-      allowed: [
-        'es6',
-        'common',
-        'amd',
-        'legacy', // deprecated
-        'node', // renamed to commonjs
-        'all' // to emit all flavors for the SDK
-      ],
-      allowedHelp: {
-        'es6': 'ECMAScript 6 modules',
-        'common': 'CommonJS/Node.js modules',
-        'amd': 'AMD/RequireJS modules'
-      },
-      allowMultiple: allowMultiple,
-      defaultsTo: 'amd');
+  argParser
+    ..addOption('modules',
+        help: 'module pattern to emit',
+        allowed: [
+          'es6',
+          'common',
+          'amd',
+          'legacy', // deprecated
+          'node', // renamed to commonjs
+          'all' // to emit all flavors for the SDK
+        ],
+        allowedHelp: {
+          'es6': 'ECMAScript 6 modules',
+          'common': 'CommonJS/Node.js modules',
+          'amd': 'AMD/RequireJS modules'
+        },
+        allowMultiple: allowMultiple,
+        defaultsTo: 'amd')
+    ..addFlag('single-out-file',
+        help: 'emit output so that libraries can be concatenated together into '
+            'a single file. Only compatible with legacy and amd module formats.',
+        defaultsTo: false);
 }
 
 /// Transforms an ES6 [module] into a given module [format].
 ///
 /// If the format is [ModuleFormat.es6] this will return [module] unchanged.
 ///
 /// Because JS ASTs are immutable the resulting module will share as much
 /// structure as possible with the original. The transformation is a shallow one
 /// that affects the top-level module items, especially [ImportDeclaration]s and
 /// [ExportDeclaration]s.
-Program transformModuleFormat(ModuleFormat format, Program module) {
+Program transformModuleFormat(
+    ModuleFormat format, bool singleOutFile, Program module) {
   switch (format) {
     case ModuleFormat.legacy:
-      return new LegacyModuleBuilder().build(module);
+      return new LegacyModuleBuilder(singleOutFile).build(module);
     case ModuleFormat.common:
-      return new CommonJSModuleBuilder().build(module);
+      return new CommonJSModuleBuilder(singleOutFile).build(module);
     case ModuleFormat.amd:
-      return new AmdModuleBuilder().build(module);
+      return new AmdModuleBuilder(singleOutFile).build(module);
     case ModuleFormat.es6:
+      assert(singleOutFile == false);
       return module;
   }
   return null; // unreachable. suppresses a bogus analyzer message
 }
 
 /// Base class for compiling ES6 modules into various ES5 module patterns.
 ///
 /// This is a helper class for utilities and state that is shared by several
 /// module transformers.
 // TODO(jmesserly): "module transformer" might be a better name than builder.
@@ skipping 28 matching lines @@
   }
 
   visitStatement(Statement node) {
     statements.add(node);
   }
 }
 
 /// Generates modules for with our legacy `dart_library.js` loading mechanism.
 // TODO(jmesserly): remove this and replace with something that interoperates.
 class LegacyModuleBuilder extends _ModuleBuilder {
+  /// The legacy module format always generates output compatible with a single
+  /// file mode.
+  LegacyModuleBuilder(bool singleOutFile);
+
   Program build(Program module) {
     // Collect imports/exports/statements.
     visitProgram(module);
 
     // Build import parameters.
     var exportsVar = new TemporaryId('exports');
     var parameters = <TemporaryId>[exportsVar];
     var importNames = <Expression>[];
     var importStatements = <Statement>[];
     for (var import in imports) {
@@ skipping 37 matching lines @@
       js.commentExpression(
           "Imports", new ArrayInitializer(importNames, multiline: true)),
       resultModule
     ]);
     return new Program(<ModuleItem>[moduleDef]);
   }
 }
 
 /// Generates CommonJS modules (used by Node.js).
 class CommonJSModuleBuilder extends _ModuleBuilder {
+  final bool singleOutFile;
+
+  CommonJSModuleBuilder(this.singleOutFile) {
+    // singleOutFile mode is not currently supported by the CommonJS module
+    // builder.
+    assert(singleOutFile == false);
+  }
+
   Program build(Program module) {
     var importStatements = <Statement>[];
 
     // Collect imports/exports/statements.
     visitProgram(module);
 
     for (var import in imports) {
       // TODO(jmesserly): we could use destructuring here.
       var moduleVar =
           new TemporaryId(pathToJSIdentifier(import.from.valueWithoutQuotes));
@@ skipping 29 matching lines @@
     // This extra level of indirection should be unnecessary.
     var block =
         js.statement("(function() { 'use strict'; #; })()", [statements]);
 
     return new Program([block]);
   }
 }
 
 /// Generates AMD modules (used in browsers with RequireJS).
 class AmdModuleBuilder extends _ModuleBuilder {
+  final bool singleOutFile;
+
+  AmdModuleBuilder(this.singleOutFile);
+
   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.
@@ skipping 21 matching lines @@
         assert(names != null);
         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]);
+    var block = singleOutFile
+        ? js.statement("define(#, #, function(#) { 'use strict'; #; });", [
+            js.string(module.name, "'"),
+            new ArrayInitializer(dependencies),
+            fnParams,
+            statements
+          ])
+        : 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));
 }
 
@@ skipping 18 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]');