Refactor ConstantExpression/ConstantConstructor to use entities.

pkg/compiler/lib/src/serialization/constant_serialization.dart

 // Copyright (c) 2015, 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.serialization.constants;
 
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../elements/resolution_types.dart';
-import '../elements/elements.dart' show FieldElement;
+import '../elements/elements.dart'
+    show ConstructorElement, FieldElement, LocalVariableElement, MethodElement;
 import '../resolution/operators.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import 'keys.dart';
 import 'serialization.dart';
 
 /// Visitor that serializes a [ConstantExpression] by encoding it into an
 /// [ObjectEncoder].
 ///
 /// This class is called from the [Serializer] when a [ConstantExpression] needs
 /// serialization. The [ObjectEncoder] ensures that any [Element],
@@ skipping 20 matching lines @@
   void visitConditional(
       ConditionalConstantExpression exp, ObjectEncoder encoder) {
     encoder.setConstant(Key.CONDITION, exp.condition);
     encoder.setConstant(Key.TRUE, exp.trueExp);
     encoder.setConstant(Key.FALSE, exp.falseExp);
   }
 
   @override
   void visitConstructed(
       ConstructedConstantExpression exp, ObjectEncoder encoder) {
-    encoder.setElement(Key.ELEMENT, exp.target);
-    encoder.setType(Key.TYPE, exp.type);
+    ConstructorElement constructor = exp.target;
+    ResolutionInterfaceType type = exp.type;
+    encoder.setElement(Key.ELEMENT, constructor);
+    encoder.setType(Key.TYPE, type);
     encoder.setStrings(Key.NAMES, exp.callStructure.namedArguments);
     encoder.setConstants(Key.ARGUMENTS, exp.arguments);
   }
 
   @override
   void visitFunction(FunctionConstantExpression exp, ObjectEncoder encoder) {
-    encoder.setElement(Key.ELEMENT, exp.element);
+    MethodElement function = exp.element;
+    encoder.setElement(Key.ELEMENT, function);
   }
 
   @override
   void visitIdentical(IdenticalConstantExpression exp, ObjectEncoder encoder) {
     encoder.setConstant(Key.LEFT, exp.left);
     encoder.setConstant(Key.RIGHT, exp.right);
   }
 
   @override
   void visitList(ListConstantExpression exp, ObjectEncoder encoder) {
-    encoder.setType(Key.TYPE, exp.type);
+    ResolutionInterfaceType type = exp.type;
+    encoder.setType(Key.TYPE, type);
     encoder.setConstants(Key.VALUES, exp.values);
   }
 
   @override
   void visitMap(MapConstantExpression exp, ObjectEncoder encoder) {
-    encoder.setType(Key.TYPE, exp.type);
+    ResolutionInterfaceType type = exp.type;
+    encoder.setType(Key.TYPE, type);
     encoder.setConstants(Key.KEYS, exp.keys);
     encoder.setConstants(Key.VALUES, exp.values);
   }
 
   @override
   void visitBool(BoolConstantExpression exp, ObjectEncoder encoder) {
     encoder.setBool(Key.VALUE, exp.primitiveValue);
   }
 
   @override
@@ skipping 17 matching lines @@
   }
 
   @override
   void visitSymbol(SymbolConstantExpression exp, ObjectEncoder encoder) {
     encoder.setString(Key.NAME, exp.name);
   }
 
   @override
   void visitType(TypeConstantExpression exp, ObjectEncoder encoder) {
     encoder.setType(Key.TYPE, exp.type);
+    encoder.setString(Key.NAME, exp.name);
   }
 
   @override
   void visitUnary(UnaryConstantExpression exp, ObjectEncoder encoder) {
     encoder.setEnum(Key.OPERATOR, exp.operator.kind);
     encoder.setConstant(Key.EXPRESSION, exp.expression);
   }
 
   @override
