Collect getters in a FunctionSet while resolving.

lib/compiler/implementation/ssa/nodes.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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 779 matching lines @@
   static const int GREATER_TYPECODE = 21;
   static const int GREATER_EQUAL_TYPECODE = 22;
   static const int LESS_TYPECODE = 23;
   static const int LESS_EQUAL_TYPECODE = 24;
   static const int STATIC_TYPECODE = 25;
   static const int STATIC_STORE_TYPECODE = 26;
   static const int FIELD_GET_TYPECODE = 27;
   static const int TYPE_CONVERSION_TYPECODE = 28;
   static const int BAILOUT_TARGET_TYPECODE = 29;
   static const int INVOKE_STATIC_TYPECODE = 30;
+  static const int INVOKE_DYNAMIC_GETTER_TYPECODE = 31;
 
   HInstruction(this.inputs)
       : id = idCounter++,
         usedBy = <HInstruction>[];
 
   int hashCode() => id;
 
   bool getFlag(int position) => (flags & (1 << position)) != 0;
   void setFlag(int position) { flags |= (1 << position); }
   void clearFlag(int position) { flags &= ~(1 << position); }
@@ skipping 487 matching lines @@
   HInvokeDynamicField(Selector selector, Element element,
                       List<HInstruction> inputs)
       : super(selector, element, inputs);
   toString() => 'invoke dynamic field: $selector';
 
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 class HInvokeDynamicGetter extends HInvokeDynamicField {
-  HInvokeDynamicGetter(selector, element, receiver)
+  final bool isSideEffectFree;
+  HInvokeDynamicGetter(
+      selector, element, receiver, this.isSideEffectFree)
     : super(selector, element,[receiver]);
   toString() => 'invoke dynamic getter: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicGetter(this);
+
+  void prepareGvn(HTypeMap types) {
+    if (isSideEffectFree) {
+      setUseGvn();
+      clearAllSideEffects();
+      setDependsOnSomething();
+    } else {
+      setAllSideEffects();
+    }
+  }
+
+  int typeCode() => HInstruction.INVOKE_DYNAMIC_GETTER_TYPECODE;
+  bool typeEquals(other) => other is HInvokeDynamicGetter;
+  bool dataEquals(HInvokeDynamicGetter other) => selector == other.selector;
 }
 
 class HInvokeDynamicSetter extends HInvokeDynamicField {
   HInvokeDynamicSetter(selector, element, receiver, value)
     : super(selector, element, [receiver, value]);
   toString() => 'invoke dynamic setter: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicSetter(this);
 }
 
 class HInvokeStatic extends HInvoke {
@@ skipping 28 matching lines @@
 
   HInstruction get value {
     assert(isSetter);
     // Index 0: the element, index 1: 'this'.
     return inputs[2];
   }
 }
 
 class HInvokeInterceptor extends HInvokeStatic {
   final Selector selector;
+  final bool isSideEffectFree;
 
   HInvokeInterceptor(this.selector,
                      List<HInstruction> inputs,
-                     [HType knownType = HType.UNKNOWN])
-      : super(inputs, knownType);
+                     [bool this.isSideEffectFree = false])
+      : super(inputs);
 
   toString() => 'invoke interceptor: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeInterceptor(this);
 
   bool isLengthGetter() {
     return selector.isGetter() &&
         selector.name == const SourceString('length');
   }
 
   bool isPopCall(HTypeMap types) {
@@ skipping 35 matching lines @@
 
   void prepareGvn(HTypeMap types) {
     if (isLengthGetterOnStringOrArray(types)) {
       setUseGvn();
       clearAllSideEffects();
       // If the input is a string, we know the length cannot change.
       // We cannot do the same thing for non-extendable array because
       // we don't express that type yet: a mutable array might be
       // extendable.
       if (!inputs[1].isString(types)) setDependsOnSomething();
+    } else if (isSideEffectFree) {
+      setUseGvn();
+      clearAllSideEffects();
+      setDependsOnSomething();
     } else {
       setAllSideEffects();
     }
   }
 
   int typeCode() => HInstruction.INVOKE_INTERCEPTOR_TYPECODE;
   bool typeEquals(other) => other is HInvokeInterceptor;
   bool dataEquals(HInvokeInterceptor other) => selector == other.selector;
 }
 
@@ skipping 1446 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty());
     return statements.last().end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }