Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/native/enqueue.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.
 
 part of native;
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
@@ skipping 79 matching lines @@
   ClassElement _annotationJsNameClass;
 
   /// Subclasses of [NativeEnqueuerBase] are constructed by the backend.
   NativeEnqueuerBase(this.world, Compiler compiler, this.enableLiveTypeAnalysis)
       : this.compiler = compiler,
         processedLibraries = compiler.cacheStrategy.newSet();
 
   JavaScriptBackend get backend => compiler.backend;
   Resolution get resolution => compiler.resolution;
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   void processNativeClasses(Iterable<LibraryElement> libraries) {
     if (compiler.hasIncrementalSupport) {
       // Since [Set.add] returns bool if an element was added, this restricts
       // [libraries] to ones that haven't already been processed. This saves
       // time during incremental compiles.
       libraries = libraries.where(processedLibraries.add);
     }
     libraries.forEach(processNativeClassesInLibrary);
     if (backend.isolateHelperLibrary != null) {
       processNativeClassesInLibrary(backend.isolateHelperLibrary);
@@ skipping 126 matching lines @@
         token = token.next;
         if (token.stringValue != '.') break;
         token = token.next;
         if (!token.isIdentifier()) return null;
         id = token;
       }
       // Should be at '{', 'with', 'implements', '<' or 'native'.
       return id.value;
     }
 
