Fix performance regression on some benchmarks: add an extendable array type where push and pop can …

lib/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2011, 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 visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 660 matching lines @@
   const HType(int this.flag);
 
   static final int FLAG_CONFLICTING = 0;
   static final int FLAG_UNKNOWN = 1;
   static final int FLAG_BOOLEAN = FLAG_UNKNOWN << 1;
   static final int FLAG_INTEGER = FLAG_BOOLEAN << 1;
   static final int FLAG_STRING = FLAG_INTEGER << 1;
   static final int FLAG_READABLE_ARRAY = FLAG_STRING << 1;
   // FLAG_WRITABLE_ARRAY implies FLAG_READABLE_ARRAY.
   static final int FLAG_WRITEABLE_ARRAY = FLAG_READABLE_ARRAY << 1;
-  static final int FLAG_DOUBLE = FLAG_WRITEABLE_ARRAY << 1;
+  static final int FLAG_EXTENDABLE_ARRAY = FLAG_WRITEABLE_ARRAY << 1;
+  static final int FLAG_DOUBLE = FLAG_EXTENDABLE_ARRAY << 1;
   static final int FLAG_NON_PRIMITIVE = FLAG_DOUBLE << 1;
 
   static final HType CONFLICTING = const HType(FLAG_CONFLICTING);
   static final HType UNKNOWN = const HType(FLAG_UNKNOWN);
   static final HType BOOLEAN = const HType(FLAG_BOOLEAN);
   static final HType STRING = const HType(FLAG_STRING);
   static final HType READABLE_ARRAY = const HType(FLAG_READABLE_ARRAY);
-  static final HType MUTABLE_ARRAY =
-      const HType(FLAG_READABLE_ARRAY | FLAG_WRITEABLE_ARRAY);
+  static final HType MUTABLE_ARRAY = const HType(
+      FLAG_READABLE_ARRAY | FLAG_WRITEABLE_ARRAY);
+  static final HType EXTENDABLE_ARRAY = const HType(
+      FLAG_READABLE_ARRAY | FLAG_WRITEABLE_ARRAY | FLAG_EXTENDABLE_ARRAY);
   static final HType INTEGER = const HType(FLAG_INTEGER);
   static final HType DOUBLE = const HType(FLAG_DOUBLE);
-  static final HType STRING_OR_ARRAY =
-      const HType(FLAG_STRING | FLAG_READABLE_ARRAY | FLAG_WRITEABLE_ARRAY);
+  static final HType STRING_OR_ARRAY = const HType(
+      FLAG_STRING | FLAG_READABLE_ARRAY | FLAG_WRITEABLE_ARRAY
+      | FLAG_EXTENDABLE_ARRAY);
   static final HType NUMBER = const HType(FLAG_DOUBLE | FLAG_INTEGER);
 
   bool isConflicting() => this === CONFLICTING;
   bool isUnknown() => this === UNKNOWN;
   bool isBoolean() => this === BOOLEAN;
   bool isInteger() => this === INTEGER;
   bool isDouble() => this === DOUBLE;
   bool isString() => this === STRING;
   bool isArray() => (this.flag & FLAG_READABLE_ARRAY) != 0;
