Revert r23380, some browser tests fail.

sdk/lib/_internal/compiler/implementation/js_backend/emitter.dart

 // Copyright (c) 2012, 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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 40 matching lines @@
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
 class CodeEmitterTask extends CompilerTask {
   bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsMixinSupport = false;
+  bool needsClosureClass = false;
   bool needsLazyInitializer = false;
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter nativeEmitter;
   CodeBuffer mainBuffer;
   final CodeBuffer deferredBuffer = new CodeBuffer();
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
@@ skipping 15 matching lines @@
   String get N => compiler.enableMinification ? "\n" : ";\n";
 
   /**
    * A cache of closures that are used to closurize instance methods.
    * A closure is dynamically bound to the instance used when
    * closurized.
    */
   final Map<int, String> boundClosureCache;
 
   /**
+   * A cache of closures that are used to closurize instance methods
+   * of interceptors. These closures are dynamically bound to the
+   * interceptor instance, and the actual receiver of the method.
+   */
+  final Map<int, String> interceptorClosureCache;
+
+  /**
    * Raw ClassElement symbols occuring in is-checks and type assertions.  If the
    * program contains parameterized checks `x is Set<int>` and
    * `x is Set<String>` then the ClassElement `Set` will occur once in
    * [checkedClasses].
    */
   Set<ClassElement> checkedClasses;
 
   /**
    * Raw Typedef symbols occuring in is-checks and type assertions.  If the
    * program contains `x is F<int>` and `x is F<bool>` then the TypedefElement
@@ skipping 12 matching lines @@
           .map((TypeVariableType v) => v.element.getEnclosingClass())
           .toList();
     }
     return cachedClassesUsingTypeVariableTests;
   }
 
   CodeEmitterTask(Compiler compiler, Namer namer, this.generateSourceMap)
       : mainBuffer = new CodeBuffer(),
         this.namer = namer,
         boundClosureCache = new Map<int, String>(),
+        interceptorClosureCache = new Map<int, String>(),
         constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   void addComment(String comment, CodeBuffer buffer) {
     buffer.write(jsAst.prettyPrint(js.comment(comment), compiler));
   }
 
   void computeRequiredTypeChecks() {
@@ skipping 1602 matching lines @@
     for (ClassElement interceptor in backend.interceptedClasses) {
       if (!needed.contains(interceptor)
           && interceptor != compiler.objectClass) {
         unneededClasses.add(interceptor);
       }
     }
 
     return (ClassElement cls) => !unneededClasses.contains(cls);
   }
 
+  void emitClosureClassIfNeeded(CodeBuffer buffer) {
+    // The closure class could have become necessary because of the generation
+    // of stubs.
+    ClassElement closureClass = compiler.closureClass;
+    if (needsClosureClass && !instantiatedClasses.contains(closureClass)) {
+      ClassElement objectClass = compiler.objectClass;
+      if (!instantiatedClasses.contains(objectClass)) {
+        generateClass(objectClass, bufferForElement(objectClass, buffer));
+      }
+      generateClass(closureClass, bufferForElement(closureClass, buffer));
+    }
+  }
+
   void emitFinishClassesInvocationIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
       buffer.write('$finishClassesName($classesCollector,'
                    '$_$isolateProperties,'
                    '${_}null)$N');
 
       // Reset the map.
       buffer.write("$classesCollector$_=${_}null$N$n");
     }
   }
@@ skipping 63 matching lines @@
       buffer.write(jsAst.prettyPrint(assignment, compiler));
       buffer.write('$N');
     }
   }
 
   void emitStaticFunctionClosures() {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.staticFunctionsNeedingGetter;
     for (FunctionElement element in
              Elements.sortedByPosition(functionsNeedingGetter)) {
-      assert(instantiatedClasses.contains(compiler.closureClass));
       String staticName = namer.getName(element);
       String superName = namer.getName(compiler.closureClass);
       String name = 'Closure\$${element.name.slowToString()}';
+      needsClosureClass = true;
 
       ClassElement closureClassElement = new ClosureClassElement(
           null, new SourceString(name), compiler, element,
           element.getCompilationUnit());
       // Now add the methods on the closure class. The instance method does not
       // have the correct name. Since [addParameterStubs] use the name to create
       // its stubs we simply create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(namer.closureInvocationSelectorName,
@@ skipping 38 matching lines @@
         js.string("$superName;${fieldNames.join(',')}"));
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitDynamicFunctionGetter(FunctionElement member,
                                  DefineStubFunction defineStub) {
-    assert(instantiatedClasses.contains(compiler.boundClosureClass));
     assert(invariant(member, member.isDeclaration));
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
     // 'foo' and somewhere in the code there is a dynamic property get of
     // 'foo'. Then we generate the following code (in pseudo Dart/JavaScript):
     //
     // class A {
     //    foo(x, y, z) { ... } // Original function.
     //    get foo { return new BoundClosure499(this, "foo"); }
     // }
-    // class BoundClosure499 extends BoundClosure {
-    //   BoundClosure499(this.self, this.target);
-    //   $call3(x, y, z) { return self[target](x, y, z); }
+    // class BoundClosure499 extends Closure {
+    //   var self;
+    //   BoundClosure499(this.self, this.name);
+    //   $call3(x, y, z) { return self[name](x, y, z); }
     // }
 
     // TODO(floitsch): share the closure classes with other classes
     // if they share methods with the same signature. Currently we do this only
     // if there are no optional parameters. Closures with optional parameters
     // are more difficult to canonicalize because they would need to have the
     // same default values.
 
     bool hasOptionalParameters = member.optionalParameterCount(compiler) != 0;
     int parameterCount = member.parameterCount(compiler);
 
-    Map<int, String> cache = boundClosureCache;
+    Map<int, String> cache;
+    String extraArg = null;
     // Intercepted methods take an extra parameter, which is the
     // receiver of the call.
     bool inInterceptor = backend.isInterceptedMethod(member);
-    List<String> fieldNames = <String>[];
-    compiler.boundClosureClass.forEachInstanceField((_, field) {
-      fieldNames.add(namer.getName(field));
-    });
+    if (inInterceptor) {
+      cache = interceptorClosureCache;
+      extraArg = 'receiver';
+    } else {
+      cache = boundClosureCache;
+    }
+    List<String> fieldNames = compiler.enableMinification
+        ? inInterceptor ? const ['a', 'b', 'c']
+                        : const ['a', 'b']
+        : inInterceptor ? const ['self', 'target', 'receiver']
+                        : const ['self', 'target'];
 
     Iterable<Element> typedefChecks =
         getTypedefChecksOn(member.computeType(compiler));
     bool hasTypedefChecks = !typedefChecks.isEmpty;
 
     bool canBeShared = !hasOptionalParameters && !hasTypedefChecks;
 
     String closureClass = canBeShared ? cache[parameterCount] : null;
     if (closureClass == null) {
       // Either the class was not cached yet, or there are optional parameters.
       // Create a new closure class.
       String name;
       if (canBeShared) {
-        name = 'BoundClosure\$${parameterCount}';
+        if (inInterceptor) {
+          name = 'BoundClosure\$i${parameterCount}';
+        } else {
+          name = 'BoundClosure\$${parameterCount}';
+        }
       } else {
         name = 'Bound_${member.name.slowToString()}'
             '_${member.enclosingElement.name.slowToString()}';
       }
 
       ClassElement closureClassElement = new ClosureClassElement(
           null, new SourceString(name), compiler, member,
           member.getCompilationUnit());
       String mangledName = namer.getName(closureClassElement);
       String superName = namer.getName(closureClassElement.superclass);
+      needsClosureClass = true;
 
       // Define the constructor with a name so that Object.toString can
       // find the class name of the closure class.
       ClassBuilder boundClosureBuilder = new ClassBuilder();
       emitBoundClosureClassHeader(
           mangledName, superName, fieldNames, boundClosureBuilder);
       // Now add the methods on the closure class. The instance method does not
       // have the correct name. Since [addParameterStubs] use the name to create
       // its stubs we simply create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
@@ skipping 40 matching lines @@
 
     // And finally the getter.
     String getterName = namer.getterName(member);
     String targetName = namer.instanceMethodName(member);
 
     List<String> parameters = <String>[];
     List<jsAst.Expression> arguments = <jsAst.Expression>[];
     arguments.add(js('this'));
     arguments.add(js.string(targetName));
     if (inInterceptor) {
-      parameters.add('receiver');
-      arguments.add(js('receiver'));
+      parameters.add(extraArg);
+      arguments.add(js(extraArg));
     }
 
     jsAst.Expression getterFunction = js.fun(
         parameters,
         js.return_(js(closureClass).newWith(arguments)));
 
     defineStub(getterName, getterFunction);
   }
 
   /**
@@ skipping 931 matching lines @@
       nativeEmitter.assembleCode(nativeBuffer);
 
       // Might create boundClosures.
       if (!deferredClasses.isEmpty) {
         for (ClassElement element in deferredClasses) {
           generateClass(element, bufferForElement(element, mainBuffer));
         }
       }
 
       emitStaticFunctionClosures();
+      emitClosureClassIfNeeded(mainBuffer);
 
       addComment('Bound closures', mainBuffer);
       // Now that we have emitted all classes, we know all the bound
       // closures that will be needed.
       for (jsAst.Node node in boundClosures) {
         // TODO(ahe): Some of these can be deferred.
         mainBuffer.add(jsAst.prettyPrint(node, compiler));
         mainBuffer.add("$N$n");
       }
 
@@ skipping 242 matching lines @@
         functions.push(property);
       } else {
         $$[property] = element;
         classes.push(property);
         classes.push(element[""]);
       }
     }
     libraries.push([name, uri, classes, functions]);
   }
 })''';