-    return compiler.withCurrentElement(classElement, () {
+    return reporter.withCurrentElement(classElement, () {
       return scanForExtendsName(classElement.position);
     });
   }
 
   ClassElement get annotationCreatesClass {
     findAnnotationClasses();
     return _annotationCreatesClass;
   }
 
   ClassElement get annotationReturnsClass {
     findAnnotationClasses();
     return _annotationReturnsClass;
   }
 
   ClassElement get annotationJsNameClass {
     findAnnotationClasses();
     return _annotationJsNameClass;
   }
 
   void findAnnotationClasses() {
     if (_annotationCreatesClass != null) return;
     ClassElement find(name) {
       Element e = backend.findHelper(name);
       if (e == null || e is! ClassElement) {
-        compiler.internalError(NO_LOCATION_SPANNABLE,
+        reporter.internalError(NO_LOCATION_SPANNABLE,
             "Could not find implementation class '${name}'.");
       }
       return e;
     }
     _annotationCreatesClass = find('Creates');
     _annotationReturnsClass = find('Returns');
     _annotationJsNameClass = find('JSName');
   }
 
   /// Returns the JSName annotation string or `null` if no JSName annotation is
   /// present.
   String findJsNameFromAnnotation(Element element) {
     String name = null;
     ClassElement annotationClass = annotationJsNameClass;
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(resolution);
       ConstantValue value =
           compiler.constants.getConstantValue(annotation.constant);
       if (!value.isConstructedObject) continue;
       ConstructedConstantValue constructedObject = value;
       if (constructedObject.type.element != annotationClass) continue;
 
       Iterable<ConstantValue> fields = constructedObject.fields.values;
       // TODO(sra): Better validation of the constant.
       if (fields.length != 1 || fields.single is! StringConstantValue) {
-        compiler.internalError(annotation,
+        reporter.internalError(annotation,
             'Annotations needs one string: ${annotation.node}');
       }
       StringConstantValue specStringConstant = fields.single;
       String specString = specStringConstant.toDartString().slowToString();
       if (name == null) {
         name = specString;
       } else {
-        compiler.internalError(annotation,
+        reporter.internalError(annotation,
             'Too many JSName annotations: ${annotation.node}');
       }
     }
     return name;
   }
 
   enqueueClass(ClassElement classElement, cause) {
     assert(unusedClasses.contains(classElement));
     unusedClasses.remove(classElement);
     pendingClasses.add(classElement);
@@ skipping 22 matching lines @@
     classElement.ensureResolved(resolution);
     compiler.backend.registerInstantiatedType(
         classElement.rawType, world, compiler.globalDependencies);
 
     if (firstTime) {
       queue.add(onFirstNativeClass);
     }
   }
 
   registerElement(Element element) {
-    compiler.withCurrentElement(element, () {
+    reporter.withCurrentElement(element, () {
       if (element.isFunction || element.isGetter || element.isSetter) {
         handleMethodAnnotations(element);
         if (element.isNative) {
           registerMethodUsed(element);
         }
       } else if (element.isField) {
         handleFieldAnnotations(element);
         if (element.isNative) {
           registerFieldLoad(element);
           registerFieldStore(element);
@@ skipping 39 matching lines @@
   /// 2. If [element] has a @JSName annotation that is not an identifier,
   ///    use the declared @JSName as the expression
   /// 3. If [element] does not have a @JSName annotation, qualify the name of
   ///    the method with the @Native name of the enclosing class.
   void setNativeNameForStaticMethod(ElementX element) {
     String name = findJsNameFromAnnotation(element);
     if (name == null) name = element.name;
     if (isIdentifier(name)) {
       List<String> nativeNames = nativeTagsOfClassRaw(element.enclosingClass);
       if (nativeNames.length != 1) {
-        compiler.internalError(element,
+        reporter.internalError(element,
             'Unable to determine a native name for the enclosing class, '
             'options: $nativeNames');
       }
       element.setNative('${nativeNames[0]}.$name');
     } else {
       element.setNative(name);
     }
   }
 
   bool isIdentifier(String s) => _identifier.hasMatch(s);
 
   bool isNativeMethod(FunctionElementX element) {
     if (!element.library.canUseNative) return false;
     // Native method?
-    return compiler.withCurrentElement(element, () {
+    return reporter.withCurrentElement(element, () {
       Node node = element.parseNode(resolution.parsing);
       if (node is! FunctionExpression) return false;
       FunctionExpression functionExpression = node;
       node = functionExpression.body;
       Token token = node.getBeginToken();
       if (identical(token.stringValue, 'native')) return true;
       return false;
     });
   }
 
@@ skipping 54 matching lines @@
       assert(type is DartType);
       enqueueUnusedClassesMatching(
           (nativeClass) => compiler.types.isSubtype(nativeClass.thisType, type),
           cause,
           'subtypeof($type)');
     }
 
     // Give an info so that library developers can compile with -v to find why
     // all the native classes are included.
     if (unusedClasses.isEmpty && !allUsedBefore) {
-      compiler.log('All native types marked as used due to $cause.');
+      reporter.log('All native types marked as used due to $cause.');
     }
   }
 
   enqueueUnusedClassesMatching(bool predicate(classElement),
                                cause,
                                [String reason]) {
     Iterable matches = unusedClasses.where(predicate);
     matches.toList().forEach((c) => enqueueClass(c, cause));
   }
 
@@ skipping 32 matching lines @@
 
   void processNativeClass(ClassElement classElement) {
     super.processNativeClass(classElement);
 
     // Since we map from dispatch tags to classes, a dispatch tag must be used
     // on only one native class.
     for (String tag in nativeTagsOfClass(classElement)) {
       ClassElement owner = tagOwner[tag];
       if (owner != null) {
         if (owner != classElement) {
-          compiler.internalError(
+          reporter.internalError(
               classElement, "Tag '$tag' already in use by '${owner.name}'");
         }
       } else {
         tagOwner[tag] = classElement;
       }
     }
   }
 
   void logSummary(log(message)) {
     log('Resolved ${registeredClasses.length} native elements used, '
         '${unusedClasses.length} native elements dead.');
   }
 
   /**
    * Handles JS-calls, which can be an instantiation point for types.
    *
    * For example, the following code instantiates and returns native classes
    * that are `_DOMWindowImpl` or a subtype.
    *
    *     JS('_DOMWindowImpl', 'window')
    *
    */
   void registerJsCall(Send node, ForeignResolver resolver) {
-    NativeBehavior behavior = NativeBehavior.ofJsCall(node, compiler, resolver);
+    NativeBehavior behavior = NativeBehavior.ofJsCall(
+        node, reporter, compiler.parsing, compiler.coreTypes, resolver);
     registerNativeBehavior(behavior, node);
     nativeBehaviors[node] = behavior;
   }
 
 
   /**
    * Handles JS-embedded global calls, which can be an instantiation point for
    * types.
    *
    * For example, the following code instantiates and returns a String class
    *
    *     JS_EMBEDDED_GLOBAL('String', 'foo')
    *
    */
   void registerJsEmbeddedGlobalCall(Send node, ForeignResolver resolver) {
-    NativeBehavior behavior =
-        NativeBehavior.ofJsEmbeddedGlobalCall(node, compiler, resolver);
+    NativeBehavior behavior = NativeBehavior.ofJsEmbeddedGlobalCall(
+        node, reporter, compiler.parsing, compiler.coreTypes, resolver);
     registerNativeBehavior(behavior, node);
     nativeBehaviors[node] = behavior;
   }
 
 
   /**
    * Handles JS-compiler builtin calls, which can be an instantiation point for
    * types.
    *
    * For example, the following code instantiates and returns a String class
    *
    *     JS_BUILTIN('String', 'int2string', 0)
    *
    */
   void registerJsBuiltinCall(Send node, ForeignResolver resolver) {
-    NativeBehavior behavior =
-        NativeBehavior.ofJsBuiltinCall(node, compiler, resolver);
+    NativeBehavior behavior = NativeBehavior.ofJsBuiltinCall(
+        node, reporter, compiler.parsing, compiler.coreTypes, resolver);
     registerNativeBehavior(behavior, node);
     nativeBehaviors[node] = behavior;
   }
 }
 
 
 class NativeCodegenEnqueuer extends NativeEnqueuerBase {
 
   final CodeEmitterTask emitter;
 
@@ skipping 51 matching lines @@
         superclass,
         () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }