Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/resolution/enum_creator.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.resolution.enum_creator;
 
-import '../compiler.dart';
-import '../core_types.dart';
+import '../core_types.dart' show
+    CoreTypes;
 import '../dart_types.dart';
+import '../diagnostics/diagnostic_listener.dart' show
+    DiagnosticReporter;
 import '../elements/elements.dart';
 import '../elements/modelx.dart';
 import '../tokens/keyword.dart' show
     Keyword;
 import '../tokens/precedence.dart';
 import '../tokens/precedence_constants.dart' as Precedence;
 import '../tokens/token.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 
@@ skipping 153 matching lines @@
         null, // Type arguments.
         new NodeList(symbolToken(Precedence.OPEN_CURLY_BRACKET_INFO),
                      linkedList(entries),
                      symbolToken(Precedence.CLOSE_CURLY_BRACKET_INFO),
                      ','),
         isConst ? keywordToken('const') : null);
   }
 }
 
 class EnumCreator {
-  final Compiler compiler;
+  final DiagnosticReporter reporter;
+  final CoreTypes coreTypes;
   final EnumClassElementX enumClass;
 
-  EnumCreator(this.compiler, this.enumClass);
-
-  CoreTypes get coreTypes => compiler.coreTypes;
+  EnumCreator(this.reporter, this.coreTypes, this.enumClass);
 
   void createMembers() {
     Enum node = enumClass.node;
     InterfaceType enumType = enumClass.thisType;
     AstBuilder builder = new AstBuilder(enumClass.position.charOffset);
 
     InterfaceType intType = coreTypes.intType;
     InterfaceType stringType = coreTypes.stringType;
 
     EnumFieldElementX addInstanceMember(String name, InterfaceType type) {
       Identifier identifier = builder.identifier(name);
       VariableList variableList =
           new VariableList(builder.modifiers(isFinal: true));
       variableList.type = type;
       EnumFieldElementX variable = new EnumFieldElementX(
           identifier, enumClass, variableList, identifier);
-      enumClass.addMember(variable, compiler);
+      enumClass.addMember(variable, reporter);
       return variable;
     }
 
     EnumFieldElementX indexVariable = addInstanceMember('index', intType);
 
     VariableDefinitions indexDefinition = builder.initializingFormal('index');
 
     FunctionExpression constructorNode = builder.functionExpression(
         builder.modifiers(isConst: true),
         enumClass.name,
@@ skipping 10 matching lines @@
         indexDefinition,
         builder.identifier('index'),
         indexVariable);
 
     FunctionSignatureX constructorSignature = new FunctionSignatureX(
         requiredParameters: [indexFormal],
         requiredParameterCount: 1,
         type: new FunctionType(constructor, const VoidType(),
             <DartType>[intType]));
     constructor.functionSignatureCache = constructorSignature;
-    enumClass.addMember(constructor, compiler);
+    enumClass.addMember(constructor, reporter);
 
     List<FieldElement> enumValues = <FieldElement>[];
     VariableList variableList =
         new VariableList(builder.modifiers(isStatic: true, isConst: true));
     variableList.type = enumType;
     int index = 0;
     List<Node> valueReferences = <Node>[];
     List<LiteralMapEntry> mapEntries = <LiteralMapEntry>[];
     for (Link<Node> link = node.names.nodes;
          !link.isEmpty;
@@ skipping 11 matching lines @@
 
       Expression initializer = valueBuilder.newExpression(
           enumClass.name,
           valueBuilder.argumentList([valueBuilder.literalInt(index)]),
           isConst: true);
       SendSet definition = valueBuilder.createDefinition(name, initializer);
 
       EnumFieldElementX field = new EnumFieldElementX(
           name, enumClass, variableList, definition, initializer);
       enumValues.add(field);
-      enumClass.addMember(field, compiler);
+      enumClass.addMember(field, reporter);
       index++;
     }
 
     VariableList valuesVariableList =
         new VariableList(builder.modifiers(isStatic: true, isConst: true));
     valuesVariableList.type = coreTypes.listType(enumType);
 
     Identifier valuesIdentifier = builder.identifier('values');
     // TODO(johnniwinther): Add type argument.
     Expression initializer = builder.listLiteral(
         valueReferences, isConst: true);
 
     Node definition = builder.createDefinition(valuesIdentifier, initializer);
 
     EnumFieldElementX valuesVariable = new EnumFieldElementX(
         valuesIdentifier, enumClass, valuesVariableList,
         definition, initializer);
 
-    enumClass.addMember(valuesVariable, compiler);
+    enumClass.addMember(valuesVariable, reporter);
 
     // TODO(johnniwinther): Support return type. Note `String` might be prefixed
     // or not imported within the current library.
     FunctionExpression toStringNode = builder.functionExpression(
         Modifiers.EMPTY,
         'toString',
         builder.argumentList([]),
         builder.returnStatement(
               builder.indexGet(
                   builder.mapLiteral(mapEntries, isConst: true),
                   builder.reference(builder.identifier('index')))
             )
         );
 
     EnumMethodElementX toString = new EnumMethodElementX('toString',
         enumClass, Modifiers.EMPTY, toStringNode);
     FunctionSignatureX toStringSignature = new FunctionSignatureX(
         type: new FunctionType(toString, stringType));
     toString.functionSignatureCache = toStringSignature;
-    enumClass.addMember(toString, compiler);
+    enumClass.addMember(toString, reporter);
 
     enumClass.enumValues = enumValues;
   }
 }