Recognize const/fixed/growable arrays in simple types inferrer.

sdk/lib/_internal/compiler/implementation/ssa/optimize.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;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 318 matching lines @@
       assert(interceptor.constant.isInterceptor());
       ClassElement cls = interceptor.constant.dispatchedType.element;
       Element target = cls.lookupSelector(selector);
       if (target != null && selector.applies(target, compiler)) {
         node.element = target;
       }
     }
     return node;
   }
 
-  bool isFixedSizeListConstructor(HInvokeStatic node) {
-    Element element = node.target.element;
-    if (backend.fixedLengthListConstructor == null) {
-      backend.fixedLengthListConstructor =
-        compiler.listClass.lookupConstructor(
-            new Selector.callConstructor(const SourceString(""),
-                                         compiler.listClass.getLibrary()));
-    }
-    // TODO(ngeoffray): checking if the second input is an integer
-    // should not be necessary but it currently makes it easier for
-    // other optimizations to reason on a fixed length constructor
-    // that we know takes an int.
-    return element == backend.fixedLengthListConstructor
-        && node.inputs.length == 2
-        && node.inputs[1].isInteger();
-  }
-
-  HInstruction visitInvokeStatic(HInvokeStatic node) {
-    if (isFixedSizeListConstructor(node)) {
-      node.instructionType = HType.FIXED_ARRAY;
-    }
-    return node;
-  }
-
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     if (node.isCallOnInterceptor) return handleInterceptorCall(node);
     HType receiverType = node.receiver.instructionType;
     Selector selector = receiverType.refine(node.selector, compiler);
     Element element = compiler.world.locateSingleElement(selector);
     // TODO(ngeoffray): Also fold if it's a getter or variable.
     if (element != null && element.isFunction()) {
       FunctionElement method = element;
       FunctionSignature parameters = method.computeSignature(compiler);
       // TODO(ngeoffray): If the method has optional parameters,
@@ skipping 213 matching lines @@
     return compiler.world.locateSingleField(
         receiverType.refine(selector, compiler));
   }
 
   HInstruction visitFieldGet(HFieldGet node) {
     if (node.element == backend.jsArrayLength) {
       if (node.receiver is HInvokeStatic) {
         // Try to recognize the length getter with input
         // [:new List(int):].
         HInvokeStatic call = node.receiver;
-        if (isFixedSizeListConstructor(call)) {
+        Element element = call.target.element;
+        // TODO(ngeoffray): checking if the second input is an integer
+        // should not be necessary but it currently makes it easier for
+        // other optimizations to reason about a fixed length constructor
+        // that we know takes an int.
+        if (element == compiler.unnamedListConstructor
+            && call.inputs.length == 2
+            && call.inputs[1].isInteger()) {
           return call.inputs[1];
         }
       }
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     if (node.isCallOnInterceptor) return handleInterceptorCall(node);
 
@@ skipping 942 matching lines @@
     HBasicBlock block = user.block;
     block.addAfter(user, interceptor);
     block.rewrite(user, interceptor);
     block.remove(user);
 
     // The interceptor will be removed in the dead code elimination
     // phase. Note that removing it here would not work because of how
     // the [visitBasicBlock] is implemented.
   }
 }