Clean up error handling.

dart/tests/compiler/dart2js/patch_test.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.
 
 import "package:expect/expect.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/tree/tree.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/util/util.dart";
 import "mock_compiler.dart";
@@ skipping 368 matching lines @@
       """);
   var function = ensure(compiler, "foo", compiler.coreLibrary.find);
   compiler.resolver.resolve(function);
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   print('testExternalWithoutImplementationTopLevel:${compiler.errors}');
   Expect.equals(1, compiler.errors.length);
   Expect.isTrue(
       compiler.errors[0].message.kind ==
           MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
-  Expect.equals('External method without an implementation.',
-                compiler.errors[0].message.toString());
+  Expect.stringEquals('Error: External method without an implementation.',
+                      compiler.errors[0].message.toString());
 }
 
 testExternalWithoutImplementationMember() {
   var compiler = applyPatch(
       """
       class Class {
         external void foo();
       }
       """,
       """
       patch class Class {
         // patch void foo() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
   container.parseNode(compiler);
 
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "foo", container.lookupLocalMember));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   print('testExternalWithoutImplementationMember:${compiler.errors}');
   Expect.equals(1, compiler.errors.length);
   Expect.isTrue(
       compiler.errors[0].message.kind ==
           MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
-  Expect.equals('External method without an implementation.',
-                compiler.errors[0].message.toString());
+  Expect.stringEquals('Error: External method without an implementation.',
+                      compiler.errors[0].message.toString());
 }
 
 testIsSubclass() {
   var compiler = applyPatch(
       """
       class A {}
       """,
       """
       patch class A {}
       """);
@@ skipping 282 matching lines @@
   cls = ensure(compiler, "B", compiler.coreLibrary.find);
   cls.ensureResolved(compiler);
   typedSelector = new TypedSelector.exact(cls.rawType, selector);
   Expect.isTrue(selector.applies(method, compiler));
   Expect.isTrue(typedSelector.applies(method, compiler));
 }
 
 void testAnalyzeAllInjectedMembers() {
   void expect(String patchText, [expectedWarnings]) {
     if (expectedWarnings == null) expectedWarnings = [];
-    if (expectedWarnings is! List) expectedWarnings = [expectedWarnings];
+    if (expectedWarnings is! List) {
+      expectedWarnings = <MessageKind>[expectedWarnings];
+    }
 
     var compiler = applyPatch('', patchText,
                               analyzeAll: true, analyzeOnly: true);
     compiler.librariesToAnalyzeWhenRun = [Uri.parse('dart:core')];
     compiler.runCompiler(null);
     compareWarningKinds(patchText, expectedWarnings, compiler.warnings);
   }
 
-  expect('String s = 0;', MessageKind.NOT_ASSIGNABLE);
-  expect('void method() { String s = 0; }', MessageKind.NOT_ASSIGNABLE);
+  expect('String s = 0;', MessageKind.NOT_ASSIGNABLE.warning);
+  expect('void method() { String s = 0; }', MessageKind.NOT_ASSIGNABLE.warning);
   expect('''
          class Class {
            String s = 0;
          }
          ''',
-         MessageKind.NOT_ASSIGNABLE);
+         MessageKind.NOT_ASSIGNABLE.warning);
   expect('''
          class Class {
            void method() {
              String s = 0;
            }
          }
          ''',
-         MessageKind.NOT_ASSIGNABLE);
+         MessageKind.NOT_ASSIGNABLE.warning);
 }
 
 void testTypecheckPatchedMembers() {
   String originText = "external void method();";
   String patchText = """
                      patch void method() {
                        String s = 0;
                      }
                      """;
   var compiler = applyPatch(originText, patchText,
                             analyzeAll: true, analyzeOnly: true);
   compiler.librariesToAnalyzeWhenRun = [Uri.parse('dart:core')];
   compiler.runCompiler(null);
   compareWarningKinds(patchText,
-      [MessageKind.NOT_ASSIGNABLE], compiler.warnings);
+      [MessageKind.NOT_ASSIGNABLE.warning], compiler.warnings);
 }
 
 main() {
   testPatchConstructor();
   testPatchFunction();
   testPatchMember();
   testPatchGetter();
   testRegularMember();
   testGhostMember();
   testInjectFunction();
@@ skipping 15 matching lines @@
   testPatchNoGetter();
   testPatchNonSetter();
   testPatchNoSetter();
   testPatchNonFunction();
 
   testPatchAndSelector();
 
   testAnalyzeAllInjectedMembers();
   testTypecheckPatchedMembers();
 }