Refactor ConstantSystem

tests/compiler/dart2js/constant_expression_evaluate_test.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.constants.expressions.evaluate_test;
 
 import 'dart:async';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
+import 'package:compiler/src/common/backend_api.dart';
 import 'package:compiler/src/constants/constructors.dart';
 import 'package:compiler/src/constants/evaluation.dart';
 import 'package:compiler/src/constants/expressions.dart';
 import 'package:compiler/src/constants/values.dart';
 import 'package:compiler/src/constant_system_dart.dart';
 import 'package:compiler/src/compiler.dart';
+import 'package:compiler/src/core_types.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import 'memory_compiler.dart';
 
 class TestData {
   /// Declarations needed for the [constants].
   final String declarations;
 
   /// Tested constants.
   final List constants;
 
   const TestData(this.declarations, this.constants);
 }
 
 class ConstantData {
   /// Source code for the constant expression.
   final String code;
 
   /// Map from environment to expected constant value as structured text.
   final Map<Map<String, String>, String> expectedValues;
 
   const ConstantData(this.code, this.expectedValues);
 }
 
 class MemoryEnvironment implements Environment {
-  final Compiler compiler;
+  final Compiler _compiler;
   final Map<String, String> env;
 
-  MemoryEnvironment(this.compiler, [this.env = const <String, String>{}]);
+  MemoryEnvironment(this._compiler, [this.env = const <String, String>{}]);
 
   @override
   String readFromEnvironment(String name) => env[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;
   }
+
+  @override
+  CommonElements get commonElements => _compiler.commonElements;
+
+  @override
+  BackendClasses get backendClasses => _compiler.backend.backendClasses;
 }
 
 const List<TestData> DATA = const [
   const TestData('', const [
     const ConstantData('null', const {const {}: 'NullConstant'}),
     const ConstantData('false', const {const {}: 'BoolConstant(false)'}),
     const ConstantData('true', const {const {}: 'BoolConstant(true)'}),
     const ConstantData('0', const {const {}: 'IntConstant(0)'}),
     const ConstantData('0.0', const {const {}: 'DoubleConstant(0.0)'}),
     const ConstantData('"foo"', const {const {}: 'StringConstant("foo")'}),
@@ skipping 202 matching lines @@
           constant.evaluate(environment, DART_CONSTANT_SYSTEM);
       String valueText = value.toStructuredText();
       Expect.equals(
           expectedText,
           valueText,
           "Unexpected value '${valueText}' for contant "
           "`${constant.toDartText()}`, expected '${expectedText}'.");
     });
   });
 }