Follow up to CL 764533002.

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 337 matching lines @@
     // Declare a function called "generateAccessor".  This is used in
     // defineClassFunction (it's a local declaration in init()).
     List result = <jsAst.Node>[
         generateAccessorFunction,
         js('$generateAccessorHolder = generateAccessor'),
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('defineClass'), defineClass) ];
 
     if (compiler.hasIncrementalSupport) {
       result.add(
-          js(r'self.$dart_unsafe_eval.defineClass = defineClass'));
+          js(r'#.defineClass = defineClass', [namer.accessIncrementalHelper]));
     }
 
     if (hasIsolateSupport) {
       jsAst.Expression classIdExtractorAccess =
           generateEmbeddedGlobalAccess(embeddedNames.CLASS_ID_EXTRACTOR);
       var classIdExtractorAssignment =
           js('# = function(o) { return o.constructor.name; }',
               classIdExtractorAccess);
 
       jsAst.Expression classFieldsExtractorAccess =
@@ skipping 50 matching lines @@
                 object[member] = properties[member];
               }
             }
             object.constructor = constructor;
             constructor.prototype = object;
             return object;
           };
         }()
       ''');
     if (compiler.hasIncrementalSupport) {
-      result = js(r'self.$dart_unsafe_eval.inheritFrom = #', [result]);
+      result = js(
+          r'#.inheritFrom = #', [namer.accessIncrementalHelper, result]);
     }
     return js(r'var inheritFrom = #', [result]);
   }
 
   /// Code that needs to be run before first invocation of
   /// [finishClassesFunction], but should only be run once.
   jsAst.Expression get initFinishClasses {
     jsAst.Expression allClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
     jsAst.Expression interceptorsByTagAccess =
@@ skipping 1124 matching lines @@
       /// following parenthesis looks like a call to the object literal.
       mainBuffer..add(
           'self.${deferredInitializers} = self.${deferredInitializers} || '
           'Object.create(null);$n');
     }
 
     // Using a named function here produces easier to read stack traces in
     // 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');
+      mainBuffer.add(jsAst.prettyPrint(js.statement(
+          """
+{
+  #helper = #helper || Object.create(null);
+  #helper.patch = function(a) { eval(a)};
+  #helper.schemaChange = #schemaChange;
+  #helper.addMethod = #addMethod;
+  #helper.extractStubs = function(array, name, isStatic, originalDescriptor) {
+    var descriptor = Object.create(null);
+    this.addStubs(descriptor, array, name, isStatic, originalDescriptor, []);
+    return descriptor;
+  };
+}""",
+          { 'helper': js('this.#', [namer.incrementalHelperName]),
+            'schemaChange': buildSchemaChangeFunction(),
+            'addMethod': buildIncrementalAddMethod() }), compiler));
     }
     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 224 matching lines @@
   /// 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;
-    var descriptor = Object.create(null);
-    this.addStubs(
-        descriptor, arrayOrFunction, name, isStatic, originalDescriptor, []);
+
+    // Each method may have a number of stubs associated. For example, if an
+    // instance method supports multiple arguments, a stub for each matching
+    // selector. There is also a getter stub for tear-off getters. For example,
+    // an instance method foo([a]) may have the following stubs: foo$0, foo$1,
+    // and get$foo (here exemplified using unminified names).
+    // [extractStubs] returns a JavaScript object whose own properties
+    // corresponds to the stubs.
+    var descriptor =
+        this.extractStubs(array, name, isStatic, originalDescriptor);
     method = descriptor[name];
+
+    // Iterate through the properties of descriptor and copy the stubs to the
+    // existing holder (for instance methods, a prototype).
     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 || !stub.$getterStub) {
         // Not replacing an existing getter stub.
         holder[property] = stub;
         continue;
       }
       if (!stub.$getterStub) {
         var error = new Error('Unexpected stub.');
         error.stub = stub;
         throw error;
       }
 
       // 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);
 
+          // Copy the properties from the new tear-off's prototype to the
+          // prototype of the existing tear-off.
           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
@@ skipping 346 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }