Begin to compute constant expressions in resolution.

pkg/compiler/lib/src/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.
 
 library dart2js.compile_time_constant_evaluator;
 
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
@@ skipping 230 matching lines @@
     if (expression != null) {
       initialVariableValues[element.declaration] = expression;
     } else {
       assert(invariant(element, !isConst,
              message: "Variable $element does not compile to a constant."));
     }
     pendingVariables.remove(element);
     return expression;
   }
 
+  void cacheConstantValue(ConstantExpression expression, ConstantValue value) {
+    constantValueMap[expression] = value;
+  }
+
   ConstantExpression compileNodeWithDefinitions(Node node,
                                                 TreeElements definitions,
                                                 {bool isConst: true}) {
     assert(node != null);
     CompileTimeConstantEvaluator evaluator = new CompileTimeConstantEvaluator(
         this, definitions, compiler, isConst: isConst);
     AstConstant constant = evaluator.evaluate(node);
     if (constant != null) {
-      constantValueMap[constant.expression] = constant.value;
+      cacheConstantValue(constant.expression, constant.value);
       return constant.expression;
     }
     return null;
   }
 
   ConstantValue getConstantValue(ConstantExpression expression) {
     return constantValueMap[expression];
   }
 
   ConstantExpression compileNode(Node node, TreeElements elements,
@@ skipping 25 matching lines @@
       : super(compiler, const DartConstantSystem());
 
   ConstantExpression getConstantForNode(Node node, TreeElements definitions) {
     return definitions.getConstant(node);
   }
 
   ConstantExpression compileNodeWithDefinitions(Node node,
                                                 TreeElements definitions,
                                                 {bool isConst: true}) {
     ConstantExpression constant = definitions.getConstant(node);
-    if (constant != null) {
+    if (constant != null && getConstantValue(constant) != null) {
       return constant;
     }
     constant =
         super.compileNodeWithDefinitions(node, definitions, isConst: isConst);
     if (constant != null) {
       definitions.setConstant(node, constant);
     }
     return constant;
   }
 }
@@ skipping 1011 matching lines @@
           // TODO(johnniwinther): Return a [NonConstantValue] instead.
           new ErroneousConstantExpression(), new NullConstantValue());
 }
 
 // TODO(johnniwinther): Avoid the need for this hack.
 TreeElements _analyzeElementEagerly(Compiler compiler, AstElement element) {
   WorldImpact worldImpact = compiler.analyzeElement(element.declaration);
   compiler.enqueuer.resolution.applyImpact(element.declaration, worldImpact);
   return element.resolvedAst.elements;
 }