fix #27607, add dev_compiler summary to the SDK and move JS files

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 47 matching lines @@
           '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);
+        help: 'emit modules that can be concatenated into one file.\n'
+            'Only compatible with legacy and amd module formats.',
+        defaultsTo: false,
+        hide: true);
 }
 
 /// 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, bool singleOutFile, Program module) {
+    ModuleFormat format, Program module, {bool singleOutFile: false}) {
   switch (format) {
     case ModuleFormat.legacy:
-      return new LegacyModuleBuilder(singleOutFile).build(module);
+      // Legacy format always generates output compatible with single file mode.
+      return new LegacyModuleBuilder().build(module);
     case ModuleFormat.common:
-      return new CommonJSModuleBuilder(singleOutFile).build(module);
+      assert(!singleOutFile);
+      return new CommonJSModuleBuilder().build(module);
     case ModuleFormat.amd:
-      return new AmdModuleBuilder(singleOutFile).build(module);
+      // TODO(jmesserly): encode singleOutFile as a module format?
+      // Since it's irrelevant except for AMD.
+      return new AmdModuleBuilder(singleOutFile: singleOutFile).build(module);
     case ModuleFormat.es6:
-      assert(singleOutFile == false);
+      assert(!singleOutFile);
       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>[];
@@ skipping 38 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 31 matching lines @@
         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);
+  AmdModuleBuilder({this.singleOutFile: false});
 
   Program build(Program module) {
     var importStatements = <Statement>[];
 
     // Collect imports/exports/statements.
     visitProgram(module);
 
     var dependencies = <LiteralString>[];
     var fnParams = <Parameter>[];
     for (var import in imports) {
@@ skipping 69 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]');