Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  *
  * Names are generated through three stages:
@@ skipping 439 matching lines @@
         constantHasher = new ConstantCanonicalHasher(compiler),
         functionTypeNamer = new FunctionTypeNamer(compiler) {
     _literalAsyncPrefix = new StringBackedName(asyncPrefix);
     _literalGetterPrefix = new StringBackedName(getterPrefix);
     _literalSetterPrefix = new StringBackedName(setterPrefix);
     _literalLazyGetterPrefix = new StringBackedName(lazyGetterPrefix);
   }
 
   JavaScriptBackend get backend => compiler.backend;
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   String get deferredTypesName => 'deferredTypes';
   String get isolateName => 'Isolate';
   String get isolatePropertiesName => r'$isolateProperties';
   jsAst.Name get noSuchMethodName => invocationName(Selectors.noSuchMethod_);
 
   /**
    * Some closures must contain their name. The name is stored in
    * [STATIC_CLOSURE_NAME_NAME].
    */
   String get STATIC_CLOSURE_NAME_NAME => r'$name';
@@ skipping 36 matching lines @@
       case JsGetName.IS_INDEXABLE_FIELD_NAME:
         Element cls = backend.findHelper('JavaScriptIndexingBehavior');
         return operatorIs(cls);
       case JsGetName.NULL_CLASS_TYPE_NAME:
         return runtimeTypeName(compiler.nullClass);
       case JsGetName.OBJECT_CLASS_TYPE_NAME:
         return runtimeTypeName(compiler.objectClass);
       case JsGetName.FUNCTION_CLASS_TYPE_NAME:
         return runtimeTypeName(compiler.functionClass);
       default:
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
           node,
           MessageKind.GENERIC,
           {'text': 'Error: Namer has no name for "$name".'});
         return asName('BROKEN');
     }
   }
 
   /// Return a reference to the given [name].
   ///
   /// This is used to ensure that every use site of a name has a unique node so
@@ skipping 171 matching lines @@
         List<String> suffix = callSuffixForStructure(selector.callStructure);
         if (selector.name == Identifiers.call) {
           // Derive the annotated name for this variant of 'call'.
           return deriveCallMethodName(suffix);
         }
         jsAst.Name disambiguatedName =
             _disambiguateMember(selector.memberName, suffix);
         return disambiguatedName; // Methods other than call are not annotated.
 
       default:
-        compiler.internalError(compiler.currentElement,
+        reporter.internalError(
+            CURRENT_ELEMENT_SPANNABLE,
             'Unexpected selector kind: ${selector.kind}');
         return null;
     }
   }
 
   /**
    * Returns the internal name used for an invocation mirror of this selector.
    */
   jsAst.Name invocationMirrorInternalName(Selector selector)
       => invocationName(selector);
@@ skipping 855 matching lines @@
   final Compiler compiler;
   final ConstantCanonicalHasher hasher;
 
   String root = null;     // First word, usually a type name.
   bool failed = false;    // Failed to generate something pretty.
   List<String> fragments = <String>[];
   int length = 0;
 
   ConstantNamingVisitor(this.compiler, this.hasher);
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   String getName(ConstantValue constant) {
     _visit(constant);
     if (root == null) return 'CONSTANT';
     if (failed) return '${root}_${getHashTag(constant, DEFAULT_TAG_LENGTH)}';
     if (fragments.length == 1) return 'C_${root}';
     return fragments.join('_');
   }
 
   String getHashTag(ConstantValue constant, int width) =>
       hashWord(hasher.getHash(constant), width);
@@ skipping 142 matching lines @@
       case SyntheticConstantKind.DUMMY_INTERCEPTOR:
         add('dummy_receiver');
         break;
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
         // Omit. These are opaque deferred indexes with nothing helpful to add.
         break;
       case SyntheticConstantKind.NAME:
         add('name');
         break;
       default:
-        compiler.internalError(compiler.currentElement,
+        reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
                                "Unexpected SyntheticConstantValue");
     }
   }
 
   @override
   void visitDeferred(DeferredConstantValue constant, [_]) {
     addRoot('Deferred');
   }
 }
 
 /**
  * Generates canonical hash values for [ConstantValue]s.
  *
  * Unfortunately, [Constant.hashCode] is not stable under minor perturbations,
  * so it can't be used for generating names.  This hasher keeps consistency
  * between runs by basing hash values of the names of elements, rather than
  * their hashCodes.
  */
 class ConstantCanonicalHasher implements ConstantValueVisitor<int, Null> {
 
   static const _MASK = 0x1fffffff;
   static const _UINT32_LIMIT = 4 * 1024 * 1024 * 1024;
 
 
   final Compiler compiler;
   final Map<ConstantValue, int> hashes = new Map<ConstantValue, int>();
 
   ConstantCanonicalHasher(this.compiler);
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   int getHash(ConstantValue constant) => _visit(constant);
 
   int _visit(ConstantValue constant) {
     int hash = hashes[constant];
     if (hash == null) {
       hash = _finish(constant.accept(this, null));
       hashes[constant] = hash;
     }
     return hash;
   }
@@ skipping 63 matching lines @@
 
   @override
   int visitSynthetic(SyntheticConstantValue constant, [_]) {
     switch (constant.kind) {
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
         // These contain a deferred opaque index into metadata. There is nothing
         // we can access that is stable between compiles.  Luckily, since they
         // resolve to integer indexes, they're always part of a larger constant.
         return 0;
       default:
-        compiler.internalError(NO_LOCATION_SPANNABLE,
-                               'SyntheticConstantValue should never be named and '
-                               'never be subconstant');
+        reporter.internalError(
+            NO_LOCATION_SPANNABLE,
+            'SyntheticConstantValue should never be named and '
+            'never be subconstant');
         return 0;
     }
   }
 
   @override
   int visitDeferred(DeferredConstantValue constant, [_]) {
     int hash = constant.prefix.hashCode;
     return _combine(hash, _visit(constant.referenced));
   }
 
@@ skipping 121 matching lines @@
       }
     }
   }
 }
 
 enum NamingScope {
   global,
   instance,
   constant
 }