Compute an incremental patch to JavaScript code.

dart/site/try/poi/poi.dart

 // Copyright (c) 2014, 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 trydart.poi;
 
 import 'dart:async' show
     Completer,
     Future;
 
@@ skipping 43 matching lines @@
 
 import 'package:compiler/implementation/scanner/scannerlib.dart' show
     EOF_TOKEN,
     IDENTIFIER_TOKEN,
     KEYWORD_TOKEN,
     PartialClassElement,
     PartialElement,
     Token;
 
 import 'package:compiler/implementation/js/js.dart' show
-    prettyPrint;
+    js;
 
 /// Enabled by the option --enable-dart-mind.  Controls if this program should
 /// be querying Dart Mind.
 bool isDartMindEnabled = false;
 
 /// Iterator over lines from standard input (or the argument array).
 Iterator<String> stdin;
 
 /// Enabled by the option --simulate-mutation. When true, this program will
 /// only prompt for one file name, and subsequent runs will read
@@ skipping 14 matching lines @@
 int globalCounter = 0;
 
 /// Enabled by the option --verbose (or -v). Prints more information than you
 /// really need.
 bool isVerbose = false;
 
 /// Enabled by the option --compile. Also compiles the program after analyzing
 /// the POI.
 bool isCompiler = false;
 
+/// Enabled by the option --minify. Passes the same option to the compiler to
+/// generate minified output.
+bool enableMinification = false;
+
 /// When true (the default value) print serialized scope information at the
 /// provided position.
 const bool PRINT_SCOPE_INFO =
     const bool.fromEnvironment('PRINT_SCOPE_INFO', defaultValue: true);
 
 Stopwatch wallClock = new Stopwatch();
 
 PoiTask poiTask;
 
 Compiler cachedCompiler;
@@ skipping 44 matching lines @@
         case '--enable-dart-mind':
           isDartMindEnabled = true;
           break;
         case '-v':
         case '--verbose':
           isVerbose = true;
           break;
         case '--compile':
           isCompiler = true;
           break;
+        case '--minify':
+          enableMinification = true;
+          break;
         default:
           throw 'Unknown option: $argument.';
       }
     } else {
       nonOptionArguments.add(argument);
     }
   }
   if (nonOptionArguments.isEmpty) {
     stdin = new StdinIterator();
   } else {
@@ skipping 32 matching lines @@
     if (uri == script) {
       if (poiCount == count) {
         cachedFileName = uri.toFilePath();
         if (count != 0) {
           cachedFileName = '$cachedFileName.$count.dart';
         }
         printVerbose('Not using cached version of $cachedFileName');
         cache = new io.File(cachedFileName).readAsBytes().then((data) {
           printVerbose(
               'Read file $cachedFileName: '
-              '${UTF8.decode(data.sublist(0, 100), allowMalformed: true)}...');
+              '${UTF8.decode(data.take(100).toList(), allowMalformed: true)}...');
           return data;
         });
         count++;
       } else {
         printVerbose('Using cached version of $cachedFileName');
       }
       return cache;
     } else {
       printVerbose('Using original provider for $uri');
       return inputProvider(uri);
@@ skipping 153 matching lines @@
       '--verbose',
       '--categories=Client,Server',
       '--incremental-support',
       '--disable-type-inference',
   ];
 
   if (!isCompiler) {
     options.add('--analyze-only');
   }
 
+  if (enableMinification) {
+    options.add('--minify');
+  }
+
   LibraryUpdater updater =
       new LibraryUpdater(
           cachedCompiler, inputProvider, script, printWallClock, printVerbose);
   Future<bool> reuseLibrary(LibraryElement library) {
     return poiTask.measure(() => updater.reuseLibrary(library));
   }
 
   return reuseCompiler(
       diagnosticHandler: handler,
       inputProvider: inputProvider,
@@ skipping 24 matching lines @@
 
   if (!isFullCompile) {
     printFormattedTime(
         'Analyzing changes and updating elements took', sw.elapsedMicroseconds);
   }
   sw.reset();
 
   Future<bool> compilation;
 
   if (updater.hasPendingUpdates) {
-    List<Element> updatedElements = updater.applyUpdates();
     compilation = new Future(() {
-      cachedCompiler.progress.reset();
-      for (Element element in updatedElements) {
-        cachedCompiler.enqueuer.resolution.addToWorkList(element);
-      }
-      cachedCompiler.processQueue(cachedCompiler.enqueuer.resolution, null);
-
-      cachedCompiler.phase = Compiler.PHASE_DONE_RESOLVING;
-
-      for (Element element in updatedElements) {
-        cachedCompiler.enqueuer.codegen.addToWorkList(element);
-      }
-      cachedCompiler.processQueue(cachedCompiler.enqueuer.codegen, null);
-
-      for (Element element in updatedElements) {
-        var node = cachedCompiler.enqueuer.codegen.generatedCode[element];
-        print(prettyPrint(node, cachedCompiler).getText());
-      }
+      var node = js.statement(
+          r'var $dart_patch = #', js.escapedString(updater.computeUpdateJs()));
+      print(updater.prettyPrintJs(node));
 
       return !cachedCompiler.compilationFailed;
     });
   } else {
     compilation = cachedCompiler.run(updater.uri);
   }
 
   return compilation.then((success) {
     printVerbose('Compiler queue processed in ${sw.elapsedMicroseconds}us');
     if (isVerbose) {
@@ skipping 325 matching lines @@
 
 modelx.ImportScope importScope(modelx.LibraryElementX element) {
   return element.importScope;
 }
 
 class PoiTask extends CompilerTask {
   PoiTask(Compiler compiler) : super(compiler);
 
   String get name => 'POI';
 }