Incremental compiler: support optional arguments.

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 54 matching lines @@
     LinkBuilder;
 
 import 'package:compiler/src/elements/modelx.dart' show
     ClassElementX,
     CompilationUnitElementX,
     DeclarationSite,
     ElementX,
     FieldElementX,
     LibraryElementX;
 
+import 'package:compiler/src/universe/universe.dart' show
+    Selector;
+
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 typedef void Logger(message);
 
 typedef bool Reuser(
     Token diffToken,
     PartialElement before,
     PartialElement after);
@@ skipping 476 matching lines @@
         new Set<ClassElementX>.from(_classesWithSchemaChanges);
     for (Element element in updatedElements) {
       if (!element.isClass) {
         compiler.enqueuer.codegen.addToWorkList(element);
       } else {
         changedClasses.add(element);
       }
     }
     compiler.processQueue(compiler.enqueuer.codegen, null);
 
+    for (Element e in compiler.enqueuer.codegen.generatedCode.keys) {
+      if (e.isFunction && e.functionSignature.hasOptionalParameters) {
+        for (Selector selector in compiler.enqueuer.codegen.newlySeenSelectors) {

[Johnni Winther, 2014/12/05 09:48:23]

Long line.

[ahe, 2014/12/09 16:28:23]

Done.

+          // TODO(ahe): Group selectors by name at this point for improved
+          // performance.
+          if (e.name == selector.name &&
+              selector.appliesUnnamed(e, compiler.world)) {

[Johnni Winther, 2014/12/05 09:48:23]

Isn't this the same as `applies`?

[ahe, 2014/12/09 16:28:23]

Not exactly, but I had misunderstood the assertion errors I saw when using
applies.

The problem was that I was passing in constructors here.

+            // TODO(ahe): Don't use
+            // compiler.enqueuer.codegen.newlyEnqueuedElements directly like
+            // this, make a copy.
+            compiler.enqueuer.codegen.newlyEnqueuedElements.add(e);
+          }
+          if (selector.name == namer.closureInvocationSelectorName) {
+            selector = new Selector.call(
+                e.name, e.library,
+                selector.argumentCount, selector.namedArguments);
+            if (selector.appliesUnnamed(e, compiler.world)) {
+              // TODO(ahe): Also make a copy here.
+              compiler.enqueuer.codegen.newlyEnqueuedElements.add(e);
+            }
+          }
+        }
+      }
+    }
+
     List<jsAst.Statement> updates = <jsAst.Statement>[];
 
-    Set newClasses = new Set.from(
+    // TODO(ahe): allInstantiatedClasses seem to include interfaces that aren't
+    // needed.
+    Set<ClassElementX> newClasses = new Set.from(
         compiler.codegenWorld.allInstantiatedClasses.where(
             emitter.computeClassFilter()));
     newClasses.removeAll(_existingClasses);
 
+    // TODO(ahe): When more than one updated is computed, we need to make sure
+    // that existing classes aren't overwritten. No test except the one test
+    // that tests more than one update is affected by this problem, and only
+    // because main is closurized because we always enable tear-off. Is that
+    // really necessary? Also, add a test which tests directly that what
+    // happens when tear-off is introduced in second update.
+    emitter.neededClasses.addAll(newClasses);
+
     List<jsAst.Statement> inherits = <jsAst.Statement>[];
 
     for (ClassElementX cls in newClasses) {
       jsAst.Node classAccess = namer.elementAccess(cls);
       String name = namer.getNameOfClass(cls);
 
       updates.add(
           js.statement(
               r'# = #', [classAccess, invokeDefineClass(cls)]));
 
@@ skipping 22 matching lines @@
               r'# = self.$dart_unsafe_eval.schemaChange(#, #, #)',
               [classAccess, invokeDefineClass(cls), classAccess, superAccess]));
     }
 
     for (RemovalUpdate update in removals) {
       update.writeUpdateJsOn(updates);
     }
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (!element.isField) {
         updates.add(computeMemberUpdateJs(element));
+      } else {
+        if (backend.constants.lazyStatics.contains(element)) {
+          throw new StateError("$element requires lazy initializer.");
+        }
       }
     }
 
+    updates.add(js.statement(r'''
+if (self.$dart_unsafe_eval.pendingStubs) {
+  self.$dart_unsafe_eval.pendingStubs.map(function(e) { return e(); });
+  self.$dart_unsafe_eval.pendingStubs = void 0;
+}
+'''));
+
     if (updates.length == 1) {
       return prettyPrintJs(updates.single);
     } else {
       return prettyPrintJs(js.statement('{#}', [updates]));
     }
   }
 
   jsAst.Expression invokeDefineClass(ClassElementX cls) {
     String name = namer.getNameOfClass(cls);
     var descriptor = js('Object.create(null)');
@@ skipping 527 matching lines @@
   List<String> computeFields(ClassElement cls) {
     // TODO(ahe): Rewrite for new emitter.
     ClassBuilder builder = new ClassBuilder(cls, namer);
     classEmitter.emitFields(cls, builder, "");
     return builder.fields;
   }
 }
 
 // TODO(ahe): Remove this method.
 NO_WARN(x) => x;