Clean up error handling.

dart/sdk/lib/_internal/compiler/implementation/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 376 matching lines @@
   PatchMetadataAnnotation() : super(STATE_DONE);
 
   Token get beginToken => null;
   Token get endToken => null;
 }
 
 void patchElement(leg.DiagnosticListener listener,
                    Element origin,
                    Element patch) {
   if (origin == null) {
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_NON_EXISTING.error({'name': patch.name}),
-        api.Diagnostic.ERROR);
+    listener.reportError(
+        patch, leg.MessageKind.PATCH_NON_EXISTING, {'name': patch.name});
     return;
   }
   if (!(origin.isClass() ||
         origin.isConstructor() ||
         origin.isFunction() ||
         origin.isAbstractField())) {
-    listener.reportMessage(
-        listener.spanFromSpannable(origin),
-        leg.MessageKind.PATCH_NONPATCHABLE.error(),
-        api.Diagnostic.ERROR);
+    listener.reportError(origin, leg.MessageKind.PATCH_NONPATCHABLE);
     return;
   }
   if (patch.isClass()) {
     tryPatchClass(listener, origin, patch);
   } else if (patch.isGetter()) {
     tryPatchGetter(listener, origin, patch);
   } else if (patch.isSetter()) {
     tryPatchSetter(listener, origin, patch);
   } else if (patch.isConstructor()) {
     tryPatchConstructor(listener, origin, patch);
   } else if(patch.isFunction()) {
     tryPatchFunction(listener, origin, patch);
   } else {
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_NONPATCHABLE.error(),
-        api.Diagnostic.ERROR);
+    listener.reportError(patch, leg.MessageKind.PATCH_NONPATCHABLE);
   }
 }
 
 void tryPatchClass(leg.DiagnosticListener listener,
                     Element origin,
                     ClassElement patch) {
   if (!origin.isClass()) {
-    listener.reportMessage(
-        listener.spanFromSpannable(origin),
-        leg.MessageKind.PATCH_NON_CLASS.error({'className': patch.name}),
-        api.Diagnostic.ERROR);
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_POINT_TO_CLASS.error({'className': patch.name}),
-        api.Diagnostic.INFO);
+    listener.reportError(
+        origin, leg.MessageKind.PATCH_NON_CLASS, {'className': patch.name});
+    listener.reportInfo(
+        patch, leg.MessageKind.PATCH_POINT_TO_CLASS, {'className': patch.name});
     return;
   }
   patchClass(listener, origin, patch);
 }
 
 void patchClass(leg.DiagnosticListener listener,
                  ClassElement origin,
                  ClassElement patch) {
   if (origin.isPatched) {
     listener.internalErrorOnElement(
         origin, "Patching the same class more than once.");
   }
   // TODO(johnniwinther): Change to functions on the ElementX class.
   origin.patch = patch;
   patch.origin = origin;
 }
 
 void tryPatchGetter(leg.DiagnosticListener listener,
                      Element origin,
                      FunctionElement patch) {
   if (!origin.isAbstractField()) {
-    listener.reportMessage(
-        listener.spanFromSpannable(origin),
-        leg.MessageKind.PATCH_NON_GETTER.error({'name': origin.name}),
-        api.Diagnostic.ERROR);
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_POINT_TO_GETTER.error({'getterName': patch.name}),
-        api.Diagnostic.INFO);
+    listener.reportError(
+        origin, leg.MessageKind.PATCH_NON_GETTER, {'name': origin.name});
+    listener.reportInfo(
+        patch,
+        leg.MessageKind.PATCH_POINT_TO_GETTER, {'getterName': patch.name});
     return;
   }
   AbstractFieldElement originField = origin;
   if (originField.getter == null) {
-    listener.reportMessage(
-        listener.spanFromSpannable(origin),
-        leg.MessageKind.PATCH_NO_GETTER.error({'getterName': patch.name}),
-        api.Diagnostic.ERROR);
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_POINT_TO_GETTER.error({'getterName': patch.name}),
-        api.Diagnostic.INFO);
+    listener.reportError(
+        origin, leg.MessageKind.PATCH_NO_GETTER, {'getterName': patch.name});
+    listener.reportInfo(
+        patch,
+        leg.MessageKind.PATCH_POINT_TO_GETTER, {'getterName': patch.name});
     return;
   }
   patchFunction(listener, originField.getter, patch);
 }
 
 void tryPatchSetter(leg.DiagnosticListener listener,
                      Element origin,
                      FunctionElement patch) {
   if (!origin.isAbstractField()) {
-    listener.reportMessage(
-        listener.spanFromSpannable(origin),
-        leg.MessageKind.PATCH_NON_SETTER.error({'name': origin.name}),
-        api.Diagnostic.ERROR);
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_POINT_TO_SETTER.error({'setterName': patch.name}),
-        api.Diagnostic.INFO);
+    listener.reportError(
+        origin, leg.MessageKind.PATCH_NON_SETTER, {'name': origin.name});
+    listener.reportInfo(
+        patch,
+        leg.MessageKind.PATCH_POINT_TO_SETTER, {'setterName': patch.name});
     return;
   }
   AbstractFieldElement originField = origin;
   if (originField.setter == null) {
-    listener.reportMessage(
-        listener.spanFromSpannable(origin),
-        leg.MessageKind.PATCH_NO_SETTER.error({'setterName': patch.name}),
-        api.Diagnostic.ERROR);
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_POINT_TO_SETTER.error({'setterName': patch.name}),
-        api.Diagnostic.INFO);
+    listener.reportError(
+        origin, leg.MessageKind.PATCH_NO_SETTER, {'setterName': patch.name});
+    listener.reportInfo(
+        patch,
+        leg.MessageKind.PATCH_POINT_TO_SETTER, {'setterName': patch.name});
     return;
   }
   patchFunction(listener, originField.setter, patch);
 }
 
 void tryPatchConstructor(leg.DiagnosticListener listener,
                           Element origin,
                           FunctionElement patch) {
   if (!origin.isConstructor()) {
-    listener.reportMessage(
-        listener.spanFromSpannable(origin),
-        leg.MessageKind.PATCH_NON_CONSTRUCTOR.error(
-            {'constructorName': patch.name}),
-        api.Diagnostic.ERROR);
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_POINT_TO_CONSTRUCTOR.error(
-            {'constructorName': patch.name}),
-        api.Diagnostic.INFO);
+    listener.reportError(
+        origin,
+        leg.MessageKind.PATCH_NON_CONSTRUCTOR, {'constructorName': patch.name});
+    listener.reportInfo(
+        patch,
+        leg.MessageKind.PATCH_POINT_TO_CONSTRUCTOR,
+        {'constructorName': patch.name});
     return;
   }
   patchFunction(listener, origin, patch);
 }
 
 void tryPatchFunction(leg.DiagnosticListener listener,
                        Element origin,
                        FunctionElement patch) {
   if (!origin.isFunction()) {
-    listener.reportMessage(
-        listener.spanFromSpannable(origin),
-        leg.MessageKind.PATCH_NON_FUNCTION.error({'functionName': patch.name}),
-        api.Diagnostic.ERROR);
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_POINT_TO_FUNCTION.error(
-            {'functionName': patch.name}),
-        api.Diagnostic.INFO);
+    listener.reportError(
+        origin,
+        leg.MessageKind.PATCH_NON_FUNCTION, {'functionName': patch.name});
+    listener.reportInfo(
+        patch,
+        leg.MessageKind.PATCH_POINT_TO_FUNCTION, {'functionName': patch.name});
     return;
   }
   patchFunction(listener, origin, patch);
 }
 
 void patchFunction(leg.DiagnosticListener listener,
                     FunctionElement origin,
                     FunctionElement patch) {
   if (!origin.modifiers.isExternal()) {
-    listener.reportMessage(
-        listener.spanFromSpannable(origin),
-        leg.MessageKind.PATCH_NON_EXTERNAL.error(),
-        api.Diagnostic.ERROR);
-    listener.reportMessage(
-        listener.spanFromSpannable(patch),
-        leg.MessageKind.PATCH_POINT_TO_FUNCTION.error(
-            {'functionName': patch.name}),
-        api.Diagnostic.INFO);
+    listener.reportError(origin, leg.MessageKind.PATCH_NON_EXTERNAL);
+    listener.reportInfo(
+        patch,
+        leg.MessageKind.PATCH_POINT_TO_FUNCTION, {'functionName': patch.name});
     return;
   }
   if (origin.isPatched) {
     listener.internalErrorOnElement(origin,
         "Trying to patch a function more than once.");
   }
   if (origin.cachedNode != null) {
     listener.internalErrorOnElement(origin,
         "Trying to patch an already compiled function.");
   }
   // Don't just assign the patch field. This also updates the cachedNode.
   // TODO(johnniwinther): Change to functions on the ElementX class.
   origin.setPatch(patch);
   patch.origin = origin;
 }
 
 // TODO(johnniwinther): Add unittest when patch is (real) metadata.
 bool isPatchElement(Element element) {
   // TODO(lrn): More checks needed if we introduce metadata for real.
   // In that case, it must have the identifier "native" as metadata.
   for (Link link = element.metadata; !link.isEmpty; link = link.tail) {
     if (link.head is PatchMetadataAnnotation) return true;
   }
   return false;
 }