Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/closure.dart

 // Copyright (c) 2012, 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 closureToClassMapper;
 
 import 'common/names.dart' show
     Identifiers;
 import 'common/resolution.dart' show
     Parsing,
@@ skipping 60 matching lines @@
       }
       assert(closureMappingCache[node] != null);
       return closureMappingCache[node];
     });
   }
 
   ClosureClassMap getMappingForNestedFunction(FunctionExpression node) {
     return measure(() {
       ClosureClassMap nestedClosureData = closureMappingCache[node];
       if (nestedClosureData == null) {
-        compiler.internalError(node, "No closure cache.");
+        reporter.internalError(node, "No closure cache.");
       }
       return nestedClosureData;
     });
   }
 
   void forgetElement(var closure) {
     ClosureClassElement cls;
     if (closure is ClosureFieldElement) {
       cls = closure.closureClass;
     } else if (closure is SynthesizedCallMethodElementX) {
@@ skipping 112 matching lines @@
     supertype = superclass.thisType;
     interfaces = const Link<DartType>();
     thisType = rawType = new InterfaceType(this);
     allSupertypesAndSelf =
         superclass.allSupertypesAndSelf.extendClass(thisType);
     callType = methodElement.type;
   }
 
   Iterable<ClosureFieldElement> get closureFields => _closureFields;
 
-  void addField(ClosureFieldElement field, DiagnosticListener listener) {
+  void addField(ClosureFieldElement field, DiagnosticReporter listener) {
     _closureFields.add(field);
     addMember(field, listener);
   }
 
   bool get hasNode => true;
 
   bool get isClosure => true;
 
   Token get position => node.getBeginToken();
 
@@ skipping 278 matching lines @@
 
   // The closureData of the currentFunctionElement.
   ClosureClassMap closureData;
 
   bool insideClosure = false;
 
   ClosureTranslator(this.compiler,
                     this.elements,
                     this.closureMappingCache);
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   /// Generate a unique name for the [id]th closure field, with proposed name
   /// [name].
   ///
   /// The result is used as the name of [ClosureFieldElement]s, and must
   /// therefore be unique to avoid breaking an invariant in the element model
   /// (classes cannot declare multiple fields with the same name).
   ///
   /// Also, the names should be distinct from real field names to prevent
   /// clashes with selectors for those fields.
   String getClosureVariableName(String name, int id) {
@@ skipping 12 matching lines @@
   String getBoxFieldName(int id) {
     return "_box_$id";
   }
 
   bool isCapturedVariable(Local element) {
     return _capturedVariableMapping.containsKey(element);
   }
 
   void addCapturedVariable(Node node, Local variable) {
     if (_capturedVariableMapping[variable] != null) {
-      compiler.internalError(node, 'In closure analyzer.');
+      reporter.internalError(node, 'In closure analyzer.');
     }
     _capturedVariableMapping[variable] = null;
   }
 
   void setCapturedVariableBoxField(Local variable,
       BoxFieldElement boxField) {
     assert(isCapturedVariable(variable));
     _capturedVariableMapping[variable] = boxField;
   }
 
@@ skipping 49 matching lines @@
           boxes.add(boxFieldElement.box);
         }
       });
       ClosureClassElement closureClass = data.closureClassElement;
       assert(closureClass != null ||
              (fieldCaptures.isEmpty && boxes.isEmpty));
 
       void addClosureField(Local local, String name) {
         ClosureFieldElement closureField =
             new ClosureFieldElement(name, local, closureClass);
-        closureClass.addField(closureField, compiler);
+        closureClass.addField(closureField, reporter);
         data.freeVariableMap[local] = closureField;
       }
 
       // Add the box elements first so we get the same ordering.
       // TODO(sra): What is the canonical order of multiple boxes?
       for (BoxLocal capturedElement in boxes) {
         addClosureField(capturedElement, capturedElement.name);
       }
 
       /// Comparator for locals. Position boxes before elements.
@@ skipping 369 matching lines @@
     ClosureClassElement globalizedElement = new ClosureClassElement(
         node, closureName, compiler, element);
     FunctionElement callElement =
         new SynthesizedCallMethodElementX(Identifiers.call,
                                           element,
                                           globalizedElement);
     backend.maybeMarkClosureAsNeededForReflection(
         globalizedElement, callElement, element);
     MemberElement enclosing = element.memberContext;
     enclosing.nestedClosures.add(callElement);
-    globalizedElement.addMember(callElement, compiler);
+    globalizedElement.addMember(callElement, reporter);
     globalizedElement.computeAllClassMembers(compiler);
     // The nested function's 'this' is the same as the one for the outer
     // function. It could be [null] if we are inside a static method.
     ThisLocal thisElement = closureData.thisLocal;
 
     return new ClosureClassMap(element, globalizedElement,
                                callElement, thisElement);
   }
 
   void visitInvokable(ExecutableElement element,
@@ skipping 107 matching lines @@
 
   String get name => typeVariable.name;
 
   int get hashCode => typeVariable.hashCode;
 
   bool operator ==(other) {
     if (other is! TypeVariableLocal) return false;
     return typeVariable == other.typeVariable;
   }
 }