Change switch to give errors when cases don't follow the newest syntax.

lib/compiler/implementation/compile_time_constants.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.
 
 class Constant implements Hashable {
   const Constant();
 
   bool isNull() => false;
   bool isBool() => false;
   bool isTrue() => false;
   bool isFalse() => false;
   bool isInt() => false;
   bool isDouble() => false;
   bool isNum() => false;
   bool isString() => false;
   bool isList() => false;
   bool isMap() => false;
   bool isConstructedObject() => false;
   bool isFunction() => false;
   /** Returns true if the constant is null, a bool, a number or a string. */
   bool isPrimitive() => false;
   /** Returns true if the constant is a list, a map or a constructed object. */
   bool isObject() => false;
 
   bool isNaN() => false;
 
+  abstract bool isSameType(Constant constant);

[ngeoffray, 2012/08/30 07:29:13]

I'd prefer having something consistant with what we have with HType and Element:
a computeType(compiler) method that returns the type of the constant.

[Lasse Reichstein Nielsen, 2012/08/30 10:54:25]

Seems reasonable if there is a simple way to get a Type corresponding to the
primitive types.

[ngeoffray, 2012/08/30 11:07:13]

The Dart "primitive" types? compiler.boolClass.computeType(compiler);

[Lasse Reichstein Nielsen, 2012/09/03 09:12:56]

Done.

+
   abstract void _writeJsCode(CodeBuffer buffer, ConstantHandler handler);
   /**
     * Unless the constant can be emitted multiple times (as for numbers and
     * strings) adds its canonical name to the buffer.
     */
   abstract void _writeCanonicalizedJsCode(CodeBuffer buffer,
                                           ConstantHandler handler);
   abstract List<Constant> getDependencies();
 }
 
@@ skipping 50 matching lines @@
 }
 
 class NullConstant extends PrimitiveConstant {
   /** The value a Dart null is compiled to in JavaScript. */
   static const String JsNull = "null";
 
   factory NullConstant() => const NullConstant._internal();
   const NullConstant._internal();
   bool isNull() => true;
   get value => null;
+  bool isSameType(Constant constant) => constant.isNull();
 
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
     buffer.add(JsNull);
   }
 
   // The magic constant has no meaning. It is just a random value.
   int hashCode() => 785965825;
   DartString toDartString() => const LiteralDartString("null");
 }
 
@@ skipping 18 matching lines @@
       case 8: return const IntConstant._internal(8);
       case 9: return const IntConstant._internal(9);
       case 10: return const IntConstant._internal(10);
       case -1: return const IntConstant._internal(-1);
       case -2: return const IntConstant._internal(-2);
       default: return new IntConstant._internal(value);
     }
   }
   const IntConstant._internal(this.value);
   bool isInt() => true;
+  bool isSameType(Constant constant) => constant.isInt();
 
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
     buffer.add("$value");
   }
 
   // We have to override the equality operator so that ints and doubles are
   // treated as separate constants.
   // The is [:!IntConstant:] check at the beginning of the function makes sure
   // that we compare only equal to integer constants.
   bool operator ==(var other) {
@@ skipping 19 matching lines @@
       return const DoubleConstant._internal(0.0);
     } else if (value == 1.0) {
       return const DoubleConstant._internal(1.0);
     } else {
       return new DoubleConstant._internal(value);
     }
   }
   const DoubleConstant._internal(this.value);
   bool isDouble() => true;
   bool isNaN() => value.isNaN();
+  bool isSameType(Constant constant) => constant.isDouble();
 
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
     if (value.isNaN()) {
       buffer.add("(0/0)");
     } else if (value == double.INFINITY) {
       buffer.add("(1/0)");
     } else if (value == -double.INFINITY) {
       buffer.add("(-1/0)");
     } else {
       buffer.add("$value");
@@ skipping 16 matching lines @@
   int hashCode() => value.hashCode();
   DartString toDartString() => new DartString.literal(value.toString());
 }
 
 class BoolConstant extends PrimitiveConstant {
   factory BoolConstant(value) {
     return value ? new TrueConstant() : new FalseConstant();
   }
   const BoolConstant._internal();
   bool isBool() => true;
+  bool isSameType(Constant constant) => constant.isBool();
 
   BoolConstant unaryFold(String op) {
     if (op == "!") return new BoolConstant(!value);
     return null;
   }
 
   abstract BoolConstant negate();
 }
 
 class TrueConstant extends BoolConstant {
@@ skipping 41 matching lines @@
   int _hashCode;
   final Node node;
 
   StringConstant(this.value, this.node) {
     // TODO(floitsch): cache StringConstants.
     // TODO(floitsch): compute hashcode without calling toString() on the
     // DartString.
     _hashCode = value.slowToString().hashCode();
   }
   bool isString() => true;
+  bool isSameType(Constant constant) => constant.isString();
 
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
     buffer.add("'");
     ConstantHandler.writeEscapedString(value, buffer, (reason) {
       handler.compiler.reportError(node, reason);
     });
     buffer.add("'");
   }
 
   bool operator ==(var other) {
     if (other is !StringConstant) return false;
     StringConstant otherString = other;
     return (_hashCode == otherString._hashCode) && (value == otherString.value);
   }
 
   int hashCode() => _hashCode;
   DartString toDartString() => value;
   int get length => value.length;
 }
 
