Create specialized versions of getInterceptor.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1512 matching lines @@
   }
 
   js.Call jsPropertyCall(js.Expression receiver,
                          String fieldName,
                          List<js.Expression> arguments) {
     return new js.Call(new js.PropertyAccess.field(receiver, fieldName),
                        arguments);
   }
 
   void visitInterceptor(HInterceptor node) {
-    Element element = backend.getInterceptorMethod;
-    assert(element != null);
-    world.registerStaticUse(element);
-    js.VariableUse interceptor =
-        new js.VariableUse(backend.namer.isolateAccess(element));
+    String name =
+        backend.registerSpecializedGetInterceptor(node.interceptedClasses);
+    js.VariableUse interceptor = new js.VariableUse(name);
     use(node.receiver);
     List<js.Expression> arguments = <js.Expression>[pop()];
     push(new js.Call(interceptor, arguments), node);
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
     js.Expression object = pop();
     SourceString name = node.selector.name;
     String methodName;
@@ skipping 83 matching lines @@
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     use(node.receiver);
     Selector getter = node.selector;
     String name = backend.namer.getterName(getter.library, getter.name);
     push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
     world.registerDynamicGetter(
         getter.name, getOptimizedSelectorFor(node, getter));
     if (node.isInterceptorCall) {
       backend.addInterceptedSelector(getter);
     }
+    world.registerInstantiatedClass(compiler.functionClass);
   }
 
   visitInvokeClosure(HInvokeClosure node) {
     use(node.receiver);
     push(jsPropertyCall(pop(),
                         backend.namer.closureInvocationName(node.selector),
                         visitArguments(node.inputs)),
          node);
     Selector call = new Selector.callClosureFrom(node.selector);
     world.registerDynamicInvocation(call.name, call);
@@ skipping 123 matching lines @@
       }
       pushStatement(new js.LiteralStatement(code), node);
     } else {
       List<js.Expression> data = <js.Expression>[];
       for (int i = 0; i < inputs.length; i++) {
         use(inputs[i]);
         data.add(pop());
       }
       push(new js.LiteralExpression.withData(code, data), node);
     }
+    DartType type = types[node].computeType(compiler);
+    if (type != null) {
+      world.registerInstantiatedClass(type.element);
+    }
     // TODO(sra): Tell world.nativeEnqueuer about the types created here.
   }
 
   visitForeignNew(HForeignNew node) {
     visitedForeignCode = true;
     String jsClassReference = backend.namer.isolateAccess(node.element);
     List<HInstruction> inputs = node.inputs;
     // We can't use 'visitArguments', since our arguments start at input[0].
     List<js.Expression> arguments = <js.Expression>[];
     for (int i = 0; i < inputs.length; i++) {
@@ skipping 51 matching lines @@
       String name = namer.constantName(constant);
       js.VariableUse currentIsolateUse =
           new js.VariableUse(backend.namer.CURRENT_ISOLATE);
       push(new js.PropertyAccess.field(currentIsolateUse, name));
     }
   }
 
   visitConstant(HConstant node) {
     assert(isGenerateAtUseSite(node));
     generateConstant(node.constant);
+    DartType type = node.constant.computeType(compiler);
+    world.registerInstantiatedClass(type.element);
   }
 
   visitLoopBranch(HLoopBranch node) {
     if (subGraph != null && identical(node.block, subGraph.end)) {
       // We are generating code for a loop condition.
       // If doing this as part of a SubGraph traversal, the
       // calling code will handle the control flow logic.
 
       // If we are generating the subgraph as an expression, the
       // condition will be generated as the expression.
@@ skipping 213 matching lines @@
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
   }
 
   void visitStatic(HStatic node) {
     // Check whether this static is used for anything else than as a target in
     // a static call.
     node.usedBy.forEach((HInstruction instr) {
       if (instr is !HInvokeStatic) {
         backend.registerNonCallStaticUse(node);
-      } else if (!identical(instr.target, node)) {
+        if (node.element.isFunction()) {
+          world.registerInstantiatedClass(compiler.functionClass);
+        }
+      } else if (instr.target != node) {
         backend.registerNonCallStaticUse(node);
-      } else {
-        // If invoking the static is can still be passed as an argument as well
-        // which will also be non call static use.
-        for (int i = 1; i < node.inputs.length; i++) {
-          if (identical(node.inputs, node)) {
-            backend.registerNonCallStaticUse(node);
-            break;
-          }
-        }
       }
     });
-    world.registerStaticUse(node.element);
+    Element element = node.element;
+    world.registerStaticUse(element);
+    ClassElement cls = element.getEnclosingClass();    
+    if (element.isGenerativeConstructor()
+        || (element.isFactoryConstructor() && cls == compiler.listClass)) {
+      world.registerInstantiatedClass(cls);
+    }
     push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
   }
 
   void visitLazyStatic(HLazyStatic node) {
     Element element = node.element;
     world.registerStaticUse(element);
     String lazyGetter = backend.namer.isolateLazyInitializerAccess(element);
     js.VariableUse target = new js.VariableUse(lazyGetter);
     js.Call call = new js.Call(target, <js.Expression>[]);
     push(call, node);
@@ skipping 34 matching lines @@
       Element convertToString = compiler.findHelper(const SourceString("S"));
       world.registerStaticUse(convertToString);
       js.VariableUse variableUse =
           new js.VariableUse(backend.namer.isolateAccess(convertToString));
       use(node);
       push(new js.Call(variableUse, <js.Expression>[pop()]), node);
     }
   }
 
   void visitLiteralList(HLiteralList node) {
+    world.registerInstantiatedClass(compiler.listClass);
     generateArrayLiteral(node);
   }
 
   void generateArrayLiteral(HLiteralList node) {
     int len = node.inputs.length;
     List<js.ArrayElement> elements = <js.ArrayElement>[];
     for (int i = 0; i < len; i++) {
       use(node.inputs[i]);
       elements.add(new js.ArrayElement(i, pop()));
     }
@@ skipping 877 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }