Support check mode for statics.

lib/compiler/implementation/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.
 
 interface ConstantVisitor<R> {
   R visitSentinel(SentinelConstant constant);
   R visitFunction(FunctionConstant constant);
   R visitNull(NullConstant constant);
   R visitInt(IntConstant constant);
   R visitDouble(DoubleConstant constant);
@@ skipping 22 matching lines @@
   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 isSentinel() => false;
 
   bool isNaN() => false;
   bool isMinusZero() => false;
 
+  abstract DartType computeType(Compiler compiler);
+
   abstract List<Constant> getDependencies();
 
   abstract accept(ConstantVisitor);
 }
 
 class SentinelConstant extends Constant {
   const SentinelConstant();
   static final SENTINEL = const SentinelConstant();
 
   List<Constant> getDependencies() => const <Constant>[];
@@ skipping 17 matching lines @@
     if (other is !FunctionConstant) return false;
     return other.element === element;
   }
 
   String toString() => element.toString();
   List<Constant> getDependencies() => const <Constant>[];
   DartString toDartString() {
     return new DartString.literal(element.name.slowToString());
   }
 
+  DartType computeType(Compiler compiler) {
+    return compiler.functionClass.computeType(compiler);
+  }
+
   int hashCode() => (17 * element.hashCode()) & 0x7fffffff;
 
   accept(ConstantVisitor visitor) => visitor.visitFunction(this);
 }
 
 class PrimitiveConstant extends Constant {
   abstract get value;
   const PrimitiveConstant();
   bool isPrimitive() => true;
 
@@ skipping 12 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;
 
+  DartType computeType(Compiler compiler) {
+    return compiler.nullClass.computeType(compiler);
+  }
+
   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");
 
   accept(ConstantVisitor visitor) => visitor.visitNull(this);
 }
@@ skipping 20 matching lines @@
       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;
 
+  DartType computeType(Compiler compiler) {
+    return compiler.intClass.computeType(compiler);
+  }
+
   // 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) {
     if (other is !IntConstant) return false;
     IntConstant otherInt = other;
     return value == otherInt.value;
   }
 
@@ skipping 19 matching lines @@
     } else {
       return new DoubleConstant._internal(value);
     }
   }
   const DoubleConstant._internal(this.value);
   bool isDouble() => true;
   bool isNaN() => value.isNaN();
   // We need to check for the negative sign since -0.0 == 0.0.
   bool isMinusZero() => value == 0.0 && value.isNegative();
 
+  DartType computeType(Compiler compiler) {
+    return compiler.doubleClass.computeType(compiler);
+  }
+
   bool operator ==(var other) {
     if (other is !DoubleConstant) return false;
     DoubleConstant otherDouble = other;
     double otherValue = otherDouble.value;
     if (value == 0.0 && otherValue == 0.0) {
       return value.isNegative() == otherValue.isNegative();
     } else if (value.isNaN()) {
       return otherValue.isNaN();
     } else {
       return value == otherValue;
     }
   }
 
   int hashCode() => value.hashCode();
   DartString toDartString() => new DartString.literal(value.toString());
 
   accept(ConstantVisitor visitor) => visitor.visitDouble(this);
 }
 
 class BoolConstant extends PrimitiveConstant {
   factory BoolConstant(value) {
     return value ? new TrueConstant() : new FalseConstant();
   }
   const BoolConstant._internal();
   bool isBool() => true;
 
+  DartType computeType(Compiler compiler) {
+    return compiler.boolClass.computeType(compiler);
+  }
+
   abstract BoolConstant negate();
 }
 
 class TrueConstant extends BoolConstant {
   final bool value = true;
 
   factory TrueConstant() => const TrueConstant._internal();
   const TrueConstant._internal() : super._internal();
   bool isTrue() => true;
 
@@ skipping 32 matching lines @@
   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;
 
+  DartType computeType(Compiler compiler) {
+    return compiler.stringClass.computeType(compiler);
+  }
+
   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;
 
   accept(ConstantVisitor visitor) => visitor.visitString(this);
 }
 
 class ObjectConstant extends Constant {
   final DartType type;
 
   ObjectConstant(this.type);
   bool isObject() => true;
 
+  DartType computeType(Compiler compiler) => type;
+
   // TODO(1603): The class should be marked as abstract, but the VM doesn't
   // currently allow this.
   abstract int hashCode();
 }
 
 class ListConstant extends ObjectConstant {
   final List<Constant> entries;
   int _hashCode;
 
   ListConstant(DartType type, this.entries) : super(type) {
@@ skipping 108 matching lines @@
       if (fields[i] != other.fields[i]) return false;
     }
     return true;
   }
 
   int hashCode() => _hashCode;
   List<Constant> getDependencies() => fields;
 
   accept(ConstantVisitor visitor) => visitor.visitConstructed(this);
 }