Use entities in CommonElements interface.

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';
@@ skipping 218 matching lines @@
 
   @override
   int _computeHashCode() => 13 * primitiveValue.hashCode;
 
   @override
   bool _equals(BoolConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.nullType;
 }
 
 /// Literal list constant.
 class ListConstantExpression extends ConstantExpression {
   final ResolutionInterfaceType type;
   final List<ConstantExpression> values;
 
   ListConstantExpression(this.type, this.values);
 
@@ skipping 296 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
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.symbolType;
 }
 
 /// Type literal.
 class TypeConstantExpression extends ConstantExpression {
   /// Either [ResolutionDynamicType] or a raw [GenericType].
   final ResolutionDartType type;
 
   TypeConstantExpression(this.type) {
     assert(type is GenericType || type is ResolutionDynamicType);
@@ skipping 18 matching lines @@
 
   @override
   int _computeHashCode() => 13 * type.hashCode;
 
   @override
   bool _equals(TypeConstantExpression other) {
     return type == other.type;
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.typeType;
 }
 
 /// Reference to a constant local, top-level, or static variable.
 class VariableConstantExpression extends ConstantExpression {
   final VariableElement element;
 
   VariableConstantExpression(this.element);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.VARIABLE;
@@ skipping 47 matching lines @@
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(FunctionConstantExpression other) {
     return element == other.element;
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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));
   }
 
-  ResolutionDartType getKnownType(CommonElements commonElements) {
+  ResolutionInterfaceType getKnownType(CommonElements commonElements) {
     ResolutionDartType knownLeftType = left.getKnownType(commonElements);
     ResolutionDartType 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:
@@ skipping 121 matching lines @@
   int _computeHashCode() {
     return 17 * left.hashCode + 19 * right.hashCode;
   }
 
   @override
   bool _equals(IdenticalConstantExpression other) {
     return left == other.left && right == other.right;
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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 98 matching lines @@
   int _computeHashCode() {
     return 23 * expression.hashCode;
   }
 
   @override
   bool _equals(StringLengthConstantExpression other) {
     return expression == other.expression;
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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 232 matching lines @@
       return defaultConstantValue;
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new BoolFromEnvironmentConstantExpression(name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
 
   @override
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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
-  ResolutionDartType getKnownType(CommonElements commonElements) =>
+  ResolutionInterfaceType 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;
 
   DeferredConstantExpression(this.expression, this.prefix);
@@ skipping 338 matching lines @@
     visit(exp.name);
     if (exp.defaultValue != null) {
       sb.write(', defaultValue: ');
       visit(exp.defaultValue);
     }
     sb.write(')');
   }
 
   String toString() => sb.toString();
 }