-  void visitVariable(VariableConstantExpression exp, ObjectEncoder encoder) {
-    encoder.setElement(Key.ELEMENT, exp.element);
+  void visitField(FieldConstantExpression exp, ObjectEncoder encoder) {
+    FieldElement field = exp.element;
+    encoder.setElement(Key.ELEMENT, field);
   }
 
   @override
+  void visitLocalVariable(
+      LocalVariableConstantExpression exp, ObjectEncoder encoder) {
+    LocalVariableElement local = exp.element;
+    encoder.setElement(Key.ELEMENT, local);
+  }
+
+  @override
   void visitPositional(PositionalArgumentReference exp, ObjectEncoder encoder) {
     encoder.setInt(Key.INDEX, exp.index);
   }
 
   @override
   void visitNamed(NamedArgumentReference exp, ObjectEncoder encoder) {
     encoder.setString(Key.NAME, exp.name);
   }
 
   @override
@@ skipping 63 matching lines @@
             decoder.getConstant(Key.DEFAULT, isOptional: true));
       case ConstantExpressionKind.CONCATENATE:
         return new ConcatenateConstantExpression(
             decoder.getConstants(Key.ARGUMENTS));
       case ConstantExpressionKind.CONDITIONAL:
         return new ConditionalConstantExpression(
             decoder.getConstant(Key.CONDITION),
             decoder.getConstant(Key.TRUE),
             decoder.getConstant(Key.FALSE));
       case ConstantExpressionKind.CONSTRUCTED:
+        ResolutionInterfaceType type = decoder.getType(Key.TYPE);
+        ConstructorElement constructor = decoder.getElement(Key.ELEMENT);
         List<String> names = decoder.getStrings(Key.NAMES, isOptional: true);
         List<ConstantExpression> arguments =
             decoder.getConstants(Key.ARGUMENTS, isOptional: true);
-        return new ConstructedConstantExpression(
-            decoder.getType(Key.TYPE),
-            decoder.getElement(Key.ELEMENT),
-            new CallStructure(arguments.length, names),
-            arguments);
+        return new ConstructedConstantExpression(type, constructor,
+            new CallStructure(arguments.length, names), arguments);
       case ConstantExpressionKind.DOUBLE:
         return new DoubleConstantExpression(decoder.getDouble(Key.VALUE));
       case ConstantExpressionKind.ERRONEOUS:
         break;
       case ConstantExpressionKind.FUNCTION:
-        return new FunctionConstantExpression(decoder.getElement(Key.ELEMENT));
+        MethodElement function = decoder.getElement(Key.ELEMENT);
+        return new FunctionConstantExpression(function, function.type);
       case ConstantExpressionKind.IDENTICAL:
         return new IdenticalConstantExpression(
             decoder.getConstant(Key.LEFT), decoder.getConstant(Key.RIGHT));
       case ConstantExpressionKind.INT:
         return new IntConstantExpression(decoder.getInt(Key.VALUE));
       case ConstantExpressionKind.INT_FROM_ENVIRONMENT:
         return new IntFromEnvironmentConstantExpression(
             decoder.getConstant(Key.NAME),
             decoder.getConstant(Key.DEFAULT, isOptional: true));
       case ConstantExpressionKind.LIST:
-        return new ListConstantExpression(decoder.getType(Key.TYPE),
-            decoder.getConstants(Key.VALUES, isOptional: true));
+        ResolutionInterfaceType type = decoder.getType(Key.TYPE);
+        return new ListConstantExpression(
+            type, decoder.getConstants(Key.VALUES, isOptional: true));
       case ConstantExpressionKind.MAP:
+        ResolutionInterfaceType type = decoder.getType(Key.TYPE);
         return new MapConstantExpression(
-            decoder.getType(Key.TYPE),
+            type,
             decoder.getConstants(Key.KEYS, isOptional: true),
             decoder.getConstants(Key.VALUES, isOptional: true));
       case ConstantExpressionKind.NULL:
         return new NullConstantExpression();
       case ConstantExpressionKind.STRING:
         return new StringConstantExpression(decoder.getString(Key.VALUE));
       case ConstantExpressionKind.STRING_FROM_ENVIRONMENT:
         return new StringFromEnvironmentConstantExpression(
             decoder.getConstant(Key.NAME),
             decoder.getConstant(Key.DEFAULT, isOptional: true));
       case ConstantExpressionKind.STRING_LENGTH:
         return new StringLengthConstantExpression(
             decoder.getConstant(Key.EXPRESSION));
       case ConstantExpressionKind.SYMBOL:
         return new SymbolConstantExpression(decoder.getString(Key.NAME));
       case ConstantExpressionKind.TYPE:
-        return new TypeConstantExpression(decoder.getType(Key.TYPE));
+        return new TypeConstantExpression(
+            decoder.getType(Key.TYPE), decoder.getString(Key.NAME));
       case ConstantExpressionKind.UNARY:
         UnaryOperator operator = UnaryOperator
             .fromKind(decoder.getEnum(Key.OPERATOR, UnaryOperatorKind.values));
         return new UnaryConstantExpression(
             operator, decoder.getConstant(Key.EXPRESSION));
-      case ConstantExpressionKind.VARIABLE:
-        return new VariableConstantExpression(decoder.getElement(Key.ELEMENT));
+      case ConstantExpressionKind.FIELD:
+        FieldElement field = decoder.getElement(Key.ELEMENT);
+        return new FieldConstantExpression(field);
+      case ConstantExpressionKind.LOCAL_VARIABLE:
+        LocalVariableElement local = decoder.getElement(Key.ELEMENT);
+        return new LocalVariableConstantExpression(local);
 
       case ConstantExpressionKind.POSITIONAL_REFERENCE:
         return new PositionalArgumentReference(decoder.getInt(Key.INDEX));
       case ConstantExpressionKind.NAMED_REFERENCE:
         return new NamedArgumentReference(decoder.getString(Key.NAME));
       case ConstantExpressionKind.DEFERRED:
         return new DeferredConstantExpression(
             decoder.getConstant(Key.EXPRESSION),
             decoder.getElement(Key.PREFIX));
       case ConstantExpressionKind.SYNTHETIC:
@@ skipping 15 matching lines @@
 
   @override
   void visit(ConstantConstructor constantConstructor, ObjectEncoder encoder) {
     encoder.setEnum(Key.KIND, constantConstructor.kind);
     constantConstructor.accept(this, encoder);
   }
 
   @override
   void visitGenerative(
       GenerativeConstantConstructor constructor, ObjectEncoder encoder) {
-    encoder.setType(Key.TYPE, constructor.type);
+    ResolutionInterfaceType type = constructor.type;
+    encoder.setType(Key.TYPE, type);
     MapEncoder defaults = encoder.createMap(Key.DEFAULTS);
     constructor.defaultValues.forEach((key, e) {
       defaults.setConstant('$key', e);
     });
     ListEncoder fields = encoder.createList(Key.FIELDS);
     constructor.fieldMap.forEach((FieldElement f, ConstantExpression e) {
       ObjectEncoder fieldSerializer = fields.createObject();
       fieldSerializer.setElement(Key.FIELD, f);
       fieldSerializer.setConstant(Key.CONSTANT, e);
     });
@@ skipping 72 matching lines @@
       }
       return fieldMap;
     }
 
     ConstructedConstantExpression readConstructorInvocation() {
       return decoder.getConstant(Key.CONSTRUCTOR, isOptional: true);
     }
 
     switch (kind) {
       case ConstantConstructorKind.GENERATIVE:
-        return new GenerativeConstantConstructor(readType(), readDefaults(),
-            readFields(), readConstructorInvocation());
+        ResolutionInterfaceType type = readType();
+        return new GenerativeConstantConstructor(
+            type, readDefaults(), readFields(), readConstructorInvocation());
       case ConstantConstructorKind.REDIRECTING_GENERATIVE:
         return new RedirectingGenerativeConstantConstructor(
             readDefaults(), readConstructorInvocation());
       case ConstantConstructorKind.REDIRECTING_FACTORY:
         return new RedirectingFactoryConstantConstructor(
             readConstructorInvocation());
     }
   }
 }