- Move length getter and setter interceptors to the new interceptor scheme.

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 186 matching lines @@
     HInstruction operand = node.operand;
     if (operand is HConstant) {
       UnaryOperation operation = node.operation(constantSystem);
       HConstant receiver = operand;
       Constant folded = operation.fold(receiver.constant);
       if (folded != null) return graph.addConstant(folded);
     }
     return node;
   }
 
-  HInstruction visitInvokeInterceptor(HInvokeInterceptor node) {
-    // Try to recognize the length interceptor with input [:new List(int):].
-    if (node.isLengthGetter() && node.inputs[1] is HInvokeStatic) {
-      HInvokeStatic call = node.inputs[1];
-      if (isFixedSizeListConstructor(call)) {
-        return call.inputs[1];
-      }
-    }
+  HInstruction handleInterceptorCall(HInvokeDynamic node) {
     HInstruction input = node.inputs[1];
-    if (node.isLengthGetter()) {
-      if (input.isConstantString()) {
-        HConstant constantInput = input;
-        StringConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length, constantSystem);
-      } else if (input.isConstantList()) {
-        HConstant constantInput = input;
-        ListConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length, constantSystem);
-      } else if (input.isConstantMap()) {
-        HConstant constantInput = input;
-        MapConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length, constantSystem);
-      }
-    }
-
     if (input.isString(types)
         && node.selector.name == const SourceString('toString')) {
       return node.inputs[1];
     }
