Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/patch_parser.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.
 
 /**
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
@@ skipping 104 matching lines @@
 library dart2js.patchparser;
 
 import 'dart:async';
 
 import 'constants/values.dart' show
     ConstantValue;
 import 'compiler.dart' show
     Compiler;
 import 'common/tasks.dart' show
     CompilerTask;
+import 'dart_types.dart' show
+    DartType;
 import 'diagnostics/diagnostic_listener.dart';
 import 'diagnostics/messages.dart' show
     MessageKind;
 import 'elements/elements.dart';
 import 'elements/modelx.dart' show
     BaseFunctionElementX,
     ClassElementX,
     GetterElementX,
     LibraryElementX,
     MetadataAnnotationX,
@@ skipping 28 matching lines @@
   /**
    * Scans a library patch file, applies the method patches and
    * injections to the library, and returns a list of class
    * patches.
    */
   Future patchLibrary(LibraryLoader loader,
                       Uri patchUri, LibraryElement originLibrary) {
     return compiler.readScript(originLibrary, patchUri)
         .then((Script script) {
       var patchLibrary = new LibraryElementX(script, null, originLibrary);
-      return compiler.withCurrentElement(patchLibrary, () {
+      return reporter.withCurrentElement(patchLibrary, () {
         loader.registerNewLibrary(patchLibrary);
-        compiler.withCurrentElement(patchLibrary.entryCompilationUnit, () {
+        reporter.withCurrentElement(patchLibrary.entryCompilationUnit, () {
           // This patches the elements of the patch library into [library].
           // Injected elements are added directly under the compilation unit.
           // Patch elements are stored on the patched functions or classes.
           scanLibraryElements(patchLibrary.entryCompilationUnit);
         });
         return loader.processLibraryTags(patchLibrary);
       });
     });
   }
 
   void scanLibraryElements(CompilationUnitElement compilationUnit) {
     measure(() {
       // TODO(johnniwinther): Test that parts and exports are handled correctly.
       Script script = compilationUnit.script;
       Token tokens = new Scanner(script.file).tokenize();
       Function idGenerator = compiler.getNextFreeClassId;
       Listener patchListener = new PatchElementListener(compiler,
                                                         compilationUnit,
                                                         idGenerator);
       try {
         new PartialParser(patchListener).parseUnit(tokens);
       } on ParserError catch (e) {
         // No need to recover from a parser error in platform libraries, user
         // will never see this if the libraries are tested correctly.
-        compiler.internalError(
+        reporter.internalError(
             compilationUnit, "Parser error in patch file: $e");
       }
     });
   }
 
   void parsePatchClassNode(PartialClassElement cls) {
     // Parse [PartialClassElement] using a "patch"-aware parser instead
     // of calling its [parseNode] method.
     if (cls.cachedNode != null) return;
 
-    measure(() => compiler.withCurrentElement(cls, () {
+    measure(() => reporter.withCurrentElement(cls, () {
       MemberListener listener = new PatchMemberListener(compiler, cls);
       Parser parser = new PatchClassElementParser(listener);
       try {
         Token token = parser.parseTopLevelDeclaration(cls.beginToken);
         assert(identical(token, cls.endToken.next));
       } on ParserError catch (e) {
         // No need to recover from a parser error in platform libraries, user
         // will never see this if the libraries are tested correctly.
-        compiler.internalError(
+        reporter.internalError(
             cls, "Parser error in patch file: $e");
       }
       cls.cachedNode = listener.popNode();
       assert(listener.nodes.isEmpty);
     }));
   }
 }
 
 class PatchMemberListener extends MemberListener {
   final Compiler compiler;
 
   PatchMemberListener(Compiler compiler, ClassElement enclosingClass)
       : this.compiler = compiler,
-        super(compiler, enclosingClass);
+        super(compiler.reporter, enclosingClass);
 
   @override
   void addMember(Element patch) {
     addMetadata(patch);
 
     PatchVersion patchVersion = getPatchVersion(compiler, patch);
     if (patchVersion != null) {
       if (patchVersion.isActive(compiler.patchVersion)) {
         Element origin = enclosingClass.origin.localLookup(patch.name);
-        patchElement(compiler, origin, patch);
-        enclosingClass.addMember(patch, listener);
+        patchElement(compiler, reporter, origin, patch);
+        enclosingClass.addMember(patch, reporter);
       } else {
         // Skip this element.
       }
     } else {
-      enclosingClass.addMember(patch, listener);
+      enclosingClass.addMember(patch, reporter);
     }
   }
 }
 
 /**
  * Partial parser for patch files that also handles the members of class
  * declarations.
  */
 class PatchClassElementParser extends PartialParser {
   PatchClassElementParser(Listener listener) : super(listener);
 
   Token parseClassBody(Token token) => fullParseClassBody(token);
 }
 
 /**
  * Extension of [ElementListener] for parsing patch files.
  */
 class PatchElementListener extends ElementListener implements Listener {
   final Compiler compiler;
 
   PatchElementListener(Compiler compiler,
                        CompilationUnitElement patchElement,
                        int idGenerator())
     : this.compiler = compiler,
-      super(compiler, patchElement, idGenerator);
+      super(compiler.reporter, patchElement, idGenerator);
 
   @override
   void pushElement(Element patch) {
     popMetadata(patch);
 
     PatchVersion patchVersion = getPatchVersion(compiler, patch);
     if (patchVersion != null) {
       if (patchVersion.isActive(compiler.patchVersion)) {
         LibraryElement originLibrary = compilationUnitElement.library;
         assert(originLibrary.isPatched);
         Element origin = originLibrary.localLookup(patch.name);
-        patchElement(listener, origin, patch);
-        compilationUnitElement.addMember(patch, listener);
+        patchElement(compiler, reporter, origin, patch);
+        compilationUnitElement.addMember(patch, reporter);
       } else {
         // Skip this element.
       }
     } else {
-      compilationUnitElement.addMember(patch, listener);
+      compilationUnitElement.addMember(patch, reporter);
     }
   }
 }
 
 void patchElement(Compiler compiler,
+                  DiagnosticReporter reporter,
                   Element origin,
                   Element patch) {
   if (origin == null) {
-    compiler.reportErrorMessage(
+    reporter.reportErrorMessage(
         patch, MessageKind.PATCH_NON_EXISTING, {'name': patch.name});
     return;
   }
   if (!(origin.isClass ||
         origin.isConstructor ||
         origin.isFunction ||
         origin.isAbstractField)) {
     // TODO(ahe): Remove this error when the parser rejects all bad modifiers.
-    compiler.reportErrorMessage(origin, MessageKind.PATCH_NONPATCHABLE);
+    reporter.reportErrorMessage(origin, MessageKind.PATCH_NONPATCHABLE);
     return;
   }
   if (patch.isClass) {
-    tryPatchClass(compiler, origin, patch);
+    tryPatchClass(compiler, reporter, origin, patch);
   } else if (patch.isGetter) {
-    tryPatchGetter(compiler, origin, patch);
+    tryPatchGetter(reporter, origin, patch);
   } else if (patch.isSetter) {
-    tryPatchSetter(compiler, origin, patch);
+    tryPatchSetter(reporter, origin, patch);
   } else if (patch.isConstructor) {
-    tryPatchConstructor(compiler, origin, patch);
+    tryPatchConstructor(reporter, origin, patch);
   } else if(patch.isFunction) {
-    tryPatchFunction(compiler, origin, patch);
+    tryPatchFunction(reporter, origin, patch);
   } else {
     // TODO(ahe): Remove this error when the parser rejects all bad modifiers.
-    compiler.reportErrorMessage(patch, MessageKind.PATCH_NONPATCHABLE);
+    reporter.reportErrorMessage(patch, MessageKind.PATCH_NONPATCHABLE);
   }
 }
 
 void tryPatchClass(Compiler compiler,
+                   DiagnosticReporter reporter,
                    Element origin,
                    ClassElement patch) {
   if (!origin.isClass) {
-    compiler.reportError(
-        compiler.createMessage(
+    reporter.reportError(
+        reporter.createMessage(
             origin,
             MessageKind.PATCH_NON_CLASS,
             {'className': patch.name}),
         <DiagnosticMessage>[
-            compiler.createMessage(
+            reporter.createMessage(
                 patch,
                 MessageKind.PATCH_POINT_TO_CLASS,
                 {'className': patch.name}),
         ]);
     return;
   }
-  patchClass(compiler, origin, patch);
+  patchClass(compiler, reporter, origin, patch);
 }
 
 void patchClass(Compiler compiler,
+                DiagnosticReporter reporter,
                 ClassElementX origin,
                 ClassElementX patch) {
   if (origin.isPatched) {
-    compiler.internalError(origin,
+    reporter.internalError(origin,
         "Patching the same class more than once.");
   }
   origin.applyPatch(patch);
   checkNativeAnnotation(compiler, patch);
 }
 
 /// Check whether [cls] has a `@Native(...)` annotation, and if so, set its
 /// native name from the annotation.
 checkNativeAnnotation(Compiler compiler, ClassElement cls) {
   EagerAnnotationHandler.checkAnnotation(compiler, cls,
@@ skipping 73 matching lines @@
         return native;
       }
     }
     return null;
   }
 
   void validate(Compiler compiler,
                 Element element,
                 MetadataAnnotation annotation,
                 ConstantValue constant) {
-    if (constant.getType(compiler.coreTypes).element !=
-            compiler.nativeAnnotationClass) {
-      compiler.internalError(annotation, 'Invalid @Native(...) annotation.');
+    DartType annotationType = constant.getType(compiler.coreTypes);
+    if (annotationType.element != compiler.nativeAnnotationClass) {
+      DiagnosticReporter reporter = compiler.reporter;
+      reporter.internalError(annotation, 'Invalid @Native(...) annotation.');
     }
   }
 }
 
 /// Annotation handler for pre-resolution detection of `@patch` annotations.
 class PatchAnnotationHandler implements EagerAnnotationHandler<PatchVersion> {
   const PatchAnnotationHandler();
 
   PatchVersion getPatchVersion(MetadataAnnotation annotation) {
     if (annotation.beginToken != null) {
@@ skipping 15 matching lines @@
                      Element element,
                      MetadataAnnotation annotation) {
     return getPatchVersion(annotation);
   }
 
   @override
   void validate(Compiler compiler,
                 Element element,
                 MetadataAnnotation annotation,
                 ConstantValue constant) {
-    if (constant.getType(compiler.coreTypes).element !=
-            compiler.patchAnnotationClass) {
-      compiler.internalError(annotation, 'Invalid patch annotation.');
+    DartType annotationType = constant.getType(compiler.coreTypes);
+    if (annotationType.element != compiler.patchAnnotationClass) {
+      DiagnosticReporter reporter = compiler.reporter;
+      reporter.internalError(annotation, 'Invalid patch annotation.');
     }
   }
 }
 
 
-void tryPatchGetter(DiagnosticListener listener,
+void tryPatchGetter(DiagnosticReporter reporter,
                     Element origin,
                     FunctionElement patch) {
   if (!origin.isAbstractField) {
-    listener.reportError(
-        listener.createMessage(
+    reporter.reportError(
+        reporter.createMessage(
             origin,
             MessageKind.PATCH_NON_GETTER,
             {'name': origin.name}),
         <DiagnosticMessage>[
-            listener.createMessage(
+            reporter.createMessage(
                 patch,
                 MessageKind.PATCH_POINT_TO_GETTER,
                 {'getterName': patch.name}),
         ]);
     return;
   }
   AbstractFieldElement originField = origin;
   if (originField.getter == null) {
-    listener.reportError(
-        listener.createMessage(
+    reporter.reportError(
+        reporter.createMessage(
             origin,
             MessageKind.PATCH_NO_GETTER,
             {'getterName': patch.name}),
         <DiagnosticMessage>[
-            listener.createMessage(
+            reporter.createMessage(
                 patch,
                 MessageKind.PATCH_POINT_TO_GETTER,
                 {'getterName': patch.name}),
         ]);
     return;
   }
   GetterElementX getter = originField.getter;
-  patchFunction(listener, getter, patch);
+  patchFunction(reporter, getter, patch);
 }
 
-void tryPatchSetter(DiagnosticListener listener,
+void tryPatchSetter(DiagnosticReporter reporter,
                     Element origin,
                     FunctionElement patch) {
   if (!origin.isAbstractField) {
-    listener.reportError(
-        listener.createMessage(
+    reporter.reportError(
+        reporter.createMessage(
             origin,
             MessageKind.PATCH_NON_SETTER,
             {'name': origin.name}),
         <DiagnosticMessage>[
-            listener.createMessage(
+            reporter.createMessage(
                 patch,
                 MessageKind.PATCH_POINT_TO_SETTER,
                 {'setterName': patch.name}),
         ]);
     return;
   }
   AbstractFieldElement originField = origin;
   if (originField.setter == null) {
-    listener.reportError(
-        listener.createMessage(
+    reporter.reportError(
+        reporter.createMessage(
             origin,
             MessageKind.PATCH_NO_SETTER,
             {'setterName': patch.name}),
         <DiagnosticMessage>[
-              listener.createMessage(
+              reporter.createMessage(
                   patch,
                   MessageKind.PATCH_POINT_TO_SETTER,
                   {'setterName': patch.name}),
         ]);
     return;
   }
   SetterElementX setter = originField.setter;
-  patchFunction(listener, setter, patch);
+  patchFunction(reporter, setter, patch);
 }
 
-void tryPatchConstructor(DiagnosticListener listener,
+void tryPatchConstructor(DiagnosticReporter reporter,
                          Element origin,
                          FunctionElement patch) {
   if (!origin.isConstructor) {
-    listener.reportError(
-        listener.createMessage(
+    reporter.reportError(
+        reporter.createMessage(
             origin,
             MessageKind.PATCH_NON_CONSTRUCTOR,
             {'constructorName': patch.name}),
         <DiagnosticMessage>[
-            listener.createMessage(
+            reporter.createMessage(
                 patch,
                 MessageKind.PATCH_POINT_TO_CONSTRUCTOR,
                 {'constructorName': patch.name}),
         ]);
     return;
   }
-  patchFunction(listener, origin, patch);
+  patchFunction(reporter, origin, patch);
 }
 
-void tryPatchFunction(DiagnosticListener listener,
+void tryPatchFunction(DiagnosticReporter reporter,
                       Element origin,
                       FunctionElement patch) {
   if (!origin.isFunction) {
-    listener.reportError(
-        listener.createMessage(
+    reporter.reportError(
+        reporter.createMessage(
             origin,
             MessageKind.PATCH_NON_FUNCTION,
             {'functionName': patch.name}),
         <DiagnosticMessage>[
-            listener.createMessage(
+            reporter.createMessage(
                 patch,
                 MessageKind.PATCH_POINT_TO_FUNCTION,
                 {'functionName': patch.name}),
         ]);
     return;
   }
-  patchFunction(listener, origin, patch);
+  patchFunction(reporter, origin, patch);
 }
 
-void patchFunction(DiagnosticListener listener,
+void patchFunction(DiagnosticReporter reporter,
                    BaseFunctionElementX origin,
                    BaseFunctionElementX patch) {
   if (!origin.modifiers.isExternal) {
-    listener.reportError(
-        listener.createMessage(origin, MessageKind.PATCH_NON_EXTERNAL),
+    reporter.reportError(
+        reporter.createMessage(origin, MessageKind.PATCH_NON_EXTERNAL),
         <DiagnosticMessage>[
-              listener.createMessage(
+              reporter.createMessage(
                   patch,
                   MessageKind.PATCH_POINT_TO_FUNCTION,
                   {'functionName': patch.name}),
         ]);
     return;
   }
   if (origin.isPatched) {
-    listener.internalError(origin,
+    reporter.internalError(origin,
         "Trying to patch a function more than once.");
   }
   origin.applyPatch(patch);
 }
 
 PatchVersion getPatchVersion(Compiler compiler, Element element) {
   return EagerAnnotationHandler.checkAnnotation(compiler, element,
       const PatchAnnotationHandler());
 }
 
 class PatchVersion {
   final String tag;
 
   const PatchVersion(this.tag);
 
   bool isActive(String patchTag) => tag == null || tag == patchTag;
 
   String toString() => 'PatchVersion($tag)';
 }