Refactor ConstantExpression/ConstantConstructor to use entities.

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/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
+import 'constants/constructors.dart';
 import 'constants/evaluation.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
 import 'core_types.dart' show CommonElements;
 import 'elements/resolution_types.dart';
 import 'elements/elements.dart';
+import 'elements/entities.dart';
 import 'elements/modelx.dart' show ConstantVariableMixin;
 import 'resolution/operators.dart';
 import 'resolution/tree_elements.dart' show TreeElements;
 import 'tree/tree.dart';
 import 'universe/call_structure.dart' show CallStructure;
 import 'util/util.dart' show Link;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
 /// initializers.
 abstract class ConstantEnvironment {
@@ skipping 434 matching lines @@
     for (Link<Node> link = node.elements.nodes;
         !link.isEmpty;
         link = link.tail) {
       AstConstant argument = evaluateConstant(link.head);
       if (argument == null || argument.isError) {
         return argument;
       }
       argumentExpressions.add(argument.expression);
       argumentValues.add(argument.value);
     }
-    ResolutionDartType type = elements.getType(node);
+    ResolutionInterfaceType type = elements.getType(node);
     return new AstConstant(
         context,
         node,
         new ListConstantExpression(type, argumentExpressions),
         constantSystem.createList(type, argumentValues));
   }
 
   AstConstant visitLiteralMap(LiteralMap node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
@@ skipping 134 matching lines @@
     if (send == null) return false;
     return compiler.deferredLoadTask.deferredPrefixElement(send, elements) !=
         null;
   }
 
   AstConstant visitIdentifier(Identifier node) {
     Element element = elements[node];
     if (Elements.isClass(element) || Elements.isTypedef(element)) {
       TypeDeclarationElement typeDeclarationElement = element;
       ResolutionDartType type = typeDeclarationElement.rawType;
-      return new AstConstant(element, node, new TypeConstantExpression(type),
+      return new AstConstant(
+          element,
+          node,
+          new TypeConstantExpression(type, typeDeclarationElement.name),
           makeTypeConstant(type));
     }
     return signalNotCompileTimeConstant(node);
   }
 
   // TODO(floitsch): provide better error-messages.
   AstConstant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
       AstConstant result;
       if (Elements.isStaticOrTopLevelFunction(element)) {
         MethodElement function = element;
         function.computeType(resolution);
         result = new AstConstant(
             context,
             send,
-            new FunctionConstantExpression(function),
+            new FunctionConstantExpression(function, function.type),
             new FunctionConstantValue(function, function.type));
       } else if (Elements.isStaticOrTopLevelField(element)) {
         ConstantExpression elementExpression;
         if (element.isConst) {
           elementExpression = handler.compileConstant(element);
         } else if (element.isFinal && !isEvaluatingConstant) {
           elementExpression = handler.compileVariable(element);
         }
         if (elementExpression != null) {
+          FieldElement field = element;
           result = new AstConstant(
               context,
               send,
-              new VariableConstantExpression(element),
+              new FieldConstantExpression(field),
               handler.getConstantValue(elementExpression));
         }
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         assert(elements.isTypeLiteral(send));
         ResolutionDartType elementType = elements.getTypeLiteralType(send);
         result = new AstConstant(
             context,
             send,
-            new TypeConstantExpression(elementType),
+            new TypeConstantExpression(elementType, element.name),
             makeTypeConstant(elementType));
       } else if (send.receiver != null) {
         if (send.selector.asIdentifier().source == "length") {
           AstConstant left = evaluate(send.receiver);
           if (left != null && left.value.isString) {
             StringConstantValue stringConstantValue = left.value;
             DartString string = stringConstantValue.primitiveValue;
             IntConstantValue length = constantSystem.createInt(string.length);
             result = new AstConstant(context, send,
                 new StringLengthConstantExpression(left.expression), length);
           }
         }
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element) &&
           element.isVariable &&
           element.isConst) {
-        ConstantExpression variableExpression =
-            handler.compileConstant(element);
+        LocalVariableElement local = element;
+        ConstantExpression variableExpression = handler.compileConstant(local);
         if (variableExpression != null) {
           result = new AstConstant(
               context,
               send,
-              new VariableConstantExpression(element),
+              new LocalVariableConstantExpression(local),
               handler.getConstantValue(variableExpression));
         }
       }
       if (result == null) {
         return signalNotCompileTimeConstant(send);
       }
       if (isDeferredUse(send)) {
         if (isEvaluatingConstant) {
           reporter.reportErrorMessage(
               send, MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
@@ skipping 556 matching lines @@
       CallStructure callStructure, ConstructorElement targetConstructor) {
     ResolutionInterfaceType type =
         constructedType.asInstanceOf(targetConstructor.enclosingClass);
     if (compiler.serialization.isDeserialized(targetConstructor)) {
       List<ConstantExpression> arguments =
           compiledArguments.map((c) => c.expression).toList();
       ConstructedConstantExpression expression =
           new ConstructedConstantExpression(
               type, targetConstructor, callStructure, arguments);
 
-      Map<FieldElement, ConstantExpression> fields =
-          expression.computeInstanceFields();
+      Map<FieldEntity, ConstantExpression> fields =
+          expression.computeInstanceFields(new _CompilerEnvironment(compiler));
       fields.forEach((FieldElement field, ConstantExpression expression) {
         ConstantValue value = expression.evaluate(
             new _CompilerEnvironment(compiler), constantSystem);
         fieldValues[field] = new AstConstant(context, null, expression, value);
       });
     } else {
       ConstructorEvaluator evaluator =
           new ConstructorEvaluator(type, targetConstructor, handler, compiler);
       evaluator.evaluateConstructorFieldValues(compiledArguments);
       // Copy over the fieldValues from the super/redirect-constructor.
@@ skipping 168 matching lines @@
 
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
+
+  @override
+  ResolutionInterfaceType substByContext(
+      ResolutionInterfaceType base, ResolutionInterfaceType target) {
+    return base.substByContext(target);
+  }
+
+  @override
+  ConstantConstructor getConstructorConstant(ConstructorElement constructor) {
+    return constructor.constantConstructor;
+  }
+
+  @override
+  ConstantExpression getFieldConstant(FieldElement field) {
+    return field.constant;
+  }
+
+  @override
+  ConstantExpression getLocalConstant(LocalVariableElement local) {
+    return local.constant;
+  }
 }