Incremental compiler: Use addStubs for adding methods.

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 1434 matching lines @@
     // Chrome/V8.
     mainBuffer.add('(function(${namer.currentIsolate})$_{\n');
     if (compiler.hasIncrementalSupport) {
       mainBuffer.add(
           'this.\$dart_unsafe_eval ='
           ' this.\$dart_unsafe_eval || Object.create(null)$N');
       mainBuffer.add(
           'this.\$dart_unsafe_eval.patch = function(a) { eval(a) }$N');
       String schemaChange =
           jsAst.prettyPrint(buildSchemaChangeFunction(), compiler).getText();
+      String addMethod =
+          jsAst.prettyPrint(buildIncrementalAddMethod(), compiler).getText();
       mainBuffer.add(
           'this.\$dart_unsafe_eval.schemaChange$_=$_$schemaChange$N');
+      mainBuffer.add(
+          'this.\$dart_unsafe_eval.addMethod$_=$_$addMethod$N');
     }
     if (isProgramSplit) {
       /// We collect all the global state of the, so it can be passed to the
       /// initializer of deferred files.
       mainBuffer.add('var ${globalsHolder}$_=${_}Object.create(null)$N');
     }
     mainBuffer.add('function dart()$_{$n'
         '${_}${_}this.x$_=${_}0$N'
         '${_}${_}delete this.x$N'
         '}$n');
@@ skipping 208 matching lines @@
       oldPrototype[property] = newPrototype[property];
     }
   }
   oldPrototype.__proto__ = newConstructor.prototype.__proto__;
   oldPrototype.constructor = newConstructor;
   newConstructor.prototype = oldPrototype;
   return newConstructor;
 }''');
   }
 
+  /// 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'''
+function(originalDescriptor, name, holder, isStatic, globalFunctionsAccess) {
+  var arrayOrFunction = originalDescriptor[name];
+  var method;
+  if (arrayOrFunction.constructor === Array) {
+    var existing = holder[name];
+    var array = arrayOrFunction;

[Johnni Winther, 2014/12/01 13:40:21]

`array` is never used.

[ahe, 2014/12/01 14:03:38]

Will do in follow up.

+    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;
+        continue;
+      }
+      if (!stub.$getterStub) {
+        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;
+        }
+      }
+    }
+  } 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 =
         new Map<OutputUnit, CodeBuffer>();
 
@@ skipping 318 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }