Incremental compiler: support optional arguments.

dart/pkg/compiler/lib/src/js_emitter/old_emitter/emitter.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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 1780 matching lines @@
   }
 
   /// Used by incremental compilation to patch up an object ([holder]) with a
   /// new (or updated) method.  [arrayOrFunction] is either the new method, or
   /// an array containing the method (see
   /// [ContainerBuilder.addMemberMethodFromInfo]). [name] is the name of the
   /// new method. [isStatic] tells if method is static (or
   /// top-level). [globalFunctionsAccess] is a reference to
   /// [embeddedNames.GLOBAL_FUNCTIONS].
   jsAst.Fun buildIncrementalAddMethod() {
-    return js(r'''
+    return js(r"""
 function(originalDescriptor, name, holder, isStatic, globalFunctionsAccess) {
   var arrayOrFunction = originalDescriptor[name];
   var method;
   if (arrayOrFunction.constructor === Array) {
     var existing = holder[name];
     var array = arrayOrFunction;
     var descriptor = Object.create(null);
     this.addStubs(
         descriptor, arrayOrFunction, name, isStatic, originalDescriptor, []);
     method = descriptor[name];
     for (var property in descriptor) {
       if (!Object.prototype.hasOwnProperty.call(descriptor, property)) continue;
       var stub = descriptor[property];
       var existingStub = holder[property];
-      if (stub === method || !existingStub) {
-        // Not replacing an existing stub.
-        holder[property] = method;
+      if (stub === method || !existingStub || !stub.$getterStub) {
+        // Not replacing an existing getter stub.
+        holder[property] = stub;
         continue;
       }
       if (!stub.$getterStub) {
-        var error = new Error("Unexpected stub.");
+        var error = new Error('Unexpected stub.');
         error.stub = stub;
         throw error;
       }
-      // Invoke the existing stub to obtain the tear-off closure.
-      existingStub = existingStub();
-      // A stub already exist. Update all its references to [existing] to
-      // [method].
-      for (var reference in existingStub) {
-        if (existingStub[reference] === existing) {
-          existingStub[reference] = method;
+
+      // Existing getter stubs need special treatment as they may already have
+      // been called and produced a closure.
+      this.pendingStubs = this.pendingStubs || [];
+      // It isn't safe to invoke the stub yet.
+      this.pendingStubs.push((function(holder, stub, existingStub, existing,
+                                       method) {
+        return function() {
+          var receiver = isStatic ? holder : new holder.constructor();
+          // Invoke the existing stub to obtain the tear-off closure.
+          existingStub = existingStub.call(receiver);
+          // Invoke the new stub to create a tear-off closure we can use as a
+          // prototype.
+          stub = stub.call(receiver);
+
+          var newProto = stub.constructor.prototype;
+          var existingProto = existingStub.constructor.prototype;
+          for (var stubProperty in newProto) {
+            if (!Object.prototype.hasOwnProperty.call(newProto, stubProperty))
+              continue;
+            existingProto[stubProperty] = newProto[stubProperty];
+          }
+
+          // Update all the existing stub's references to [existing] to
+          // [method]. Instance tear-offs are call-by-name, so this isn't
+          // necessary for those.
+          if (!isStatic) return;
+          for (var reference in existingStub) {
+            if (existingStub[reference] === existing) {
+              existingStub[reference] = method;
+            }
+          }
         }
-      }
+      })(holder, stub, existingStub, existing, method));
     }
   } else {
     method = arrayOrFunction;
     holder[name] = method;
   }
   if (isStatic) globalFunctionsAccess[name] = method;
-}''');
+}""");
   }
 
   /// Returns a map from OutputUnit to a hash of its content. The hash uniquely
   /// identifies the code of the output-unit. It does not include
   /// boilerplate JS code, like the sourcemap directives or the hash
   /// itself.
   Map<OutputUnit, String> emitDeferredOutputUnits() {
     if (!compiler.deferredLoadTask.isProgramSplit) return const {};
 
     Map<OutputUnit, CodeBuffer> outputBuffers =
@@ skipping 320 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }