Support check mode for statics.

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.
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
  */
 class ConstantHandler extends CompilerTask {
@@ skipping 107 matching lines @@
 
       SendSet assignment = node.asSendSet();
       Constant value;
       if (assignment === null) {
         // No initial value.
         value = new NullConstant();
       } else {
         Node right = assignment.arguments.head;
         value =
             compileNodeWithDefinitions(right, definitions, isConst: isConst);
+        if (compiler.enableTypeAssertions
+            && value != null
+            && element.isField()) {
+          DartType elementType = element.computeType(compiler);
+          DartType constantType = value.computeType(compiler);
+          if (!compiler.types.isSubtype(constantType, elementType)) {
+            // If the type of the constant does not implement the
+            // declared type of the variable, we make the initialization
+            // of this variable lazy so that at runtime we get the type
+            // error only if the variable is used.
+            value = null;
+          }
+        }
       }
       if (value != null) {
         initialVariableValues[element] = value;
       } else {
-        assert(!isConst);
+        assert(!isConst || compiler.enableTypeAssertions);
         lazyStatics.add(element);
       }
       pendingVariables.remove(element);
       return value;
     });
   }
 
   Constant compileNodeWithDefinitions(Node node,
                                       TreeElements definitions,
                                       [bool isConst]) {
@@ skipping 123 matching lines @@
   Constant visitLiteralList(LiteralList node) {
     if (!node.isConst())  {
       return signalNotCompileTimeConstant(node);
     }
     List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty();
          link = link.tail) {
       arguments.add(evaluateConstant(link.head));
     }
-    // TODO(floitsch): get type from somewhere.
-    DartType type = null;
+    // TODO(floitsch): get type parameters.
+    DartType type = new InterfaceType(compiler.listClass);
     Constant constant = new ListConstant(type, arguments);
     compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralMap(LiteralMap node) {
     if (!node.isConst()) {
       signalNotCompileTimeConstant(node);
       error(node);
     }
@@ skipping 16 matching lines @@
     Constant protoValue = null;
     for (StringConstant key in keys) {
       if (key.value == MapConstant.PROTO_PROPERTY) {
         protoValue = map[key];
       } else {
         values.add(map[key]);
       }
     }
     bool hasProtoKey = (protoValue !== null);
     // TODO(floitsch): this should be a List<String> type.
-    DartType keysType = null;
+    DartType keysType = new InterfaceType(compiler.listClass);
     ListConstant keysList = new ListConstant(keysType, keys);
     compiler.constantHandler.registerCompileTimeConstant(keysList);
     SourceString className = hasProtoKey
                              ? MapConstant.DART_PROTO_CLASS
                              : MapConstant.DART_CLASS;
     ClassElement classElement = compiler.jsHelperLibrary.find(className);
     classElement.ensureResolved(compiler);
     // TODO(floitsch): copy over the generic type.
     DartType type = new InterfaceType(classElement);
     compiler.enqueuer.codegen.registerInstantiatedClass(classElement);
@@ skipping 412 matching lines @@
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
         fieldValue = compiler.compileConstant(field);
       }
       jsNewArguments.add(fieldValue);
     });
     return jsNewArguments;
   }
 }