Make constant lists immutable.

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 134 matching lines @@
     result.loopInformation = new HLoopInformation(type, result, target, labels);
     return result;
   }
 
   static HType mapConstantTypeToSsaType(Constant constant) {
     if (constant.isNull()) return HType.UNKNOWN;
     if (constant.isBool()) return HType.BOOLEAN;
     if (constant.isInt()) return HType.INTEGER;
     if (constant.isDouble()) return HType.DOUBLE;
     if (constant.isString()) return HType.STRING;
-    if (constant.isList()) return HType.ARRAY;
+    if (constant.isList()) return HType.READABLE_ARRAY;
     return HType.UNKNOWN;
   }
 
   HConstant addConstant(Constant constant) {
     HConstant result = constants[constant];
     if (result === null) {
       HType type = mapConstantTypeToSsaType(constant);
       result = new HConstant.internal(constant, type);
       entry.addAtExit(result);
       constants[constant] = result;
@@ skipping 584 matching lines @@
 
 class HType {
   final int flag;
   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_ARRAY = FLAG_STRING << 1;
-  static final int FLAG_DOUBLE = FLAG_ARRAY << 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 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 ARRAY = const HType(FLAG_ARRAY);
+  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 INTEGER = const HType(FLAG_INTEGER);
   static final HType DOUBLE = const HType(FLAG_DOUBLE);
-  static final HType STRING_OR_ARRAY = const HType(FLAG_STRING | FLAG_ARRAY);
+  static final HType STRING_OR_ARRAY =
+      const HType(FLAG_STRING | FLAG_READABLE_ARRAY | FLAG_WRITEABLE_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 === ARRAY;
+  bool isArray() => (this.flag & FLAG_READABLE_ARRAY) != 0;
+  bool isMutableArray() => this === MUTABLE_ARRAY;
   bool isNumber() => (this.flag & (FLAG_INTEGER | FLAG_DOUBLE)) != 0;
-  bool isStringOrArray() => (this.flag & (FLAG_STRING | FLAG_ARRAY)) != 0;
+  bool isStringOrArray() =>
+      (this.flag & (FLAG_STRING | FLAG_READABLE_ARRAY)) != 0;
   bool isKnown() => 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 === ARRAY.flag) return ARRAY;
+    if (flag === READABLE_ARRAY.flag) return READABLE_ARRAY;
+    if (flag === MUTABLE_ARRAY.flag) return MUTABLE_ARRAY;
     if (flag === NUMBER.flag) return NUMBER;
     if (flag === STRING_OR_ARRAY.flag) return STRING_OR_ARRAY;
     assert(false);
   }
 
   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 (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 39 matching lines @@
 
   void setAllSideEffects() { flags |= ((1 << FLAG_CHANGES_COUNT) - 1); }
   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;
 
   bool isArray() => type.isArray();
+  bool isMutableArray() => type.isMutableArray();
   bool isBoolean() => type.isBoolean();
   bool isInteger() => type.isInteger();
   bool isNumber() => type.isNumber();
   bool isString() => type.isString();
   bool isTypeUnknown() => type.isUnknown();
   bool isStringOrArray() => type.isStringOrArray();
 
   // Compute the type of the instruction.
   HType computeType() => HType.UNKNOWN;
 
@@ skipping 290 matching lines @@
 
   bool isArrayConstructor() {
     // TODO(ngeoffray): This is not the right way to do the check,
     // nor the right place. We need to move it to a phase.
     return (element.isFactoryConstructor()
         && element.enclosingElement.name.slowToString() == 'List');
   }
 
   HType computeType() {
     if (isArrayConstructor()) {
-      return HType.ARRAY;
+      return HType.MUTABLE_ARRAY;
     }
     return HType.UNKNOWN;
   }
 
   bool get builtin() => isArrayConstructor();
   bool hasExpectedType() => isArrayConstructor();
 }
 
 class HInvokeSuper extends HInvokeStatic {
   HInvokeSuper(selector, inputs) : super(selector, inputs);
@@ skipping 11 matching lines @@
                      List<HInstruction> inputs)
       : super(selector, inputs);
   toString() => 'invoke interceptor: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeInterceptor(this);
 
   String get builtinJsName() {
     if (getter
         && name == const SourceString('length')
         && inputs[1].isStringOrArray()) {
       return 'length';
-    } else if (name == const SourceString('add') && inputs[1].isArray()) {
+    } else if (name == const SourceString('add')
+               && inputs[1].isMutableArray()) {
       return 'push';
     } else if (name == const SourceString('removeLast')
-               && inputs[1].isArray()) {
+               && inputs[1].isMutableArray()) {
       return 'pop';
     }
     return null;
   }
 
   HType computeType() {
     if (getter
         && name == const SourceString('length')
         && inputs[1].isStringOrArray()) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     if (input == inputs[0]) return HType.UNKNOWN;
     if (input == inputs[1] && input.isStringOrArray()) {
       if (name == const SourceString('add')
           || name == const SourceString('removeLast')) {
-        return HType.ARRAY;
+        return HType.MUTABLE_ARRAY;
       }
     }
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtinJsName != null;
 
   void prepareGvn() {
     if (builtinJsName == 'length') {
       clearAllSideEffects();
@@ skipping 756 matching lines @@
 
   int typeCode() => 26;
   bool typeEquals(other) => other is HStaticStore;
   bool dataEquals(HStaticStore other) => element == other.element;
 }
 
 class HLiteralList extends HInstruction {
   HLiteralList(inputs) : super(inputs);
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
-  HType computeType() => HType.ARRAY;
+  HType computeType() => HType.MUTABLE_ARRAY;
   bool hasExpectedType() => true;
 
   void prepareGvn() {
     assert(!hasSideEffects());
   }
 }
 
 class HIndex extends HInvokeStatic {
   HIndex(HStatic target, HInstruction receiver, HInstruction index)
       : super(Selector.INDEX, <HInstruction>[target, receiver, index]);
@@ skipping 33 matching lines @@
   toString() => 'index assign operator';
   accept(HVisitor visitor) => visitor.visitIndexAssign(this);
 
   HInstruction get receiver() => inputs[1];
   HInstruction get index() => inputs[2];
   HInstruction get value() => inputs[3];
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
-    if (input == receiver) return HType.ARRAY;
+    if (input == receiver) return HType.MUTABLE_ARRAY;
     return HType.UNKNOWN;
   }
 
-  bool get builtin() => receiver.isArray();
+  bool get builtin() => receiver.isMutableArray();
   HType computeType() => value.type;
   // This instruction does not yield a new value, so it always
   // has the expected type (void).
   bool hasExpectedType() => true;
 }
 
 class HIs extends HInstruction {
   // TODO(ahe): This should be a Type, not Element.
   final Element typeExpression;
   final bool nullOk;
@@ skipping 14 matching lines @@
 class HIfBlockInformation {
   final HIf branch;
   final SubGraph thenGraph;
   final SubGraph elseGraph;
   final HBasicBlock joinBlock;
   HIfBlockInformation(this.branch,
                       this.thenGraph,
                       this.elseGraph,
                       this.joinBlock);
 }