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);
+
+    jsAst.Block updates = new jsAst.Block.empty();
+    for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
+      updates.statements.add(computeMemberUpdateJs(element));

[sra1, 2014/10/07 18:03:06]

Construct ASTs functionally.
Don't modify constructed ASTs.
They are permitted to share structure and use non-growable lists (which saves
lots of space).
Construct the list first, or use a template to spread an Iterable into a block:

jsAst.Block updates = js.statement('{ # }',
   compiler.enqueuer.codegen.newlyEnqueuedElements.map(computeMemberUpdateJs));

[ahe, 2014/10/08 12:09:45]

I'm doing something like that.

+    }
+
+    if (updates.statements.length == 1) {
+      return prettyPrintJs(updates.statements.single);
+    } else {
+      return prettyPrintJs(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);
+    jsAst.Expression globalFunctionsAccess =
+        compiler.backend.emitter.generateEmbeddedGlobalAccess(
+            embeddedNames.GLOBAL_FUNCTIONS);
+    jsAst.Node updateGlobalFunction =
+        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.

[floitsch, 2014/10/07 15:56:58]

The only temporary variable updateScope has is the one that is needed to pass
the value along.

Couldn't you just write?
return js.statement('#.# = #.# = #;',
    [ globalFunctionsAccess, name, globalObject, name, function ]);

[ahe, 2014/10/07 16:32:40]

Yes, but I know I want to add at least one more statement to support tearOffs:

js.statement('#.main$closure().call$2 = f', globalObject);

This statement is conditional based on whether or not element can be torn off.

As I start supporting instance members, I expect this become more conditional.

[floitsch, 2014/10/07 17:48:38]

Maybe you could write it with conditions:
if (#) #.main$closure().call$2 = #.# 
[ hasTearoff, X, globalObject, name ]

The JS pretty-printer removes conditions with bools.

[sra1, 2014/10/07 18:03:06]

You can conditionally generate code with templates:

https://code.google.com/p/dart/source/browse/trunk/dart/tests/compiler/dart2j...

[ahe, 2014/10/08 12:09:45]

I think I'll avoid templates with conditionals in this situation. It feels like
adding an extra level of interpretation (slow) to a boolean I already have
computed, and I'm not sure the code is more readable.

+    jsAst.Fun updateScope = new jsAst.Fun(
+        [new jsAst.Parameter('f')], new jsAst.Block.empty());

[floitsch, 2014/10/07 15:56:58]

does the following work?

jsAst.Fun = js('function(f) { #; }, updateGlobalFunction);

or even:

return js.statement('!function(f) { #.# = #.# = f; }(#);',
    [ globalFunctionsAccess, name, globalObject, name, function ]);

[ahe, 2014/10/07 16:32:40]

Yes. But doesn't scale to multiple statements.  I tried this:

var jsAst.Block block = ...;
...
jsAst.Fun = js('function(f) #, block);

That doesn't work, and I'm not inclined to modify the parser to support this :-)

[floitsch, 2014/10/07 17:48:38]

I think you don't even need a block:

js('function(f) { #; }', [[list of statements]])

If that doesn't work, I can look up how it should be done. I'm sure there is an
easy way.

[sra1, 2014/10/07 18:03:06]

It does work, with a minor tweak.

Blocks (and iterables) are spliced into blocks on substitution, e.g.:
https://code.google.com/p/dart/source/browse/trunk/dart/tests/compiler/dart2j...

So:

   js('function (f) { # }', block);

The block will be spliced. Empty blocks and lists are spliced without extra
empty statements.

Given that in future you can use splicing (of a list that is built
conditionally) and / or conditionally generation with template if-statements,
you can write the meat of this function as:


return js.statement(
    '''(function(f) {
          #.# = #.# = f;
          if (#) #.main$closure().call$2 = f';
        })(#);
    ''',
    [globalFunctionsAccess, name, globalObject, name,
     isTearOff, globalObject,
     function]);
  

When I created the templates I intended the templates to be primary AST API.
Lets avoid manual constructors if at all possible.

[ahe, 2014/10/08 12:09:45]

That's pretty nifty, but I feel that this is more readable:

[
  js.statement('#.# = #.# = f', [globalFunctionsAccess, name, globalObject,
name]),
  js.statement('if (#) #.#.# = f', [isTearOff, globalObject, closureName,
callSelector]),
]

What I like about that is the proximity of # to its value.

And I think this is easier to read:

if (isTearOff) {
  statements.add(js.statement('#.#().# = f', [globalObject, closureName,
callSelector]));
}

I think it is easier to read because there's no mental overhead to match # to
"isTearOff".

+    updateScope.body.statements.add(updateGlobalFunction);

[sra1, 2014/10/07 18:03:06]

Ditto: Construct ASTs functionally.

[ahe, 2014/10/08 12:09:45]

I don't know what you mean by that.

+    return js.statement('(#)(#)', [updateScope, function]);
+  }
+
+  String prettyPrintJs(jsAst.Node node) {
+    return jsAst.prettyPrint(node, compiler).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();
   }
 }