-class ObjectConstant extends Constant {
+abstract class ObjectConstant extends Constant {
   final Type type;
 
   ObjectConstant(this.type);
   bool isObject() => true;
 
-  // TODO(1603): The class should be marked as abstract, but the VM doesn't
-  // currently allow this.
   abstract int hashCode();
 
   void _writeCanonicalizedJsCode(CodeBuffer buffer, ConstantHandler handler) {
     String name = handler.getNameForConstant(this);
     buffer.add(handler.compiler.namer.isolatePropertiesAccessForConstant(name));
   }
 }
 
 class ListConstant extends ObjectConstant {
   final List<Constant> entries;
   int _hashCode;
 
   ListConstant(Type type, this.entries) : super(type) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant input in entries) hash ^= input.hashCode();
     _hashCode = hash;
   }
   bool isList() => true;
+  bool isSameType(Constant constant) {
+    if (!constant.isList()) return false;
+    ListConstant listConstant = constant;
+    // TODO(lrn): Does this work at all?
+    return type == listConstant.type;

[floitsch, 2012/08/30 14:08:18]

I would expect this to be always true. Maybe change into an assert?

[Lasse Reichstein Nielsen, 2012/09/03 09:12:56]

It's gone now. Switched everything to having a computeType on the constant, and
ObjectConstant just returns the type.

+  }
 
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
     // TODO(floitsch): we should not need to go through the compiler to make
     // the list constant.
     buffer.add("${handler.compiler.namer.ISOLATE}.makeConstantList");
     buffer.add("([");
     for (int i = 0; i < entries.length; i++) {
       if (i != 0) buffer.add(", ");
       Constant entry = entries[i];
       handler.writeConstant(buffer, entry);
@@ skipping 43 matching lines @@
 
   MapConstant(Type type, this.keys, this.values, this.protoValue)
       : super(type) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant value in values) hash ^= value.hashCode();
     _hashCode = hash;
   }
   bool isMap() => true;
 
+  bool isSameType(Constant constant) {
+    if (!constant.isMap()) return false;
+    MapConstant mapConstant = constant;

[floitsch, 2012/08/30 14:08:18]

ditto, but no assert, since maps containing __proto__ or not will have different
type fields.

[Lasse Reichstein Nielsen, 2012/09/03 09:12:56]

Gone too.

+    return type == mapConstant.type;
+  }
+
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
 
     void writeJsMap() {
       buffer.add("{");
       int valueIndex = 0;
       for (int i = 0; i < keys.entries.length; i++) {
         StringConstant key = keys.entries[i];
         if (key.value == const LiteralDartString(PROTO_PROPERTY)) continue;
 
         if (valueIndex != 0) buffer.add(", ");
@@ skipping 78 matching lines @@
     assert(type !== null);
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant field in fields) {
       hash ^= field.hashCode();
     }
     hash ^= type.element.hashCode();
     _hashCode = hash;
   }
   bool isConstructedObject() => true;
+  bool isSameType(Constant constant) {
+    if (!constant.isConstructedObject()) return false;
+    ConstructredConstant constructedConstant = constant;
+    // TODO(lrn): Is this the entire type, including type parameters?
+    return type == constructedConstant.type;
+  }
 
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
     buffer.add("new ");
     buffer.add(handler.getJsConstructor(type.element));
     buffer.add("(");
     for (int i = 0; i < fields.length; i++) {
       if (i != 0) buffer.add(", ");
       Constant field = fields[i];
       handler.writeConstant(buffer, field);
     }
@@ skipping 721 matching lines @@
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
         fieldValue = compiler.compileVariable(field);
       }
       jsNewArguments.add(fieldValue);
     });
     return jsNewArguments;
   }
 }