Handle use of constant constructors with default values.

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 'common.dart';
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'compiler.dart' show Compiler;
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/evaluation.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
 import 'core_types.dart' show CoreTypes;
 import 'dart_types.dart';
 import 'elements/elements.dart';
-import 'elements/modelx.dart' show FieldElementX, FunctionElementX;
+import 'elements/modelx.dart' show FieldElementX, FunctionElementX, ConstantVariableMixin;
 import 'resolution/tree_elements.dart' show TreeElements;
 import 'resolution/operators.dart';
 import 'tree/tree.dart';
 import 'util/util.dart' show Link;
 import 'universe/call_structure.dart' show CallStructure;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
 /// initializers.
 abstract class ConstantEnvironment {
   /// The [ConstantSystem] used by this environment.
@@ skipping 150 matching lines @@
 
   /// Compile [element] into a constant expression. If [isConst] is true,
   /// then [element] is a constant variable. If [checkType] is true, then
   /// report an error if [element] does not typecheck.
   ConstantExpression internalCompileVariable(
       VariableElement element, bool isConst, bool checkType) {
     if (initialVariableValues.containsKey(element.declaration)) {
       ConstantExpression result = initialVariableValues[element.declaration];
       return result;
     }
+    if (element.hasConstant) {
+      if (element.constant != null) {
+        evaluate(element.constant);

[Siggi Cherem (dart-lang), 2016/05/19 16:46:45]

could this add more evaluations than what we had in the past? (I mean, can this
do something similar to the issue we discovered with deferred libraries a couple
weeks ago?)

[Johnni Winther, 2016/05/20 11:02:13]

I'll put it behind a test for deserialization.

[Siggi Cherem (dart-lang), 2016/05/20 21:08:02]

Not sure I follow why it is needed then. I would expect that we should have no
semantic difference depending on where the element comes from.

Or are we guaranteed that evaluation already happened here for non-serialized
constants? Can we assert that the expression has already been evaluated in that
case?

Overall, I'd like to get to a point that, other than the loader, nothing else in
the compiler needs to know whether an element or constant came from sources or
deserialization.

[Johnni Winther, 2016/05/23 07:54:41]

Yes. Will add an assertion.
 
Me too. I just want to tackle this issue on its own.

+      }
+      return element.constant;
+    }
     AstElement currentElement = element.analyzableElement;
-    return reporter.withCurrentElement(currentElement, () {
+    return reporter.withCurrentElement(element, () {
       // TODO(johnniwinther): Avoid this eager analysis.
       compiler.resolution.ensureResolved(currentElement.declaration);
 
       ConstantExpression constant = compileVariableWithDefinitions(
           element, currentElement.resolvedAst.elements,
           isConst: isConst, checkType: checkType);
       return constant;
     });
   }
 
   /**
    * Returns the a compile-time constant if the variable could be compiled
    * eagerly. If the variable needs to be initialized lazily returns `null`.
    * If the variable is `const` but cannot be compiled eagerly reports an
    * error.
    */
   ConstantExpression compileVariableWithDefinitions(
-      VariableElement element, TreeElements definitions,
+      ConstantVariableMixin element, TreeElements definitions,
       {bool isConst: false, bool checkType: true}) {
     Node node = element.node;
     if (pendingVariables.contains(element)) {
       if (isConst) {
         reporter.reportErrorMessage(
             node, MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS);
         ConstantExpression expression = new ErroneousConstantExpression();
         constantValueMap[expression] = constantSystem.createNull();
         return expression;
       }
@@ skipping 35 matching lines @@
             } else {
               // If the field cannot be lazily initialized, we will throw
               // the exception at runtime.
               expression = null;
             }
           }
         }
       }
     }
     if (expression != null) {
+      element.constant = expression;
       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) {
@@ skipping 998 matching lines @@
     });
   }
 
   /// Builds a normalized list of the constant values for each field in the
   /// inheritance chain of [classElement].
   Map<FieldElement, AstConstant> buildFieldConstants(
       ClassElement classElement) {
     Map<FieldElement, AstConstant> fieldConstants =
         <FieldElement, AstConstant>{};
     classElement.implementation.forEachInstanceField(
-        (ClassElement enclosing, FieldElementX field) {
+        (ClassElement enclosing, FieldElement field) {
       AstConstant fieldValue = fieldValues[field];
       if (fieldValue == null) {
         // Use the default value.
         ConstantExpression fieldExpression =
             handler.internalCompileVariable(field, true, false);
-        field.constant = fieldExpression;
         fieldValue = new AstConstant.fromDefaultValue(
             field, fieldExpression, handler.getConstantValue(fieldExpression));
         // TODO(het): If the field value doesn't typecheck due to the type
         // variable in the constructor invocation, then report the error on the
         // invocation rather than the field.
         potentiallyCheckType(field, fieldValue);
       }
       fieldConstants[field] = fieldValue;
     }, includeSuperAndInjectedMembers: true);
     return fieldConstants;
@@ skipping 43 matching lines @@
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }