Add a fixed array type.

lib/compiler/implementation/ssa/types.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.
 
 abstract class HType {
   const HType();
 
   /**
    * Returns an [HType] that represents [type] and all types that have
    * [type] as supertype.
@@ skipping 34 matching lines @@
   static const HType CONFLICTING = const HConflictingType();
   static const HType UNKNOWN = const HUnknownType();
   static const HType BOOLEAN = const HBooleanType();
   static const HType NUMBER = const HNumberType();
   static const HType INTEGER = const HIntegerType();
   static const HType DOUBLE = const HDoubleType();
   static const HType INDEXABLE_PRIMITIVE = const HIndexablePrimitiveType();
   static const HType STRING = const HStringType();
   static const HType READABLE_ARRAY = const HReadableArrayType();
   static const HType MUTABLE_ARRAY = const HMutableArrayType();
+  static const HType FIXED_ARRAY = const HFixedArrayType();
   static const HType EXTENDABLE_ARRAY = const HExtendableArrayType();
   static const HType NULL = const HNullType();
 
   static const HType BOOLEAN_OR_NULL = const HBooleanOrNullType();
   static const HType NUMBER_OR_NULL = const HNumberOrNullType();
   static const HType INTEGER_OR_NULL = const HIntegerOrNullType();
   static const HType DOUBLE_OR_NULL = const HDoubleOrNullType();
   static const HType STRING_OR_NULL = const HStringOrNullType();
 
   bool isConflicting() => this === CONFLICTING;
   bool isUnknown() => this === UNKNOWN;
   bool isNull() => false;
   bool isBoolean() => false;
   bool isNumber() => false;
   bool isInteger() => false;
   bool isDouble() => false;
   bool isString() => false;
   bool isBooleanOrNull() => false;
   bool isNumberOrNull() => false;
   bool isIntegerOrNull() => false;
   bool isDoubleOrNull() => false;
   bool isStringOrNull() => false;
   bool isIndexablePrimitive() => false;
+  bool isFixedArray() => false;
   bool isReadableArray() => false;
   bool isMutableArray() => false;
   bool isExtendableArray() => false;
   bool isPrimitive() => false;
   bool isExact() => false;
   bool isPrimitiveOrNull() => false;
 
   bool canBePrimitive() => false;
   bool canBeNull() => false;
 
@@ skipping 514 matching lines @@
     if (other.isConflicting()) return HType.CONFLICTING;
     if (other.isUnknown()) return HType.MUTABLE_ARRAY;
     if (other.isMutableArray()) return other;
     if (other.isString()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.MUTABLE_ARRAY;
     if (other is HBoundedPotentialPrimitiveArray) return HType.MUTABLE_ARRAY;
     return HType.CONFLICTING;
   }
 }
 
+class HFixedArrayType extends HMutableArrayType {
+  const HFixedArrayType();
+  bool isFixedArray() => true;
+  String toString() => "fixed array";
+
+  HType union(HType other) {
+    if (other.isConflicting()) return HType.FIXED_ARRAY;
+    if (other.isUnknown()) return HType.UNKNOWN;
+    if (other.isFixedArray()) return HType.FIXED_ARRAY;
+    if (other.isMutableArray()) return HType.MUTABLE_ARRAY;
+    if (other.isReadableArray()) return HType.READABLE_ARRAY;
+    if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
+    if (other is HBoundedPotentialPrimitiveArray) return other;
+    return HType.UNKNOWN;
+  }
+
+  HType intersection(HType other) {
+    if (other.isConflicting()) return HType.CONFLICTING;
+    if (other.isUnknown()) return HType.FIXED_ARRAY;
+    if (other.isFixedArray()) return HType.FIXED_ARRAY;
+    if (other.isExtendableArray()) return HType.CONFLICTING;
+    if (other.isString()) return HType.CONFLICTING;
+    if (other.isIndexablePrimitive()) return HType.FIXED_ARRAY;
+    if (other is HBoundedPotentialPrimitiveArray) return HType.FIXED_ARRAY;
+    return HType.CONFLICTING;
+  }
+}
+
 class HExtendableArrayType extends HMutableArrayType {
   const HExtendableArrayType();
   bool isExtendableArray() => true;
   String toString() => "extendable array";
 
   HType union(HType other) {
     if (other.isConflicting()) return HType.EXTENDABLE_ARRAY;
     if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isExtendableArray()) return HType.EXTENDABLE_ARRAY;
     if (other.isMutableArray()) return HType.MUTABLE_ARRAY;
     if (other.isReadableArray()) return HType.READABLE_ARRAY;
     if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
     if (other is HBoundedPotentialPrimitiveArray) return other;
     return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isConflicting()) return HType.CONFLICTING;
     if (other.isUnknown()) return HType.EXTENDABLE_ARRAY;
     if (other.isExtendableArray()) return HType.EXTENDABLE_ARRAY;
     if (other.isString()) return HType.CONFLICTING;
+    if (other.isFixedArray()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.EXTENDABLE_ARRAY;
     if (other is HBoundedPotentialPrimitiveArray) return HType.EXTENDABLE_ARRAY;
     return HType.CONFLICTING;
   }
 }
 
 class HBoundedType extends HType {
   final DartType type;
   final bool _canBeNull;
   final bool _isExact;
@@ skipping 193 matching lines @@
   operator [](HInstruction instruction) {
     HType result = _map[instruction];
     if (result == null) return instruction.guaranteedType;
     return result;
   }
 
   operator []=(HInstruction instruction, HType value) {
     _map[instruction] = value;
   }
 }