Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.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.js_emitter.full_emitter;
 
 import 'dart:convert';
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 import 'package:js_runtime/shared/embedded_names.dart' show
     JsBuiltin,
     JsGetName;
 
 import '../headers.dart';
 
 import '../js_emitter.dart' hide Emitter;
 import '../js_emitter.dart' as js_emitter show Emitter;
 
 import '../model.dart';
 import '../program_builder/program_builder.dart';
 
 import '../../common.dart';
 
 import '../../constants/values.dart';
 
 import '../../deferred_load.dart' show OutputUnit;
 
-import '../../diagnostics/messages.dart' show MessageKind;
+import '../../diagnostics/diagnostic_listener.dart' show
+    DiagnosticReporter;
+
+import '../../diagnostics/messages.dart' show
+    MessageKind;
 
 import '../../diagnostics/spannable.dart' show
     NO_LOCATION_SPANNABLE;
 
 import '../../elements/elements.dart' show
     ConstructorBodyElement,
     ElementKind,
     FieldElement,
     Name,
     ParameterElement,
@@ skipping 145 matching lines @@
         cachedClassBuilders = compiler.cacheStrategy.newMap(),
         cachedElements = compiler.cacheStrategy.newSet() {
     constantEmitter = new ConstantEmitter(
         compiler, namer, this.constantReference, constantListGenerator);
     containerBuilder.emitter = this;
     classEmitter.emitter = this;
     nsmEmitter.emitter = this;
     interceptorEmitter.emitter = this;
   }
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   List<jsAst.Node> cspPrecompiledFunctionFor(OutputUnit outputUnit) {
     return _cspPrecompiledFunctions.putIfAbsent(
         outputUnit,
         () => new List<jsAst.Node>());
   }
 
   List<jsAst.Expression> cspPrecompiledConstructorNamesFor(
       OutputUnit outputUnit) {
     return _cspPrecompiledConstructorNames.putIfAbsent(
         outputUnit,
@@ skipping 203 matching lines @@
         return jsAst.js.expressionTemplateFor("$typesAccess[#]");
 
       case JsBuiltin.createDartClosureFromNameOfStaticFunction:
         // The global-functions map contains a map from name to tear-off
         // getters.
         String functionGettersMap =
             generateEmbeddedGlobalAccessString(embeddedNames.GLOBAL_FUNCTIONS);
         return jsAst.js.expressionTemplateFor("$functionGettersMap[#]()");
 
       default:
-        compiler.internalError(NO_LOCATION_SPANNABLE,
+        reporter.internalError(NO_LOCATION_SPANNABLE,
             "Unhandled Builtin: $builtin");
         return null;
     }
   }
 
   List<jsAst.Statement> buildTrivialNsmHandlers(){
     return nsmEmitter.buildTrivialNsmHandlers();
   }
 
   jsAst.Statement buildNativeInfoHandler(
@@ skipping 118 matching lines @@
     Element element = elementOrSelector;
     if (element.isGenerativeConstructorBody) {
       return null;
     } else if (element.isClass) {
       ClassElement cls = element;
       if (cls.isUnnamedMixinApplication) return null;
       return cls.name;
     } else if (element.isTypedef) {
       return element.name;
     }
-    throw compiler.internalError(element,
+    throw reporter.internalError(element,
         'Do not know how to reflect on this $element.');
   }
 
   String namedParametersAsReflectionNames(CallStructure structure) {
     if (structure.isUnnamed) return '';
     String names = structure.getOrderedNamedArguments().join(':');
     return ':$names';
   }
 
   jsAst.Statement buildCspPrecompiledFunctionFor(
@@ skipping 17 matching lines @@
          'result': new jsAst.ArrayInitializer(
                cspPrecompiledConstructorNamesFor(outputUnit))});
     } else {
       return js.comment("Constructors are generated at runtime.");
     }
   }
 
   void assembleClass(Class cls, ClassBuilder enclosingBuilder,
                      Fragment fragment) {
     ClassElement classElement = cls.element;
-    compiler.withCurrentElement(classElement, () {
+    reporter.withCurrentElement(classElement, () {
       if (compiler.hasIncrementalSupport) {
         ClassBuilder cachedBuilder =
             cachedClassBuilders.putIfAbsent(classElement, () {
               ClassBuilder builder =
                   new ClassBuilder.forClass(classElement, namer);
               classEmitter.emitClass(cls, builder, fragment);
               return builder;
             });
         invariant(classElement, cachedBuilder.fields.isEmpty);
         invariant(classElement, cachedBuilder.superName == null);
@@ skipping 32 matching lines @@
 
     bool inMainUnit = (outputUnit == compiler.deferredLoadTask.mainOutputUnit);
     JavaScriptConstantCompiler handler = backend.constants;
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
     Iterable<Element> fields = outputStaticNonFinalFieldLists[outputUnit];
     // If the outputUnit does not contain any static non-final fields, then
     // [fields] is `null`.
     if (fields != null) {
       for (Element element in fields) {
-        compiler.withCurrentElement(element, () {
+        reporter.withCurrentElement(element, () {
           ConstantValue constant = handler.getInitialValueFor(element);
           parts.add(buildInitialization(element, constantReference(constant)));
         });
       }
     }
 
     if (inMainUnit && outputStaticNonFinalFieldLists.length > 1) {
       // In the main output-unit we output a stub initializer for deferred
       // variables, so that `isolateProperties` stays a fast object.
       outputStaticNonFinalFieldLists.forEach(
           (OutputUnit fieldsOutputUnit, Iterable<VariableElement> fields) {
         if (fieldsOutputUnit == outputUnit) return;  // Skip the main unit.
         for (Element element in fields) {
-          compiler.withCurrentElement(element, () {
+          reporter.withCurrentElement(element, () {
             parts.add(buildInitialization(element, jsAst.number(0)));
           });
         }
       });
     }
 
     return new jsAst.Block(parts);
   }
 
   jsAst.Statement buildLazilyInitializedStaticFields() {
@@ skipping 220 matching lines @@
     return js.statement('''
       function init() {
         $isolatePropertiesName = Object.create(null);
         #allClasses = map();
         #getTypeFromName = function(name) {return #allClasses[name];};
         #interceptorsByTag = map();
         #leafTags = map();
         #finishedClasses = map();
 
         if (#needsLazyInitializer) {
-          // [staticName] is only provided in non-minified mode. If missing, we 
-          // fall back to [fieldName]. Likewise, [prototype] is optional and 
+          // [staticName] is only provided in non-minified mode. If missing, we
+          // fall back to [fieldName]. Likewise, [prototype] is optional and
           // defaults to the isolateProperties object.
           $lazyInitializerName = function (fieldName, getterName, lazyValue,
                                            staticName, prototype) {
             if (!#lazies) #lazies = Object.create(null);
             #lazies[fieldName] = getterName;
 
             // 'prototype' will be undefined except if we are doing an update
             // during incremental compilation. In this case we put the lazy
             // field directly on the isolate instead of the isolateProperties.
             prototype = prototype || $isolatePropertiesName;
@@ skipping 410 matching lines @@
     return new jsAst.Block(parts);
   }
 
   void checkEverythingEmitted(Iterable<Element> elements) {
     List<Element> pendingStatics;
     if (!compiler.hasIncrementalSupport) {
       pendingStatics =
           Elements.sortedByPosition(elements.where((e) => !e.isLibrary));
 
       pendingStatics.forEach((element) =>
-          compiler.reportInfo(
+          reporter.reportInfo(
               element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
     }
 
     if (pendingStatics != null && !pendingStatics.isEmpty) {
-      compiler.internalError(pendingStatics.first,
+      reporter.internalError(pendingStatics.first,
           'Pending statics (see above).');
     }
   }
 
   void assembleLibrary(Library library, Fragment fragment) {
     LibraryElement libraryElement = library.element;
 
     assembleStaticFunctions(library.statics, fragment);
 
     ClassBuilder libraryBuilder =
@@ skipping 454 matching lines @@
     Map<OutputUnit, String> deferredLoadHashes =
         emitDeferredOutputUnits(deferredParts);
 
     deferredHashTokens.forEach((OutputUnit key, _DeferredOutputUnitHash token) {
       token.setHash(deferredLoadHashes[key]);
     });
     emitMainOutputUnit(program.mainFragment.outputUnit, mainOutput);
 
     if (backend.requiresPreamble &&
         !backend.htmlLibraryIsLoaded) {
-      compiler.reportHintMessage(
+      reporter.reportHintMessage(
           NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
     }
     // Return the total program size.
     return outputBuffers.values.fold(0, (a, b) => a + b.length);
   }
 
   String generateSourceMapTag(Uri sourceMapUri, Uri fileUri) {
     if (sourceMapUri != null && fileUri != null) {
       String sourceMapFileName = relativize(fileUri, sourceMapUri, false);
       return '''
@@ skipping 13 matching lines @@
       ClassElement cls =
           element.enclosingClassOrCompilationUnit.declaration;
       if (compiler.codegenWorld.directlyInstantiatedClasses.contains(cls) &&
           !cls.isNative &&
           compiler.deferredLoadTask.outputUnitForElement(element) ==
               compiler.deferredLoadTask.outputUnitForElement(cls)) {
         owner = cls;
       }
     }
     if (owner == null) {
-      compiler.internalError(element, 'Owner is null.');
+      reporter.internalError(element, 'Owner is null.');
     }
     return elementDescriptors
         .putIfAbsent(fragment, () => new Map<Element, ClassBuilder>())
         .putIfAbsent(owner, () {
           return new ClassBuilder(owner, namer, owner.isClass);
         });
   }
 
   /// Emits support-code for deferred loading into [output].
   jsAst.Statement buildDeferredBoilerPlate(
@@ skipping 259 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }