Refactor ConstantExpression/ConstantConstructor to use entities.

pkg/compiler/lib/src/constants/expressions.dart

 // Copyright (c) 2014, 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.constants.expressions;
 
 import '../common.dart';
 import '../constants/constant_system.dart';
 import '../core_types.dart';
-import '../elements/resolution_types.dart';
-import '../elements/elements.dart'
-    show
-        ConstructorElement,
-        FieldElement,
-        MethodElement,
-        PrefixElement,
-        VariableElement;
+import '../elements/types.dart';
+import '../elements/entities.dart';
 import '../resolution/operators.dart';
 import '../tree/dartstring.dart' show DartString;
 import '../universe/call_structure.dart' show CallStructure;
+import 'constructors.dart';
 import 'evaluation.dart';
 import 'values.dart';
 
 enum ConstantExpressionKind {
   BINARY,
   BOOL,
   BOOL_FROM_ENVIRONMENT,
   CONCATENATE,
   CONDITIONAL,
   CONSTRUCTED,
   DEFERRED,
   DOUBLE,
   ERRONEOUS,
   FUNCTION,
+  FIELD,
   IDENTICAL,
   INT,
   INT_FROM_ENVIRONMENT,
   LIST,
   MAP,
   NULL,
   STRING,
   STRING_FROM_ENVIRONMENT,
   STRING_LENGTH,
   SYMBOL,
   SYNTHETIC,
   TYPE,
   UNARY,
-  VARIABLE,
+  LOCAL_VARIABLE,
   POSITIONAL_REFERENCE,
   NAMED_REFERENCE,
 }
 
 /// An expression that is a compile-time constant.
 ///
 /// Whereas [ConstantValue] represent a compile-time value, a
 /// [ConstantExpression] represents an expression for creating a constant.
 ///
 /// There is no one-to-one mapping between [ConstantExpression] and
@@ skipping 14 matching lines @@
   /// Substitute free variables using arguments.
   ConstantExpression apply(NormalizedArguments arguments) => this;
 
   /// Compute the [ConstantValue] for this expression using the [environment]
   /// and the [constantSystem].
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem);
 
   /// Returns the type of this constant expression, if it is independent of the
   /// environment values.
-  ResolutionDartType getKnownType(CommonElements commonElements) => null;
+  DartType getKnownType(CommonElements commonElements) => null;
 
   /// Returns a text string resembling the Dart code creating this constant.
   String toDartText() {
     ConstExpPrinter printer = new ConstExpPrinter();
     accept(printer);
     return printer.toString();
   }
 
   /// Returns a text string showing the structure of this constant.
   String toStructuredText() {
@@ skipping 135 matching lines @@
 
   @override
   int _computeHashCode() => 13 * primitiveValue.hashCode;
 
   @override
   bool _equals(BoolConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.boolType;
 }
 
 /// Integer literal constant.
 class IntConstantExpression extends PrimitiveConstantExpression {
   final int primitiveValue;
 
   IntConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.INT;
@@ skipping 15 matching lines @@
 
   @override
   int _computeHashCode() => 17 * primitiveValue.hashCode;
 
   @override
   bool _equals(IntConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.intType;
 }
 
 /// Double literal constant.
 class DoubleConstantExpression extends PrimitiveConstantExpression {
   final double primitiveValue;
 
   DoubleConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.DOUBLE;
@@ skipping 15 matching lines @@
 
   @override
   int _computeHashCode() => 19 * primitiveValue.hashCode;
 
   @override
   bool _equals(DoubleConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.doubleType;
 }
 
 /// String literal constant.
 class StringConstantExpression extends PrimitiveConstantExpression {
   final String primitiveValue;
 
   StringConstantExpression(this.primitiveValue);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.STRING;
@@ skipping 15 matching lines @@
 
   @override
   int _computeHashCode() => 23 * primitiveValue.hashCode;
 
   @override
   bool _equals(StringConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.stringType;
 }
 
 /// Null literal constant.
 class NullConstantExpression extends PrimitiveConstantExpression {
   NullConstantExpression();
 
   ConstantExpressionKind get kind => ConstantExpressionKind.NULL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
@@ skipping 13 matching lines @@
 
   get primitiveValue => null;
 
   @override
   int _computeHashCode() => 29;
 
   @override
   bool _equals(NullConstantExpression other) => true;
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.nullType;
 }
 
 /// Literal list constant.
 class ListConstantExpression extends ConstantExpression {
-  final ResolutionInterfaceType type;
+  final InterfaceType type;
   final List<ConstantExpression> values;
 
   ListConstantExpression(this.type, this.values);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.LIST;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitList(this, context);
   }
 
@@ skipping 34 matching lines @@
   bool _equals(ListConstantExpression other) {
     if (type != other.type) return false;
     if (values.length != other.values.length) return false;
     for (int i = 0; i < values.length; i++) {
       if (values[i] != other.values[i]) return false;
     }
     return true;
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) => type;
+  DartType getKnownType(CommonElements commonElements) => type;
 
   @override
   bool get isImplicit => false;
 
   @override
   bool get isPotential => values.any((e) => e.isPotential);
 }
 
 /// Literal map constant.
 class MapConstantExpression extends ConstantExpression {
-  final ResolutionInterfaceType type;
+  final InterfaceType type;
   final List<ConstantExpression> keys;
   final List<ConstantExpression> values;
 
   MapConstantExpression(this.type, this.keys, this.values);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.MAP;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitMap(this, context);
   }
@@ skipping 47 matching lines @@
     if (type != other.type) return false;
     if (values.length != other.values.length) return false;
     for (int i = 0; i < values.length; i++) {
       if (keys[i] != other.keys[i]) return false;
       if (values[i] != other.values[i]) return false;
     }
     return true;
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) => type;
+  DartType getKnownType(CommonElements commonElements) => type;
 
   @override
   bool get isImplicit => false;
 
   @override
   bool get isPotential {
     return keys.any((e) => e.isPotential) || values.any((e) => e.isPotential);
   }
 }
 
 /// Invocation of a const constructor.
 class ConstructedConstantExpression extends ConstantExpression {
-  final ResolutionInterfaceType type;
-  final ConstructorElement target;
+  final InterfaceType type;
+  final ConstructorEntity target;
   final CallStructure callStructure;
   final List<ConstantExpression> arguments;
 
   ConstructedConstantExpression(
       this.type, this.target, this.callStructure, this.arguments) {
     assert(type.element == target.enclosingClass);
     assert(!arguments.contains(null));
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.CONSTRUCTED;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConstructed(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Constructed(type=$type,constructor=$target,'
         'callStructure=$callStructure,arguments=[');
     String delimiter = '';
     for (ConstantExpression value in arguments) {
       sb.write(delimiter);
       value._createStructuredText(sb);
       delimiter = ',';
     }
     sb.write('])');
   }
 
-  Map<FieldElement, ConstantExpression> computeInstanceFields() {
-    assert(invariant(target, target.constantConstructor != null,
+  Map<FieldEntity, ConstantExpression> computeInstanceFields(
+      Environment environment) {
+    ConstantConstructor constantConstructor =
+        environment.getConstructorConstant(target);
+    assert(invariant(target, constantConstructor != null,
         message: "No constant constructor computed for $target."));
-    return target.constantConstructor
-        .computeInstanceFields(arguments, callStructure);
+    return constantConstructor.computeInstanceFields(
+        environment, arguments, callStructure);
   }
 
-  ResolutionInterfaceType computeInstanceType() {
-    return target.constantConstructor.computeInstanceType(type);
+  InterfaceType computeInstanceType(Environment environment) {
+    return environment
+        .getConstructorConstant(target)
+        .computeInstanceType(environment, type);
   }
 
   ConstructedConstantExpression apply(NormalizedArguments arguments) {
     return new ConstructedConstantExpression(type, target, callStructure,
         this.arguments.map((a) => a.apply(arguments)).toList());
   }
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
-    Map<FieldElement, ConstantValue> fieldValues =
-        <FieldElement, ConstantValue>{};
-    computeInstanceFields()
-        .forEach((FieldElement field, ConstantExpression constant) {
+    Map<FieldEntity, ConstantValue> fieldValues =
+        <FieldEntity, ConstantValue>{};
+    computeInstanceFields(environment)
+        .forEach((FieldEntity field, ConstantExpression constant) {
       fieldValues[field] = constant.evaluate(environment, constantSystem);
     });
-    return new ConstructedConstantValue(computeInstanceType(), fieldValues);
+    return new ConstructedConstantValue(
+        computeInstanceType(environment), fieldValues);
   }
 
   @override
   int _computeHashCode() {
     int hashCode =
         13 * type.hashCode + 17 * target.hashCode + 19 * callStructure.hashCode;
     for (ConstantExpression value in arguments) {
       hashCode ^= 23 * value.hashCode;
     }
     return hashCode;
@@ skipping 88 matching lines @@
   @override
   bool _equals(ConcatenateConstantExpression other) {
     if (expressions.length != other.expressions.length) return false;
     for (int i = 0; i < expressions.length; i++) {
       if (expressions[i] != other.expressions[i]) return false;
     }
     return true;
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.stringType;
 
   @override
   bool get isPotential {
     return expressions.any((e) => e.isPotential);
   }
 }
 
 /// Symbol literal.
 class SymbolConstantExpression extends ConstantExpression {
@@ skipping 20 matching lines @@
     return name == other.name;
   }
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createSymbol(environment.compiler, name);
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.symbolType;
 }
 
 /// Type literal.
 class TypeConstantExpression extends ConstantExpression {
-  /// Either [ResolutionDynamicType] or a raw [GenericType].
-  final ResolutionDartType type;
+  /// Either [DynamicType] or a raw [GenericType].
+  final DartType type;
+  final String name;
 
-  TypeConstantExpression(this.type) {
-    assert(type is GenericType || type is ResolutionDynamicType);
+  TypeConstantExpression(this.type, this.name) {
+    assert(type.isInterfaceType ||
+        type.isTypedef ||
+        type.isFunctionType ||
+        type.isDynamic);
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.TYPE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitType(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Type(type=$type)');
   }
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
     return constantSystem.createType(environment.compiler, type);
   }
 
   @override
   int _computeHashCode() => 13 * type.hashCode;
 
   @override
   bool _equals(TypeConstantExpression other) {
     return type == other.type;
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.typeType;
 }
 
-/// Reference to a constant local, top-level, or static variable.
-class VariableConstantExpression extends ConstantExpression {
-  final VariableElement element;
+/// Reference to a constant top-level or static field.
+class FieldConstantExpression extends ConstantExpression {
+  final FieldEntity element;
 
-  VariableConstantExpression(this.element);
+  FieldConstantExpression(this.element);
 
-  ConstantExpressionKind get kind => ConstantExpressionKind.VARIABLE;
+  ConstantExpressionKind get kind => ConstantExpressionKind.FIELD;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
-    return visitor.visitVariable(this, context);
+    return visitor.visitField(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
-    sb.write('Variable(element=$element)');
+    sb.write('Field(element=$element)');
   }
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
-    return element.constant.evaluate(environment, constantSystem);
+    ConstantExpression constant = environment.getFieldConstant(element);
+    return constant.evaluate(environment, constantSystem);
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
-  bool _equals(VariableConstantExpression other) {
+  bool _equals(FieldConstantExpression other) {
+    return element == other.element;
+  }
+}
+
+/// Reference to a constant local variable.
+class LocalVariableConstantExpression extends ConstantExpression {
+  final Local element;
+
+  LocalVariableConstantExpression(this.element);
+
+  ConstantExpressionKind get kind => ConstantExpressionKind.LOCAL_VARIABLE;
+
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitLocalVariable(this, context);
+  }
+
+  @override
+  void _createStructuredText(StringBuffer sb) {
+    sb.write('LocalVariable(element=$element)');
+  }
+
+  @override
+  ConstantValue evaluate(
+      Environment environment, ConstantSystem constantSystem) {
+    ConstantExpression constant = environment.getLocalConstant(element);
+    return constant.evaluate(environment, constantSystem);
+  }
+
+  @override
+  int _computeHashCode() => 13 * element.hashCode;
+
+  @override
+  bool _equals(LocalVariableConstantExpression other) {
     return element == other.element;
   }
 }
 
 /// Reference to a top-level or static function.
 class FunctionConstantExpression extends ConstantExpression {
-  final MethodElement element;
+  final FunctionEntity element;
+  final FunctionType type;
 
-  FunctionConstantExpression(this.element);
+  FunctionConstantExpression(this.element, this.type);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.FUNCTION;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitFunction(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Function(element=$element)');
   }
 
   @override
   ConstantValue evaluate(
       Environment environment, ConstantSystem constantSystem) {
-    return new FunctionConstantValue(element, element.type);
+    return new FunctionConstantValue(element, type);
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(FunctionConstantExpression other) {
     return element == other.element;
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.functionType;
 }
 
 /// A constant binary expression like `a * b`.
 class BinaryConstantExpression extends ConstantExpression {
   final ConstantExpression left;
   final BinaryOperator operator;
   final ConstantExpression right;
 
   BinaryConstantExpression(this.left, this.operator, this.right) {
@@ skipping 30 matching lines @@
             .lookupBinary(operator)
             .fold(leftValue, rightValue);
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new BinaryConstantExpression(
         left.apply(arguments), operator, right.apply(arguments));
   }
 
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) {
-    ResolutionDartType knownLeftType = left.getKnownType(commonElements);
-    ResolutionDartType knownRightType = right.getKnownType(commonElements);
+  InterfaceType getKnownType(CommonElements commonElements) {
+    DartType knownLeftType = left.getKnownType(commonElements);
+    DartType knownRightType = right.getKnownType(commonElements);
     switch (operator.kind) {
       case BinaryOperatorKind.EQ:
       case BinaryOperatorKind.NOT_EQ:
       case BinaryOperatorKind.LOGICAL_AND:
       case BinaryOperatorKind.LOGICAL_OR:
       case BinaryOperatorKind.GT:
       case BinaryOperatorKind.LT:
       case BinaryOperatorKind.GTEQ:
       case BinaryOperatorKind.LTEQ:
         return commonElements.boolType;
@@ skipping 119 matching lines @@
   int _computeHashCode() {
     return 17 * left.hashCode + 19 * right.hashCode;
   }
 
   @override
   bool _equals(IdenticalConstantExpression other) {
     return left == other.left && right == other.right;
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.boolType;
 
   @override
   bool get isPotential {
     return left.isPotential || right.isPotential;
   }
 }
 
 /// A unary constant expression like `-a`.
 class UnaryConstantExpression extends ConstantExpression {
@@ skipping 35 matching lines @@
   int _computeHashCode() {
     return 13 * operator.hashCode + 17 * expression.hashCode;
   }
 
   @override
   bool _equals(UnaryConstantExpression other) {
     return operator == other.operator && expression == other.expression;
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) {
+  DartType getKnownType(CommonElements commonElements) {
     return expression.getKnownType(commonElements);
   }
 
   @override
   bool get isPotential {
     return expression.isPotential;
   }
 
   static const Map<UnaryOperatorKind, int> PRECEDENCE_MAP = const {
     UnaryOperatorKind.NOT: 14,
@@ skipping 42 matching lines @@
   int _computeHashCode() {
     return 23 * expression.hashCode;
   }
 
   @override
   bool _equals(StringLengthConstantExpression other) {
     return expression == other.expression;
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.intType;
 
   @override
   bool get isPotential {
     return expression.isPotential;
   }
 }
 
 /// A constant conditional expression like `a ? b : c`.
 class ConditionalConstantExpression extends ConstantExpression {
@@ skipping 51 matching lines @@
     if (conditionValue.isTrue) {
       return trueValue;
     } else if (conditionValue.isFalse) {
       return falseValue;
     } else {
       return new NonConstantValue();
     }
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) {
-    ResolutionDartType trueType = trueExp.getKnownType(commonElements);
-    ResolutionDartType falseType = falseExp.getKnownType(commonElements);
+  DartType getKnownType(CommonElements commonElements) {
+    DartType trueType = trueExp.getKnownType(commonElements);
+    DartType falseType = falseExp.getKnownType(commonElements);
     if (trueType == falseType) {
       return trueType;
     }
     return null;
   }
 
   @override
   bool get isPotential {
     return condition.isPotential || trueExp.isPotential || falseExp.isPotential;
   }
@@ skipping 158 matching lines @@
       return defaultConstantValue;
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new BoolFromEnvironmentConstantExpression(name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.boolType;
 }
 
 /// A `const int.fromEnvironment` constant.
 class IntFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
   IntFromEnvironmentConstantExpression(
       ConstantExpression name, ConstantExpression defaultValue)
       : super(name, defaultValue);
 
@@ skipping 45 matching lines @@
       return constantSystem.createInt(value);
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new IntFromEnvironmentConstantExpression(name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.intType;
 }
 
 /// A `const String.fromEnvironment` constant.
 class StringFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
   StringFromEnvironmentConstantExpression(
       ConstantExpression name, ConstantExpression defaultValue)
       : super(name, defaultValue);
 
@@ skipping 41 matching lines @@
       return constantSystem.createString(new DartString.literal(text));
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new StringFromEnvironmentConstantExpression(name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 
   @override
-  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
+  InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.stringType;
 }
 
 /// A constant expression referenced with a deferred prefix.
 /// For example `lib.C`.
 class DeferredConstantExpression extends ConstantExpression {
   final ConstantExpression expression;
-  final PrefixElement prefix;
+  final Entity prefix;
 
   DeferredConstantExpression(this.expression, this.prefix);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.DEFERRED;
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Deferred(prefix=$prefix,expression=');
     expression._createStructuredText(sb);
     sb.write(')');
@@ skipping 42 matching lines @@
   R visitInt(IntConstantExpression exp, A context);
   R visitDouble(DoubleConstantExpression exp, A context);
   R visitString(StringConstantExpression exp, A context);
   R visitNull(NullConstantExpression exp, A context);
   R visitList(ListConstantExpression exp, A context);
   R visitMap(MapConstantExpression exp, A context);
   R visitConstructed(ConstructedConstantExpression exp, A context);
   R visitConcatenate(ConcatenateConstantExpression exp, A context);
   R visitSymbol(SymbolConstantExpression exp, A context);
   R visitType(TypeConstantExpression exp, A context);
-  R visitVariable(VariableConstantExpression exp, A context);
+  R visitLocalVariable(LocalVariableConstantExpression exp, A context);
+  R visitField(FieldConstantExpression exp, A context);
   R visitFunction(FunctionConstantExpression exp, A context);
   R visitBinary(BinaryConstantExpression exp, A context);
   R visitIdentical(IdenticalConstantExpression exp, A context);
   R visitUnary(UnaryConstantExpression exp, A context);
   R visitStringLength(StringLengthConstantExpression exp, A context);
   R visitConditional(ConditionalConstantExpression exp, A context);
   R visitBoolFromEnvironment(
       BoolFromEnvironmentConstantExpression exp, A context);
   R visitIntFromEnvironment(
       IntFromEnvironmentConstantExpression exp, A context);
@@ skipping 13 matching lines @@
     if (child.precedence < parent.precedence ||
         !leftAssociative && child.precedence == parent.precedence) {
       sb.write('(');
       child.accept(this);
       sb.write(')');
     } else {
       child.accept(this);
     }
   }
 
-  void writeTypeArguments(ResolutionInterfaceType type) {
+  void writeTypeArguments(InterfaceType type) {
     if (type.treatAsRaw) return;
     sb.write('<');
     bool needsComma = false;
-    for (ResolutionDartType value in type.typeArguments) {
+    for (DartType value in type.typeArguments) {
       if (needsComma) {
         sb.write(', ');
       }
       sb.write(value);
       needsComma = true;
     }
     sb.write('>');
   }
 
   @override
@@ skipping 113 matching lines @@
   }
 
   @override
   void visitSymbol(SymbolConstantExpression exp, [_]) {
     sb.write('#');
     sb.write(exp.name);
   }
 
   @override
   void visitType(TypeConstantExpression exp, [_]) {
-    sb.write(exp.type.name);
+    sb.write(exp.name);
   }
 
   @override
-  void visitVariable(VariableConstantExpression exp, [_]) {
+  void visitField(FieldConstantExpression exp, [_]) {
     if (exp.element.isStatic) {
       sb.write(exp.element.enclosingClass.name);
       sb.write('.');
     }
     sb.write(exp.element.name);
   }
 
   @override
+  void visitLocalVariable(LocalVariableConstantExpression exp, [_]) {
+    sb.write(exp.element.name);
+  }
+
+  @override
   void visitFunction(FunctionConstantExpression exp, [_]) {
     if (exp.element.isStatic) {
       sb.write(exp.element.enclosingClass.name);
       sb.write('.');
     }
     sb.write(exp.element.name);
   }
 
   @override
   void visitBinary(BinaryConstantExpression exp, [_]) {
@@ skipping 83 matching lines @@
     visit(exp.name);
     if (exp.defaultValue != null) {
       sb.write(', defaultValue: ');
       visit(exp.defaultValue);
     }
     sb.write(')');
   }
 
   String toString() => sb.toString();
 }