Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/js_backend/constant_emitter.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.
 
 part of js_backend;
 
 typedef jsAst.Expression _ConstantReferenceGenerator(ConstantValue constant);
 
 typedef jsAst.Expression _ConstantListGenerator(jsAst.Expression array);
 
@@ skipping 21 matching lines @@
    * The given [constantReferenceGenerator] function must, when invoked with a
    * constant, either return a reference or return its literal expression if it
    * can be inlined.
    */
   ConstantEmitter(
       this.compiler,
       this.namer,
       jsAst.Expression this.constantReferenceGenerator(ConstantValue constant),
       this.makeConstantList);
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   /**
    * Constructs a literal expression that evaluates to the constant. Uses a
    * canonical name unless the constant can be emitted multiple times (as for
    * numbers and strings).
    */
   jsAst.Expression generate(ConstantValue constant) {
     return _visit(constant);
   }
 
   jsAst.Expression _visit(ConstantValue constant) {
     return constant.accept(this, null);
   }
 
   @override
   jsAst.Expression visitFunction(FunctionConstantValue constant, [_]) {
-    compiler.internalError(NO_LOCATION_SPANNABLE,
+    reporter.internalError(NO_LOCATION_SPANNABLE,
         "The function constant does not need specific JS code.");
     return null;
   }
 
   @override
   jsAst.Expression visitNull(NullConstantValue constant, [_]) {
     return new jsAst.LiteralNull();
   }
 
   static final _exponentialRE = new RegExp(
@@ skipping 145 matching lines @@
           } else if (field.name == JavaScriptMapConstant.JS_OBJECT_NAME) {
             arguments.add(jsMap());
           } else if (field.name == JavaScriptMapConstant.KEYS_NAME) {
             arguments.add(constantReferenceGenerator(constant.keyList));
           } else if (field.name == JavaScriptMapConstant.PROTO_VALUE) {
             assert(constant.protoValue != null);
             arguments.add(constantReferenceGenerator(constant.protoValue));
           } else if (field.name == JavaScriptMapConstant.JS_DATA_NAME) {
             arguments.add(jsGeneralMap());
           } else {
-            compiler.internalError(field,
+            reporter.internalError(field,
                 "Compiler has unexpected field ${field.name} for "
                 "${className}.");
           }
           emittedArgumentCount++;
         },
         includeSuperAndInjectedMembers: true);
     if ((className == JavaScriptMapConstant.DART_STRING_CLASS &&
          emittedArgumentCount != 3) ||
         (className == JavaScriptMapConstant.DART_PROTO_CLASS &&
          emittedArgumentCount != 4) ||
         (className == JavaScriptMapConstant.DART_GENERAL_CLASS &&
          emittedArgumentCount != 1)) {
-      compiler.internalError(classElement,
+      reporter.internalError(classElement,
           "Compiler and ${className} disagree on number of fields.");
     }
 
     jsAst.Expression constructor =
         backend.emitter.constructorAccess(classElement);
     jsAst.Expression value = new jsAst.New(constructor, arguments);
     return maybeAddTypeArguments(constant.type, value);
   }
 
   JavaScriptBackend get backend => compiler.backend;
@@ skipping 19 matching lines @@
   @override
   jsAst.Expression visitSynthetic(SyntheticConstantValue constant, [_]) {
     switch (constant.kind) {
       case SyntheticConstantKind.DUMMY_INTERCEPTOR:
       case SyntheticConstantKind.EMPTY_VALUE:
         return new jsAst.LiteralNumber('0');
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
       case SyntheticConstantKind.NAME:
         return constant.payload;
       default:
-        compiler.internalError(NO_LOCATION_SPANNABLE,
+        reporter.internalError(NO_LOCATION_SPANNABLE,
                                "Unexpected DummyConstantKind ${constant.kind}");
         return null;
     }
   }
 
   @override
   jsAst.Expression visitConstructed(ConstructedConstantValue constant, [_]) {
     Element element = constant.type.element;
     if (backend.isForeign(element)
         && element.name == 'JS_CONST') {
@@ skipping 30 matching lines @@
                             [value, argumentList]);
     }
     return value;
   }
 
   @override
   jsAst.Expression visitDeferred(DeferredConstantValue constant, [_]) {
     return constantReferenceGenerator(constant.referenced);
   }
 }