-
-    if (!input.canBePrimitive(types) && node.selector.isCall()) {
-      bool transformToDynamicInvocation = true;
-      if (input.canBeNull(types)) {
-        // Check if the method exists on Null. If yes we must not transform
-        // the static interceptor call to a dynamic invocation.
-        // TODO(floitsch): get a list of methods that exist on 'null' and only
-        // bail out on them.
-        transformToDynamicInvocation = false;
-      }
-      if (transformToDynamicInvocation) {
-        return fromInterceptorToDynamicInvocation(node, node.selector);
-      }
-    }
-
     return node;
   }
 
   bool isFixedSizeListConstructor(HInvokeStatic node) {
     Element element = node.target.element;
     DartType defaultClass = compiler.listClass.defaultClass;
     // TODO(ngeoffray): make sure that the only reason the List class is
     // not resolved is because it's not being used.
     return element.isConstructor()
         && defaultClass != null
         && element.enclosingElement.declaration == defaultClass.element
         && node.inputs.length == 2
         && node.inputs[1].isInteger(types);
   }
 
   HInstruction visitInvokeStatic(HInvokeStatic node) {
     if (isFixedSizeListConstructor(node)) {
       node.guaranteedType = HType.FIXED_ARRAY;
     }
     return node;
   }
 
   HInstruction visitInvokeDynamic(HInvokeDynamic node) {
+    if (node.isInterceptorCall) return handleInterceptorCall(node);
     HType receiverType = types[node.receiver];
     if (receiverType.isExact()) {
       HBoundedType type = receiverType;
       Element element = type.lookupMember(node.selector.name);
       // TODO(ngeoffray): Also fold if it's a getter or variable.
       if (element != null && element.isFunction()) {
         if (node.selector.applies(element, compiler)) {
           FunctionElement method = element;
           FunctionSignature parameters = method.computeSignature(compiler);
           if (parameters.optionalParameterCount == 0) {
@@ skipping 301 matching lines @@
   Element findConcreteFieldForDynamicAccess(HInstruction receiver,
                                             Selector selector) {
     HType receiverType = types[receiver];
     if (!receiverType.isUseful()) return null;
     if (receiverType.canBeNull()) return null;
     DartType type = receiverType.computeType(compiler);
     if (type == null) return null;
     return compiler.world.locateSingleField(type, selector);
   }
 
+  HInstruction optimizeLengthInterceptedCall(HInvokeDynamicGetter node) {
+    HInstruction actualReceiver = node.inputs[1];
+    if (actualReceiver.isIndexablePrimitive(types)) {
+      // Try to recognize the length getter with input [:new List(int):].
+      if (actualReceiver is HInvokeStatic) {
+        HInvokeStatic call = node.inputs[1];
+        if (isFixedSizeListConstructor(call)) {
+          return call.inputs[1];
+        }
+      } else if (actualReceiver.isConstantString()) {
+        HConstant constantInput = actualReceiver;
+        StringConstant constant = constantInput.constant;
+        return graph.addConstantInt(constant.length, constantSystem);
+      } else if (actualReceiver.isConstantList()) {
+        HConstant constantInput = actualReceiver;
+        ListConstant constant = constantInput.constant;
+        return graph.addConstantInt(constant.length, constantSystem);
+      }
+      Element element;
+      bool isAssignable;
+      if (actualReceiver.isString(types)) {
+        element = backend.jsStringLength;
+        isAssignable = false;
+      } else {
+        element = backend.jsArrayLength;
+        isAssignable = !actualReceiver.isFixedArray(types);
+      }
+      HFieldGet result = new HFieldGet(
+          element, actualReceiver, isAssignable: isAssignable);
+      result.guaranteedType = HType.INTEGER;
+      return result;
+    } else if (actualReceiver.isConstantMap()) {
+      HConstant constantInput = actualReceiver;
+      MapConstant constant = constantInput.constant;
+      return graph.addConstantInt(constant.length, constantSystem);
+    }
+    return node;
+  }
+
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
+    if (node.selector.name == const SourceString('length')
+        && node.isInterceptorCall) {
+      return optimizeLengthInterceptedCall(node);
+    }
+
     Element field =
         findConcreteFieldForDynamicAccess(node.receiver, node.selector);
     if (field == null) return node;
 
     Modifiers modifiers = field.modifiers;
     bool isFinalOrConst = modifiers.isFinal() || modifiers.isConst();
     if (!compiler.resolverWorld.hasInvokedSetter(field, compiler)) {
       // If no setter is ever used for this field it is only initialized in the
       // initializer list.
       isFinalOrConst = true;
@@ skipping 42 matching lines @@
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final HTypeMap types;
   final ConstantSystem constantSystem;
   final Set<HInstruction> boundsChecked;
   final WorkItem work;
   final String name = "SsaCheckInserter";
   HGraph graph;
   Element lengthInterceptor;
-  Selector lengthSelector;
 
   SsaCheckInserter(JavaScriptBackend backend,
                    this.work,
                    this.types,
                    this.boundsChecked)
       : constantSystem = backend.constantSystem {
-    SourceString lengthString = const SourceString('length');
-    lengthSelector =
-        new Selector.getter(lengthString, work.element.getLibrary());
-    lengthInterceptor =
-        backend.builder.interceptors.getStaticInterceptor(lengthSelector);
+    lengthInterceptor = backend.jsArrayLength;
   }
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction = instruction.accept(this);
       instruction = next;
     }
   }
 
   HBoundsCheck insertBoundsCheck(HInstruction node,
                                  HInstruction receiver,
                                  HInstruction index) {
-    HStatic interceptor = new HStatic(lengthInterceptor);
-    node.block.addBefore(node, interceptor);
-    HInvokeInterceptor length = new HInvokeInterceptor(
-        lengthSelector, <HInstruction>[interceptor, receiver], true);
+    bool isAssignable = !receiver.isFixedArray(types);
+    HFieldGet length =
+        new HFieldGet(lengthInterceptor, receiver, isAssignable: isAssignable);
+    length.guaranteedType = HType.INTEGER;
     types[length] = HType.INTEGER;
     node.block.addBefore(node, length);
 
     HBoundsCheck check = new HBoundsCheck(index, length);
     node.block.addBefore(node, check);
     boundsChecked.add(node);
     return check;
   }
 
   HIntegerCheck insertIntegerCheck(HInstruction node, HInstruction value) {
@@ skipping 22 matching lines @@
     if (!node.receiver.isMutableArray(types)) return;
     if (boundsChecked.contains(node)) return;
     HInstruction index = node.index;
     if (!node.index.isInteger(types)) {
       index = insertIntegerCheck(node, index);
     }
     index = insertBoundsCheck(node, node.receiver, index);
     node.changeUse(node.index, index);
     assert(node.isBuiltin(types));
   }
-
-  void visitInvokeInterceptor(HInvokeInterceptor node) {
-    if (!node.isPopCall(types)) return;
-    if (boundsChecked.contains(node)) return;
-    HInstruction receiver = node.inputs[1];
-    insertBoundsCheck(node, receiver, graph.addConstantInt(0, constantSystem));
-  }
 }
 
 class SsaDeadCodeEliminator extends HGraphVisitor implements OptimizationPhase {
   final HTypeMap types;
   final String name = "SsaDeadCodeEliminator";
 
   SsaDeadCodeEliminator(this.types);
 
   bool isDeadCode(HInstruction instruction) {
     return !instruction.hasSideEffects(types)
@@ skipping 602 matching lines @@
     }
 
     // For other fields having setters in the generative constructor body, set
     // the type to UNKNOWN to avoid relying on the type set in the initializer
     // list.
     allSetters.forEach((Element element) {
       backend.registerFieldConstructor(element, HType.UNKNOWN);
     });
   }
 }