-  bool isMutableArray() => this === MUTABLE_ARRAY;
+  bool isMutableArray() => this === MUTABLE_ARRAY || this === EXTENDABLE_ARRAY;
+  bool isExtendableArray() => this === EXTENDABLE_ARRAY;
   bool isNumber() => (this.flag & (FLAG_INTEGER | FLAG_DOUBLE)) != 0;
   bool isStringOrArray() =>
       (this.flag & (FLAG_STRING | FLAG_READABLE_ARRAY)) != 0;
   bool isNonPrimitive() => this.flag === FLAG_NON_PRIMITIVE;
   /** A type is useful it is not unknown and not conflicting. */
   bool isUseful() => this !== UNKNOWN && this !== CONFLICTING;
 
   static HType getTypeFromFlag(int flag) {
     if (flag === CONFLICTING.flag) return CONFLICTING;
     if (flag === UNKNOWN.flag) return UNKNOWN;
     if (flag === BOOLEAN.flag) return BOOLEAN;
     if (flag === INTEGER.flag) return INTEGER;
     if (flag === DOUBLE.flag) return DOUBLE;
     if (flag === STRING.flag) return STRING;
     if (flag === READABLE_ARRAY.flag) return READABLE_ARRAY;
     if (flag === MUTABLE_ARRAY.flag) return MUTABLE_ARRAY;
+    if (flag === EXTENDABLE_ARRAY.flag) return EXTENDABLE_ARRAY;
     if (flag === NUMBER.flag) return NUMBER;
     if (flag === STRING_OR_ARRAY.flag) return STRING_OR_ARRAY;
     unreachable();
   }
 
   String toString() {
     if (isConflicting()) return 'conflicting';
     if (isUnknown()) return 'unknown';
     if (isBoolean()) return 'boolean';
     if (isInteger()) return 'integer';
     if (isDouble()) return 'double';
     if (isString()) return 'string';
     if (isMutableArray()) return 'mutable array';
+    if (isExtendableArray()) return 'extendable array';
     if (isArray()) return 'array';
     if (isNumber()) return 'number';
     if (isStringOrArray()) return 'string or array';
     unreachable();
   }
 
   HType combine(HType other) {
     if (isUnknown()) return other;
     if (other.isUnknown()) return this;
     return getTypeFromFlag(this.flag & other.flag);
@@ skipping 68 matching lines @@
   void clearAllSideEffects() { flags &= ~((1 << FLAG_CHANGES_COUNT) - 1); }
 
   bool useGvn() => getFlag(FLAG_USE_GVN);
   void setUseGvn() { setFlag(FLAG_USE_GVN); }
   // Does this node potentially affect control flow.
   bool isControlFlow() => false;
 
   // All isFunctions work on the propagated types.
   bool isArray() => propagatedType.isArray();
   bool isMutableArray() => propagatedType.isMutableArray();
+  bool isExtendableArray() => propagatedType.isExtendableArray();
   bool isBoolean() => propagatedType.isBoolean();
   bool isInteger() => propagatedType.isInteger();
   bool isDouble() => propagatedType.isDouble();
   bool isNumber() => propagatedType.isNumber();
   bool isString() => propagatedType.isString();
   bool isTypeUnknown() => propagatedType.isUnknown();
   bool isStringOrArray() => propagatedType.isStringOrArray();
   bool isNonPrimitive() => propagatedType.isNonPrimitive();
 
   /**
@@ skipping 372 matching lines @@
 
   bool isLengthGetterOnStringOrArray() {
     return isLengthGetter()
         && inputs[1].isStringOrArray();
   }
 
   String get builtinJsName() {
     if (isLengthGetterOnStringOrArray()) {
       return 'length';
     } else if (name == const SourceString('add')
-               && inputs[1].isMutableArray()) {
+               && inputs[1].isExtendableArray()) {
       return 'push';
     } else if (name == const SourceString('removeLast')
-               && inputs[1].isMutableArray()) {
+               && inputs[1].isExtendableArray()) {
       return 'pop';
     }
     return null;
   }
 
   HType get guaranteedType() => HType.UNKNOWN;
 
   HType get likelyType() {
     // In general a length getter or method returns an int.
     if (name == const SourceString('length')) return HType.INTEGER;
@@ skipping 1076 matching lines @@
   final bool isAnd;
   final SubExpression left;
   final SubExpression right;
   final HBasicBlock joinBlock;
   HAndOrBlockInformation(this.isAnd,
                          this.left,
                          this.right,
                          this.joinBlock);
   bool accept(HBlockInformationVisitor visitor) => visitor.visitAndOrInfo(this);
 }