Compute an incremental patch to JavaScript code.

dart/pkg/dart2js_incremental/lib/library_updater.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 dart2js_incremental.library_updater;
 
 import 'dart:async' show
     Future;
 
 import 'dart:convert' show
@@ skipping 14 matching lines @@
     PartialElement,
     PartialFunctionElement,
     Token;
 
 import 'package:compiler/implementation/source_file.dart' show
     StringSourceFile;
 
 import 'package:compiler/implementation/tree/tree.dart' show
     FunctionExpression;
 
+import 'package:compiler/implementation/js/js.dart' show
+    js;
+
+import 'package:compiler/implementation/js/js.dart' as jsAst;
+
+import 'package:compiler/implementation/js_emitter/js_emitter.dart' show
+    ClassBuilder;
+
+import 'package:compiler/js_lib/shared/embedded_names.dart' as embeddedNames;
+
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 typedef void Logger(message);
 
 // TODO(ahe): Generalize this class. For now only works for Compiler.mainApp,
 // and only if that library has exactly one compilation unit.
 class LibraryUpdater {
   final Compiler compiler;
@@ skipping 123 matching lines @@
       token = token.next;
     }
     print('Simple modification of ${after} detected');
     updates.add(new FunctionUpdate(compiler, before, after));
     return true;
   }
 
   List<Element> applyUpdates() {
     return updates.map((Update update) => update.apply()).toList();
   }
+
+  String computeUpdateJs() {
+    List<Element> updatedElements = applyUpdates();
+    compiler.progress.reset();
+    for (Element element in updatedElements) {
+      compiler.enqueuer.resolution.addToWorkList(element);
+    }
+    compiler.processQueue(compiler.enqueuer.resolution, null);
+
+    compiler.phase = Compiler.PHASE_DONE_RESOLVING;
+
+    for (Element element in updatedElements) {
+      compiler.enqueuer.codegen.addToWorkList(element);
+    }
+    compiler.processQueue(compiler.enqueuer.codegen, null);
+
+    List<jsAst.Statement> updates = <jsAst.Statement>[];
+    for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
+      updates.add(computeMemberUpdateJs(element));
+    }
+
+    if (updates.length == 1) {
+      return prettyPrintJs(updates.single);
+    } else {
+      return prettyPrintJs(js.statement('{#}', [updates]));
+    }
+  }
+
+  jsAst.Node computeMemberUpdateJs(Element element) {
+    ClassBuilder builder = new ClassBuilder(element, compiler.backend.namer);
+
+    compiler.backend.emitter.oldEmitter.containerBuilder.addMember(
+        element, builder);
+    jsAst.Property property = builder.properties.single;
+    jsAst.Node name = property.name;
+    jsAst.Node function = property.value;
+    jsAst.Node globalObject = compiler.backend.namer.globalObjectFor(element);

[Johnni Winther, 2014/10/08 13:21:50]

globalObject should be a String.

[ahe, 2014/10/09 13:56:27]

Actually, I should probably use Namer.elementAccess instead, so that's what I've
done.

+    jsAst.Expression globalFunctionsAccess =
+        compiler.backend.emitter.generateEmbeddedGlobalAccess(
+            embeddedNames.GLOBAL_FUNCTIONS);
+    List<jsAst.Statement> statements = <jsAst.Statement>[];
+    statements.add(
+        js.statement(
+            '#.# = #.# = f',
+            [globalFunctionsAccess, name, globalObject, name]));
+    // Create a scope by creating a new function. The updated function literal
+    // is passed as an argument to this function which ensures that temporary
+    // names in updateScope don't shadow global names.
+    jsAst.Fun updateScope = js('function (f) { # }', [statements]);
+    return js.statement('(#)(#)', [updateScope, function]);
+  }
+
+  String prettyPrintJs(jsAst.Node node) {
+    jsAst.Printer printer = new jsAst.Printer(compiler, null);
+    printer.blockOutWithoutBraces(node);
+    return printer.outBuffer.getText();
+  }
 }
 
 /// Represents an update (aka patch) of [before] to [after]. We use the word
 /// "update" to avoid confusion with the compiler feature of "patch" methods.
 abstract class Update {
   final Compiler compiler;
 
   PartialElement get before;
 
   PartialElement get after;
@@ skipping 26 matching lines @@
     before.getOrSet = after.getOrSet;
   }
 
   /// Reset various caches and remove this element from the compiler's internal
   /// state.
   void reuseElement() {
     compiler.forgetElement(before);
     before.reuseElement();
   }
 }