dart2js: Introduce HGetLength to replace strange use of HFieldGet

pkg/compiler/lib/src/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.
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/backend_api.dart' show BackendClasses;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 26 matching lines @@
   R visitBreak(HBreak node);
   R visitConstant(HConstant node);
   R visitContinue(HContinue node);
   R visitCreate(HCreate node);
   R visitDivide(HDivide node);
   R visitExit(HExit node);
   R visitExitTry(HExitTry node);
   R visitFieldGet(HFieldGet node);
   R visitFieldSet(HFieldSet node);
   R visitForeignCode(HForeignCode node);
+  R visitGetLength(HGetLength node);
   R visitGoto(HGoto node);
   R visitGreater(HGreater node);
   R visitGreaterEqual(HGreaterEqual node);
   R visitIdentity(HIdentity node);
   R visitIf(HIf node);
   R visitIndex(HIndex node);
   R visitIndexAssign(HIndexAssign node);
   R visitInterceptor(HInterceptor node);
   R visitInvokeClosure(HInvokeClosure node);
   R visitInvokeDynamicGetter(HInvokeDynamicGetter node);
@@ skipping 293 matching lines @@
   visitContinue(HContinue node) => visitJump(node);
   visitCheck(HCheck node) => visitInstruction(node);
   visitConstant(HConstant node) => visitInstruction(node);
   visitCreate(HCreate node) => visitInstruction(node);
   visitDivide(HDivide node) => visitBinaryArithmetic(node);
   visitExit(HExit node) => visitControlFlow(node);
   visitExitTry(HExitTry node) => visitControlFlow(node);
   visitFieldGet(HFieldGet node) => visitFieldAccess(node);
   visitFieldSet(HFieldSet node) => visitFieldAccess(node);
   visitForeignCode(HForeignCode node) => visitInstruction(node);
+  visitGetLength(HGetLength node) => visitInstruction(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
   visitIdentity(HIdentity node) => visitRelational(node);
   visitIf(HIf node) => visitConditionalBranch(node);
   visitIndex(HIndex node) => visitInstruction(node);
   visitIndexAssign(HIndexAssign node) => visitInstruction(node);
   visitInterceptor(HInterceptor node) => visitInstruction(node);
   visitInvokeClosure(HInvokeClosure node) => visitInvokeDynamic(node);
   visitInvokeConstructorBody(HInvokeConstructorBody node) =>
@@ skipping 515 matching lines @@
   static const int DYNAMIC_TYPE_TYPECODE = 35;
   static const int TRUNCATING_DIVIDE_TYPECODE = 36;
   static const int IS_VIA_INTERCEPTOR_TYPECODE = 37;
 
   static const int TYPE_INFO_READ_RAW_TYPECODE = 38;
   static const int TYPE_INFO_READ_VARIABLE_TYPECODE = 39;
   static const int TYPE_INFO_EXPRESSION_TYPECODE = 40;
 
   static const int FOREIGN_CODE_TYPECODE = 41;
   static const int REMAINDER_TYPECODE = 42;
+  static const int GET_LENGTH_TYPECODE = 43;
 
   HInstruction(this.inputs, this.instructionType)
       : id = idCounter++,
         usedBy = <HInstruction>[] {
     assert(inputs.every((e) => e != null));
   }
 
   int get hashCode => id;
 
   bool useGvn() => _useGvn;
@@ skipping 782 matching lines @@
   // The 'inputs' are
   //     [receiver, arg1, ..., argN] or
   //     [interceptor, receiver, arg1, ... argN].
   HInvokeConstructorBody(element, inputs, type) : super(element, inputs, type);
 
   String toString() => 'invoke constructor body: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeConstructorBody(this);
 }
 
 abstract class HFieldAccess extends HInstruction {
-  // TODO(johnniwinther): This should be a [FieldLike] but JSIndexable.length is
-  // encoded using a [HFieldGet].
-  final MemberEntity element;
+  final FieldEntity element;
 
   HFieldAccess(this.element, List<HInstruction> inputs, TypeMask type)
       : super(inputs, type);
 
   HInstruction get receiver => inputs[0];
 }
 
 class HFieldGet extends HFieldAccess {
   final bool isAssignable;
 
-  HFieldGet(MemberEntity element, HInstruction receiver, TypeMask type,
+  HFieldGet(FieldEntity element, HInstruction receiver, TypeMask type,
       {bool isAssignable})
       : this.isAssignable =
             (isAssignable != null) ? isAssignable : element.isAssignable,
         super(element, <HInstruction>[receiver], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
     if (this.isAssignable) {
       sideEffects.setDependsOnInstancePropertyStore();
     }
@@ skipping 20 matching lines @@
 
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 
   int typeCode() => HInstruction.FIELD_GET_TYPECODE;
   bool typeEquals(other) => other is HFieldGet;
   bool dataEquals(HFieldGet other) => element == other.element;
   String toString() => "FieldGet $element";
 }
 
 class HFieldSet extends HFieldAccess {
-  HFieldSet(MemberEntity element, HInstruction receiver, HInstruction value)
+  HFieldSet(FieldEntity element, HInstruction receiver, HInstruction value)
       : super(element, <HInstruction>[receiver, value],
             const TypeMask.nonNullEmpty()) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setChangesInstanceProperty();
   }
 
   bool canThrow() => receiver.canBeNull();
 
   HInstruction getDartReceiver(ClosedWorld closedWorld) => receiver;
   bool onlyThrowsNSM() => true;
 
   HInstruction get value => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   bool isJsStatement() => true;
   String toString() => "FieldSet $element";
 }
 
+class HGetLength extends HInstruction {
+  final bool isAssignable;
+  HGetLength(HInstruction receiver, TypeMask type, {bool this.isAssignable})
+      : super(<HInstruction>[receiver], type) {
+    assert(isAssignable != null);
+    sideEffects.clearAllSideEffects();
+    sideEffects.clearAllDependencies();
+    setUseGvn();
+    if (this.isAssignable) {
+      sideEffects.setDependsOnInstancePropertyStore();
+    }
+  }
+
+  HInstruction get receiver => inputs.single;
+
+  bool canThrow() => receiver.canBeNull();
+
+  HInstruction getDartReceiver(ClosedWorld closedWorld) => receiver;
+  bool onlyThrowsNSM() => true;
+
+  accept(HVisitor visitor) => visitor.visitGetLength(this);
+
+  int typeCode() => HInstruction.GET_LENGTH_TYPECODE;
+  bool typeEquals(other) => other is HGetLength;
+  bool dataEquals(HGetLength other) => true;
+  String toString() => "GetLength()";
+}
+
 /**
  * HReadModifyWrite is a late stage instruction for a field (property) update
  * via an assignment operation or pre- or post-increment.
  */
 class HReadModifyWrite extends HLateInstruction {
   static const ASSIGN_OP = 0;
   static const PRE_OP = 1;
   static const POST_OP = 2;
   final FieldEntity element;
   final String jsOp;
@@ skipping 1689 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }