Update global_compile tool

pkg/dev_compiler/tool/global_compile.dart

 #!/usr/bin/env dart
 // Copyright (c) 2016, 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 'dart:async';
 import 'dart:io';
 
 import 'package:analyzer/analyzer.dart'
     show
@@ skipping 10 matching lines @@
 
 void main(List<String> args) {
   // Parse flags.
   var parser = new ArgParser()
     ..addOption('out',
         help: 'Output file (defaults to "out.js")',
         abbr: 'o',
         defaultsTo: 'out.js')
     ..addFlag('unsafe-force-compile',
         help: 'Generate code with undefined behavior', negatable: false)
+    ..addFlag('emit-metadata',
+        help: 'Preserve annotations in generated code', negatable: false)
     ..addOption('package-root',
         help: 'Directory containing packages',
         abbr: 'p',
         defaultsTo: 'packages/')
     ..addFlag('log', help: 'Show individual build commands')
     ..addOption('tmp',
         help:
             'Directory for temporary artifacts (defaults to a system tmp directory)');
 
   var options = parser.parse(args);
   if (options.rest.length != 1) {
     throw 'Expected a single dart entrypoint.';
   }
   var entry = options.rest.first;
   var outfile = options['out'] as String;
   var packageRoot = options['package-root'] as String;
   var unsafe = options['unsafe-force-compile'] as bool;
   var log = options['log'] as bool;
   var tmp = options['tmp'] as String;
+  var metadata = options['emit-metadata'] as bool;
 
   // Build an invocation to dartdevc
   var dartPath = Platform.resolvedExecutable;
   var ddcPath = path.dirname(path.dirname(Platform.script.toFilePath()));
   var template = [
     '$ddcPath/bin/dartdevc.dart',
-    '--no-source-map', // Invalid as we're just concatenating files below
+    '--modules=legacy', // TODO(vsm): Change this to use common format.
+    '--single-out-file',
+    '--inline-source-map',
     '-p',
     packageRoot
   ];
+  if (metadata) {
+    template.add('--emit-metadata');
+  }
   if (unsafe) {
     template.add('--unsafe-force-compile');
   }
 
   // Compute the transitive closure
   var total = new Stopwatch()..start();
   var partial = new Stopwatch()..start();
 
   // TODO(vsm): We're using the analyzer just to compute the import/export/part
   // dependence graph.  This is expensive.  Is there a lighterweight way to do
   // this?
   transitiveFiles(entry, Directory.current.path, packageRoot);
   orderModules();
   computeTransitiveDependences();
 
   var graphTime = partial.elapsedMilliseconds / 1000;
   print('Computed global build graph in $graphTime seconds');
 
   // Prepend Dart runtime files to the output
   var out = new File(outfile);
   var dartLibrary =
-      new File(path.join(ddcPath, 'lib', 'runtime', 'dart_library.js'))
+      new File(path.join(ddcPath, 'lib', 'js', 'legacy', 'dart_library.js'))
           .readAsStringSync();
   out.writeAsStringSync(dartLibrary);
-  var dartSdk = new File(path.join(ddcPath, 'lib', 'runtime', 'dart_sdk.js'))
-      .readAsStringSync();
+  var dartSdk =
+      new File(path.join(ddcPath, 'lib', 'js', 'legacy', 'dart_sdk.js'))
+          .readAsStringSync();
   out.writeAsStringSync(dartSdk, mode: FileMode.APPEND);
 
   // Linearize module concatenation for deterministic output
   var last = new Future.value();
   for (var module in orderedModules) {
     linearizerMap[module] = last;
     var completer = new Completer();
     completerMap[module] = completer;
     last = completer.future;
   }
@@ skipping 175 matching lines @@
         var uri = _resolveDirective(d);
         processDependence(entryPoint, canonicalize(uri, entryDir));
         transitiveFiles(uri, entryDir, packageRoot);
       } else if (d is PartDirective) {
         var uri = _resolveDirective(d);
         processFile(canonicalize(uri, entryDir));
       }
     }
   }
 }