- 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 26 matching lines @@
           // Run trivial constant folding first to optimize
           // some patterns useful for type conversion.
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaTypeConversionInserter(compiler),
           new SsaTypePropagator(compiler, types),
           new SsaCheckInserter(backend, work, types, context.boundsChecked),
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaConstantFolder(constantSystem, backend, work, types),
+          new SsaTypePropagator(compiler, types),
           new SsaGlobalValueNumberer(compiler, types),
           new SsaCodeMotion(),
           new SsaValueRangeAnalyzer(constantSystem, types, work),
           // Previous optimizations may have generated new
           // opportunities for constant folding.
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaDeadCodeEliminator(types)];
       runPhases(graph, phases);
       if (!speculative) {
         runPhase(graph, new SsaConstructionFieldTypes(backend, work, types));
@@ skipping 140 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 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)) {
+          return call.inputs[1];
+        }
+      }
+    }
+    return node;
+  }
+
+  HInstruction optimizeLengthInterceptedCall(HInvokeDynamicGetter node) {
+    HInstruction actualReceiver = node.inputs[1];
+    if (actualReceiver.isIndexablePrimitive(types)) {
+      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;
+      types[result] = 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);
     });
   }
 }