Store constant variable initializers in elements.

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 FunctionElementX;
+import 'elements/modelx.dart' show FieldElementX, FunctionElementX;
 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.
   ConstantSystem get constantSystem;
 
   /// Returns the constant value computed for [expression].
   // TODO(johnniwinther): Support directly evaluation of [expression].
   ConstantValue getConstantValue(ConstantExpression expression);
 
   /// Returns the constant value for the initializer of [element].
+  @deprecated
   ConstantValue getConstantValueForVariable(VariableElement element);
-
-  /// Returns the constant for the initializer of [element].
-  ConstantExpression getConstantForVariable(VariableElement element);
 }
 
 /// A class that can compile and provide constants for variables, nodes and
 /// metadata.
 abstract class ConstantCompiler extends ConstantEnvironment {
   /// Compiles the compile-time constant for the initializer of [element], or
   /// reports an error if the initializer is not a compile-time constant.
   ///
   /// Depending on implementation, the constant compiler might also compute
   /// the compile-time constant for the backend interpretation of constants.
   ///
   /// The returned constant is always of the frontend interpretation.
   ConstantExpression compileConstant(VariableElement element);
 
   /// Computes the compile-time constant for the variable initializer,
   /// if possible.
-  void compileVariable(VariableElement element);
+  ConstantExpression compileVariable(VariableElement element);
 
   /// Compiles the constant for [node].
   ///
   /// Reports an error if [node] is not a compile-time constant and
   /// [enforceConst].
   ///
   /// If `!enforceConst`, then if [node] is a "runtime constant" (for example
   /// a reference to a deferred constant) it will be returned - otherwise null
   /// is returned.
   ///
@@ skipping 81 matching lines @@
   final Map<ConstantExpression, ConstantValue> constantValueMap =
       <ConstantExpression, ConstantValue>{};
 
   ConstantCompilerBase(this.compiler, this.constantSystem);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CoreTypes get coreTypes => compiler.coreTypes;
 
   @override
+  @deprecated
   ConstantValue getConstantValueForVariable(VariableElement element) {
     return getConstantValue(initialVariableValues[element.declaration]);
   }
 
-  @override
-  ConstantExpression getConstantForVariable(VariableElement element) {
-    return initialVariableValues[element.declaration];
-  }
-
   ConstantExpression compileConstant(VariableElement element) {
     return internalCompileVariable(element, true, true);
   }
 
   @override
   void evaluate(ConstantExpression constant) {
     constantValueMap.putIfAbsent(constant, () {
       return constant.evaluate(
           new _CompilerEnvironment(compiler), constantSystem);
     });
@@ skipping 1092 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, FieldElement field) {
+        (ClassElement enclosing, FieldElementX 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 49 matching lines @@
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }