New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/resolver_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver_test;
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart' show ParserErrorCode;
@@ skipping 10 matching lines @@
 class TypePropagationTest extends ResolverTestCase {
   void fail_functionExpression_asInvocationArgument_functionExpressionInvocation() {
     String code = EngineTestCase.createSource([
         "main() {",
         "  (f(String value)) {} ((v) {",
         "    v;",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     Type2 dynamicType = typeProvider.dynamicType;
     Type2 stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", FormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
     JUnitTestCase.assertSame(dynamicType, vParameter.identifier.staticType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
     JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
     JUnitTestCase.assertSame(dynamicType, vIdentifier.staticType);
   }
   void fail_propagatedReturnType_functionExpression() {
     String code = EngineTestCase.createSource(["main() {", "  var v = (() {return 42;})();", "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
   void test_as() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  bool get g => true;",
         "}",
         "A f(var p) {",
         "  if ((p as A).g) {",
         "    return p;",
         "  } else {",
         "    return null;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_assert() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  assert (p is A);",
         "  return p;",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_assignment() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v;", "  v = 0;", "  return v;", "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
   }
   void test_assignment_afterInitializer() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 0;", "  v = 1.0;", "  return v;", "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeProvider.doubleType, variableName.propagatedType);
   }
   void test_forEach() {
     String code = EngineTestCase.createSource([
         "f(List<String> p) {",
         "  for (var e in p) {",
         "    e;",
         "  }",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     InterfaceType stringType = typeProvider.stringType;
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "e in", SimpleIdentifier);
       JUnitTestCase.assertSame(stringType, identifier.propagatedType);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "e;", SimpleIdentifier);
       JUnitTestCase.assertSame(stringType, identifier.propagatedType);
     }
   }
   void test_functionExpression_asInvocationArgument() {
     String code = EngineTestCase.createSource([
         "class MyMap<K, V> {",
         "  forEach(f(K key, V value)) {}",
         "}",
         "f(MyMap<int, String> m) {",
         "  m.forEach((k, v) {",
         "    k;",
         "    v;",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     Type2 intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", SimpleFormalParameter);
     JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
     SimpleIdentifier kIdentifier = EngineTestCase.findNode(unit, code, "k;", SimpleIdentifier);
     JUnitTestCase.assertSame(intType, kIdentifier.propagatedType);
     JUnitTestCase.assertSame(typeProvider.dynamicType, kIdentifier.staticType);
     Type2 stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
     JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
     JUnitTestCase.assertSame(typeProvider.dynamicType, vIdentifier.staticType);
   }
   void test_functionExpression_asInvocationArgument_fromInferredInvocation() {
     String code = EngineTestCase.createSource([
         "class MyMap<K, V> {",
         "  forEach(f(K key, V value)) {}",
         "}",
         "f(MyMap<int, String> m) {",
         "  var m2 = m;",
         "  m2.forEach((k, v) {});",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     Type2 intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", SimpleFormalParameter);
     JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
     Type2 stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
   }
   void test_functionExpression_asInvocationArgument_keepIfLessSpecific() {
     String code = EngineTestCase.createSource([
         "class MyList {",
         "  forEach(f(Object value)) {}",
         "}",
         "f(MyList list) {",
         "  list.forEach((int v) {",
         "    v;",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     Type2 intType = typeProvider.intType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
     JUnitTestCase.assertSame(null, vParameter.identifier.propagatedType);
     JUnitTestCase.assertSame(intType, vParameter.identifier.staticType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
     JUnitTestCase.assertSame(intType, vIdentifier.staticType);
     JUnitTestCase.assertSame(null, vIdentifier.propagatedType);
   }
   void test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() {
     String code = EngineTestCase.createSource([
         "class MyList<E> {",
         "  forEach(f(E value)) {}",
         "}",
         "f(MyList<String> list) {",
         "  list.forEach((Object v) {",
         "    v;",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     Type2 stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
     JUnitTestCase.assertSame(typeProvider.objectType, vParameter.identifier.staticType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
     JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
   }
   void test_Future_then() {
     String code = EngineTestCase.createSource([
         "import 'dart:async';",
         "main(Future<int> firstFuture) {",
         "  firstFuture.then((p1) {",
         "    return 1.0;",
         "  }).then((p2) {",
         "    return new Future<String>.value('str');",
         "  }).then((p3) {",
         "  });",
         "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FormalParameter p1 = EngineTestCase.findNode(unit, code, "p1) {", SimpleFormalParameter);
     JUnitTestCase.assertSame(typeProvider.intType, p1.identifier.propagatedType);
     FormalParameter p2 = EngineTestCase.findNode(unit, code, "p2) {", SimpleFormalParameter);
     JUnitTestCase.assertSame(typeProvider.doubleType, p2.identifier.propagatedType);
     FormalParameter p3 = EngineTestCase.findNode(unit, code, "p3) {", SimpleFormalParameter);
     JUnitTestCase.assertSame(typeProvider.stringType, p3.identifier.propagatedType);
   }
   void test_initializer() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 0;", "  return v;", "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
     {
       VariableDeclarationStatement statement = statements[0] as VariableDeclarationStatement;
       SimpleIdentifier variableName = statement.variables.variables[0].name;
       JUnitTestCase.assertSame(typeProvider.dynamicType, variableName.staticType);
       JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
@@ skipping 15 matching lines @@
     SimpleIdentifier variableName = invocation.prefix;
     JUnitTestCase.assertSame(typeProvider.stringType, variableName.propagatedType);
   }
   void test_is_conditional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  return (p is A) ? p : null;",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional = statement.expression as ConditionalExpression;
     SimpleIdentifier variableName = conditional.thenExpression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_if() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  if (p is A) {",
         "    return p;",
         "  } else {",
         "    return null;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_if_lessSpecific() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(A p) {",
-        "  if (p is Object) {",
+        "  if (p is String) {",
         "    return p;",
         "  } else {",
         "    return null;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(null, variableName.propagatedType);
   }
   void test_is_if_logicalAnd() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  if (p is A && p != null) {",
         "    return p;",
         "  } else {",
         "    return null;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_postConditional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  A a = (p is A) ? p : throw null;",
         "  return p;",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_postIf() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  if (p is A) {",
         "    A a = p;",
         "  } else {",
         "    return null;",
         "  }",
         "  return p;",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_subclass() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {",
         "  B m() => this;",
         "}",
         "A f(A p) {",
         "  if (p is B) {",
         "    return p.m();",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_METHOD]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     JUnitTestCase.assertNotNull(invocation.methodName.propagatedElement);
   }
   void test_is_while() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  while (p is A) {",
         "    return p;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
     ReturnStatement statement = ((whileStatement.body as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_conditional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  return (p is! A) ? null : p;",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional = statement.expression as ConditionalExpression;
     SimpleIdentifier variableName = conditional.elseExpression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_if() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  if (p is! A) {",
         "    return null;",
         "  } else {",
         "    return p;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.elseStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_if_logicalOr() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  if (p is! A || null == p) {",
         "    return null;",
         "  } else {",
         "    return p;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.elseStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_postConditional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  A a = (p is! A) ? throw null : p;",
         "  return p;",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_postIf() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  if (p is! A) {",
         "    return null;",
         "  }",
         "  return p;",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_listLiteral_different() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = [0, '1', 2];", "  return v[2];", "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     JUnitTestCase.assertNull(indexExpression.propagatedType);
   }
   void test_listLiteral_same() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = [0, 1, 2];", "  return v[2];", "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     JUnitTestCase.assertSame(typeProvider.intType, indexExpression.propagatedType);
   }
   void test_mapLiteral_different() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  var v = {'0' : 0, 1 : '1', '2' : 2};",
         "  return v;",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType.element);
     List<Type2> typeArguments = propagatedType.typeArguments;
     EngineTestCase.assertLength(2, typeArguments);
     JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[0]);
     JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[1]);
   }
   void test_mapLiteral_same() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  var v = {'a' : 0, 'b' : 1, 'c' : 2};",
         "  return v;",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType.element);
     List<Type2> typeArguments = propagatedType.typeArguments;
     EngineTestCase.assertLength(2, typeArguments);
     JUnitTestCase.assertSame(typeProvider.stringType, typeArguments[0]);
     JUnitTestCase.assertSame(typeProvider.intType, typeArguments[1]);
   }
   void test_propagatedReturnType_function_hasReturnType_returnsNull() {
     String code = EngineTestCase.createSource(["String f() => null;", "main() {", "  var v = f();", "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.stringType);
   }
   void test_propagatedReturnType_function_lessSpecificStaticReturnType() {
     String code = EngineTestCase.createSource(["Object f() => 42;", "main() {", "  var v = f();", "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
   void test_propagatedReturnType_function_moreSpecificStaticReturnType() {
     String code = EngineTestCase.createSource([
-        "int f() => (42 as Object);",
+        "int f(v) => (v as num);",
         "main() {",
-        "  var v = f();",
+        "  var v = f(3);",
         "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
   void test_propagatedReturnType_function_noReturnTypeName_blockBody_multipleReturns() {
     String code = EngineTestCase.createSource([
         "f() {",
         "  if (true) return 0;",
         "  return 1.0;",
         "}",
         "main() {",
@@ skipping 34 matching lines @@
         "  var v7 = query('select#id');",
         "  // invocation of method",
         "  var m1 = document.query('div');",
         " // unsupported currently",
         "  var b1 = query('noSuchTag');",
         "  var b2 = query('DART_EDITOR_NO_SUCH_TYPE');",
         "  var b3 = query('body div');",
         "  return [v1, v2, v3, v4, v5, v6, v7, m1, b1, b2, b3];",
         "}"]));
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration main = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = main.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[11] as ReturnStatement;
     NodeList<Expression> elements = ((statement.expression as ListLiteral)).elements;
     JUnitTestCase.assertEquals("AnchorElement", elements[0].propagatedType.name);
     JUnitTestCase.assertEquals("AnchorElement", elements[1].propagatedType.name);
     JUnitTestCase.assertEquals("BodyElement", elements[2].propagatedType.name);
     JUnitTestCase.assertEquals("ButtonElement", elements[3].propagatedType.name);
     JUnitTestCase.assertEquals("DivElement", elements[4].propagatedType.name);
     JUnitTestCase.assertEquals("InputElement", elements[5].propagatedType.name);
     JUnitTestCase.assertEquals("SelectElement", elements[6].propagatedType.name);
     JUnitTestCase.assertEquals("DivElement", elements[7].propagatedType.name);
     JUnitTestCase.assertEquals("Element", elements[8].propagatedType.name);
     JUnitTestCase.assertEquals("Element", elements[9].propagatedType.name);
     JUnitTestCase.assertEquals("Element", elements[10].propagatedType.name);
   }
 
   /**
    * @param code the code that assigns the value to the variable "v", no matter how. We check that
    *          "v" has expected static and propagated type.
    */
   void check_propagatedReturnType(String code, Type2 expectedStaticType, Type2 expectedPropagatedType) {
     Source source = addSource(code);
     LibraryElement library = resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v = ", SimpleIdentifier);
     JUnitTestCase.assertSame(expectedStaticType, identifier.staticType);
     JUnitTestCase.assertSame(expectedPropagatedType, identifier.propagatedType);
   }
   static dartSuite() {
     _ut.group('TypePropagationTest', () {
       _ut.test('test_Future_then', () {
         final __test = new TypePropagationTest();
@@ skipping 148 matching lines @@
 }
 class NonErrorResolverTest extends ResolverTestCase {
   void test_ambiguousExport() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "export 'lib1.dart';",
         "export 'lib2.dart';"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class M {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_ambiguousExport_combinators_hide() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "export 'lib1.dart';",
         "export 'lib2.dart' hide B;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library L1;", "class A {}", "class B {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library L2;", "class B {}", "class C {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_ambiguousExport_combinators_show() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "export 'lib1.dart';",
         "export 'lib2.dart' show C;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library L1;", "class A {}", "class B {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library L2;", "class B {}", "class C {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_argumentDefinitionTestNonParameter_formalParameter() {
     Source source = addSource(EngineTestCase.createSource(["f(var v) {", "  return ?v;", "}"]));
     resolve(source);
-    assertErrors([ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST]);
+    assertErrors(source, [ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST]);
     verify([source]);
   }
   void test_argumentDefinitionTestNonParameter_namedParameter() {
     Source source = addSource(EngineTestCase.createSource(["f({var v : 0}) {", "  return ?v;", "}"]));
     resolve(source);
-    assertErrors([ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST]);
+    assertErrors(source, [ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST]);
     verify([source]);
   }
   void test_argumentDefinitionTestNonParameter_optionalParameter() {
     Source source = addSource(EngineTestCase.createSource(["f([var v]) {", "  return ?v;", "}"]));
     resolve(source);
-    assertErrors([ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST]);
+    assertErrors(source, [ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_classWithCall_Function() {
     Source source = addSource(EngineTestCase.createSource([
         "  caller(Function callee) {",
         "    callee();",
         "  }",
         "",
         "  class CallMeBack {",
         "    call() => 0;",
         "  }",
         "",
         "  main() {",
         "    caller(new CallMeBack());",
         "  }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_functionParameter_generic() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<K> {",
         "  m(f(K k), K v) {",
         "    f(v);",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_typedef_generic() {
     Source source = addSource(EngineTestCase.createSource(["typedef A<T>(T p);", "f(A<int> a) {", "  a(1);", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_Object_Function() {
     Source source = addSource(EngineTestCase.createSource([
         "main() {",
         "  process(() {});",
         "}",
         "process(Object x) {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_typedef_local() {
     Source source = addSource(EngineTestCase.createSource([
         "typedef A(int p1, String p2);",
         "A getA() => null;",
         "f() {",
         "  A a = getA();",
         "  a(1, '2');",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_typedef_parameter() {
     Source source = addSource(EngineTestCase.createSource([
         "typedef A(int p1, String p2);",
         "f(A a) {",
         "  a(1, '2');",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_assignmentToFinal_prefixNegate() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  -x;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_assignmentToFinals_importWithPrefix() {
     Source source = addSource(EngineTestCase.createSource([
         "library lib;",
         "import 'lib1.dart' as foo;",
         "main() {",
         "  foo.x = true;",
         "}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "bool x = false;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_breakWithoutLabelInSwitch() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void m(int i) {",
         "    switch (i) {",
         "      case 0:",
         "        break;",
         "    }",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_builtInIdentifierAsType_dynamic() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  dynamic x;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_caseBlockNotTerminated() {
     Source source = addSource(EngineTestCase.createSource([
         "f(int p) {",
         "  for (int i = 0; i < 10; i++) {",
         "    switch (p) {",
         "      case 0:",
         "        break;",
         "      case 1:",
         "        continue;",
         "      case 2:",
         "        return;",
         "      case 3:",
         "        throw new Object();",
         "      case 4:",
         "      case 5:",
         "        return;",
         "      case 6:",
         "      default:",
         "        return;",
         "    }",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_caseBlockNotTerminated_lastCase() {
     Source source = addSource(EngineTestCase.createSource([
         "f(int p) {",
         "  switch (p) {",
         "    case 0:",
         "      p = p + 1;",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_caseExpressionTypeImplementsEquals_int() {
     Source source = addSource(EngineTestCase.createSource([
         "f(int i) {",
         "  switch(i) {",
         "    case(1) : return 1;",
         "    default: return 0;",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_caseExpressionTypeImplementsEquals_Object() {
     Source source = addSource(EngineTestCase.createSource([
         "class IntWrapper {",
         "  final int value;",
         "  const IntWrapper(this.value);",
         "}",
         "",
         "f(IntWrapper intWrapper) {",
         "  switch(intWrapper) {",
         "    case(const IntWrapper(1)) : return 1;",
         "    default: return 0;",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_caseExpressionTypeImplementsEquals_String() {
     Source source = addSource(EngineTestCase.createSource([
         "f(String s) {",
         "  switch(s) {",
         "    case('1') : return 1;",
         "    default: return 0;",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_concreteClassWithAbstractMember() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_conflictingInstanceGetterAndSuperclassMember_instance() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  get v => 0;",
         "}",
         "class B extends A {",
         "  get v => 1;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_conflictingStaticGetterAndInstanceSetter_thisClass() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static get x => 0;",
         "  static set x(int p) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_conflictingStaticSetterAndInstanceMember_thisClass_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static x() {}",
         "  static set x(int p) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constConstructorWithNonConstSuper_redirectingFactory() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A();",
         "}",
         "class B implements C {",
         "  const B();",
         "}",
         "class C extends A {",
         "  const factory C() = B;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_finalInstanceVar() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x = 0;", "  const A();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_mixin() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  a() {}",
         "}",
         "class B extends Object with A {",
         "  const B();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static int x;", "  const A();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_syntheticField() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "  set x(value) {}",
         "  get x {return 0;}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constEval_propertyExtraction_fieldStatic_targetType() {
     addSource2("/math.dart", EngineTestCase.createSource(["library math;", "const PI = 3.14;"]));
     Source source = addSource(EngineTestCase.createSource(["import 'math.dart' as math;", "const C = math.PI;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constEval_propertyExtraction_methodStatic_targetType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "  static m() {}",
         "}",
         "const C = A.m;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constEvalTypeBoolNumString_equal() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "class B {",
         "  final v;",
         "  const B.a1(bool p) : v = p == true;",
         "  const B.a2(bool p) : v = p == false;",
         "  const B.a3(bool p) : v = p == 0;",
         "  const B.a4(bool p) : v = p == 0.0;",
         "  const B.a5(bool p) : v = p == '';",
         "  const B.b1(int p) : v = p == true;",
         "  const B.b2(int p) : v = p == false;",
         "  const B.b3(int p) : v = p == 0;",
         "  const B.b4(int p) : v = p == 0.0;",
         "  const B.b5(int p) : v = p == '';",
         "  const B.c1(String p) : v = p == true;",
         "  const B.c2(String p) : v = p == false;",
         "  const B.c3(String p) : v = p == 0;",
         "  const B.c4(String p) : v = p == 0.0;",
         "  const B.c5(String p) : v = p == '';",
         "  const B.n1(num p) : v = p == null;",
         "  const B.n2(num p) : v = null == p;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constEvalTypeBoolNumString_notEqual() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "class B {",
         "  final v;",
         "  const B.a1(bool p) : v = p != true;",
         "  const B.a2(bool p) : v = p != false;",
         "  const B.a3(bool p) : v = p != 0;",
         "  const B.a4(bool p) : v = p != 0.0;",
         "  const B.a5(bool p) : v = p != '';",
         "  const B.b1(int p) : v = p != true;",
         "  const B.b2(int p) : v = p != false;",
         "  const B.b3(int p) : v = p != 0;",
         "  const B.b4(int p) : v = p != 0.0;",
         "  const B.b5(int p) : v = p != '';",
         "  const B.c1(String p) : v = p != true;",
         "  const B.c2(String p) : v = p != false;",
         "  const B.c3(String p) : v = p != 0;",
         "  const B.c4(String p) : v = p != 0.0;",
         "  const B.c5(String p) : v = p != '';",
         "  const B.n1(num p) : v = p != null;",
         "  const B.n2(num p) : v = null != p;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_constNotInitialized_field() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  static const int x = 0;", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_constNotInitialized_local() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  const int x = 0;", "}"]));
+    resolve(source);
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constWithNonConstantArgument_literals() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(a, b, c, d);",
         "}",
         "f() { return const A(true, 0, 1.0, '2'); }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constWithTypeParameters_direct() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<T> {",
         "  static const V = const A<int>();",
         "  const A();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constWithUndefinedConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A.name();",
         "}",
         "f() {",
         "  return const A.name();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_constWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "f() {",
         "  return const A();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_defaultValueInFunctionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef F([x]);"]));
     resolve(source);
-    assertErrors([]);
+    assertNoErrors(source);
     verify([source]);
   }
   void test_defaultValueInFunctionTypedParameter_named() {
     Source source = addSource(EngineTestCase.createSource(["f(g({p})) {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_defaultValueInFunctionTypedParameter_optional() {
     Source source = addSource(EngineTestCase.createSource(["f(g([p])) {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_duplicateDefinition_emptyName() {
     Source source = addSource(EngineTestCase.createSource([
         "Map _globalMap = {",
         "  'a' : () {},",
         "  'b' : () {}",
         "};"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_duplicateDefinition_getter() {
     Source source = addSource(EngineTestCase.createSource(["bool get a => true;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_dynamicIdentifier() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  var v = dynamic;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_exportOfNonLibrary_libraryDeclared() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_exportOfNonLibrary_libraryNotDeclared() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';"]));
     addSource2("/lib1.dart", EngineTestCase.createSource([""]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_extraPositionalArguments_function() {
     Source source = addSource(EngineTestCase.createSource(["f(p1, p2) {}", "main() {", "  f(1, 2);", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_extraPositionalArguments_Function() {
     Source source = addSource(EngineTestCase.createSource(["f(Function a) {", "  a(1, 2);", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_extraPositionalArguments_typedef_local() {
     Source source = addSource(EngineTestCase.createSource([
         "typedef A(p1, p2);",
         "A getA() => null;",
         "f() {",
         "  A a = getA();",
         "  a(1, 2);",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_extraPositionalArguments_typedef_parameter() {
     Source source = addSource(EngineTestCase.createSource(["typedef A(p1, p2);", "f(A a) {", "  a(1, 2);", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_fieldInitializedByMultipleInitializers() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int x;",
         "  int y;",
         "  A() : x = 0, y = 0 {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_fieldInitializedInInitializerAndDeclaration_fieldNotFinal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x = 0;", "  A() : x = 1 {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_fieldInitializedInInitializerAndDeclaration_finalFieldNotSet() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x;", "  A() : x = 1 {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_fieldInitializerOutsideConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_fieldInitializerOutsideConstructor_defaultParameters() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A([this.x]) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_fieldInitializerRedirectingConstructor_super() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "class B extends A {",
         "  int x;",
         "  B(this.x) : super();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_finalInitializedInDeclarationAndConstructor_initializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x;", "  A() : x = 1 {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_finalInitializedInDeclarationAndConstructor_initializingFormal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x;", "  A(this.x) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_finalNotInitialized_atDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x = 0;", "  A() {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_finalNotInitialized_fieldFormal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x = 0;", "  A() {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_finalNotInitialized_functionTypedFieldFormal() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final Function x;",
         "  A(int this.x(int p)) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_finalNotInitialized_hasNativeClause_hasConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A native 'something' {",
         "  final int x;",
         "  A() {}",
         "}"]));
     resolve(source);
-    assertErrors([ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
+    assertErrors(source, [ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
     verify([source]);
   }
   void test_finalNotInitialized_hasNativeClause_noConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A native 'something' {", "  final int x;", "}"]));
     resolve(source);
-    assertErrors([ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
+    assertErrors(source, [ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
     verify([source]);
   }
   void test_finalNotInitialized_initializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x;", "  A() : x = 0 {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_finalNotInitialized_redirectingConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int x;",
         "  A(this.x);",
         "  A.named() : this (42);",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_constructorName() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.named() {}",
         "}",
         "class B {",
         "  var v;",
         "  B() : v = new A.named();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_prefixedIdentifier() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var f;",
         "}",
         "class B {",
         "  var v;",
         "  B(A a) : v = a.f;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_qualifiedMethodInvocation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  f() {}",
         "}",
         "class B {",
         "  var v;",
         "  B() : v = new A().f();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_qualifiedPropertyAccess() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var f;",
         "}",
         "class B {",
         "  var v;",
         "  B() : v = new A().f;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_staticField_thisClass() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var v;",
         "  A() : v = f;",
         "  static var f;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_staticGetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var v;",
         "  A() : v = f;",
         "  static get f => 42;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_staticMethod() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var v;",
         "  A() : v = f();",
         "  static f() => 42;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_topLevelField() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var v;",
         "  A() : v = f;",
         "}",
         "var f = 42;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_topLevelFunction() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var v;",
         "  A() : v = f();",
         "}",
         "f() => 42;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_topLevelGetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var v;",
         "  A() : v = f;",
         "}",
         "get f => 42;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
-  void test_implicitThisReferenceInInitializer_typeVariable() {
+  void test_implicitThisReferenceInInitializer_typeParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  var v;", "  A(p) : v = (p is T);", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_importDuplicatedLibraryName() {
     Source source = addSource(EngineTestCase.createSource([
         "library test;",
         "import 'lib.dart';",
         "import 'lib.dart';"]));
     addSource2("/lib.dart", "library lib;");
     resolve(source);
-    assertErrors([HintCode.UNUSED_IMPORT, HintCode.UNUSED_IMPORT]);
+    assertErrors(source, [
+        HintCode.UNUSED_IMPORT,
+        HintCode.UNUSED_IMPORT,
+        HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
   void test_importOfNonLibrary_libraryDeclared() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';", "A a;"]));
     addSource2("/part.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_importOfNonLibrary_libraryNotDeclared() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';", "A a;"]));
     addSource2("/part.dart", EngineTestCase.createSource(["class A {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_inconsistentCaseExpressionTypes() {
     Source source = addSource(EngineTestCase.createSource([
         "f(var p) {",
         "  switch (p) {",
         "    case 1:",
         "      break;",
         "    case 2:",
         "      break;",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
-  void test_inconsistentMethodInheritance_accessors_typeVariables_diamond() {
+  void test_inconsistentMethodInheritance_accessors_typeParameter2() {
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A<E> {",
+        "  E get x {return 1;}",
+        "}",
+        "class B<E> {",
+        "  E get x {return 1;}",
+        "}",
+        "class C<E> extends A<E> implements B<E> {",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_inconsistentMethodInheritance_accessors_typeParameters_diamond() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class F<E> extends B<E> {}",
         "class D<E> extends F<E> {",
         "  external E get g;",
         "}",
         "abstract class C<E> {",
         "  E get g;",
         "}",
         "abstract class B<E> implements C<E> {",
         "  E get g { return null; }",
         "}",
         "class A<E> extends B<E> implements D<E> {",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
-  void test_inconsistentMethodInheritance_accessors_typeVariables1() {
+  void test_inconsistentMethodInheritance_accessors_typeParameters1() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A<E> {",
         "  E get x;",
         "}",
         "abstract class B<E> {",
         "  E get x;",
         "}",
         "class C<E> implements A<E>, B<E> {",
         "  E get x => 1;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
-  void test_inconsistentMethodInheritance_accessors_typeVariables2() {
-    Source source = addSource(EngineTestCase.createSource([
-        "abstract class A<E> {",
-        "  E get x {return 1;}",
-        "}",
-        "class B<E> {",
-        "  E get x {return 1;}",
-        "}",
-        "class C<E> extends A<E> implements B<E> {",
-        "}"]));
-    resolve(source);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_inconsistentMethodInheritance_methods_typeVariables1() {
+  void test_inconsistentMethodInheritance_methods_typeParameter2() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<E> {",
         "  x(E e) {}",
         "}",
         "class B<E> {",
         "  x(E e) {}",
         "}",
-        "class C<E> implements A<E>, B<E> {",
+        "class C<E> extends A<E> implements B<E> {",
         "  x(E e) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
-  void test_inconsistentMethodInheritance_methods_typeVariables2() {
+  void test_inconsistentMethodInheritance_methods_typeParameters1() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<E> {",
         "  x(E e) {}",
         "}",
         "class B<E> {",
         "  x(E e) {}",
         "}",
-        "class C<E> extends A<E> implements B<E> {",
+        "class C<E> implements A<E>, B<E> {",
         "  x(E e) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_inconsistentMethodInheritance_simple() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  x();",
         "}",
         "abstract class B {",
         "  x();",
         "}",
         "class C implements A, B {",
         "  x() {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_initializingFormalForNonExistantField() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_instanceAccessToStaticMember_fromComment() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static m() {}",
         "}",
         "/// [A.m]",
         "main() {",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_instanceAccessToStaticMember_topLevel() {
     Source source = addSource(EngineTestCase.createSource(["m() {}", "main() {", "  m();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_instanceMemberAccessFromStatic_fromComment() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "  /// [m]",
         "  static foo() {",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidAnnotation_constantVariable() {
     Source source = addSource(EngineTestCase.createSource(["const C = 0;", "@C", "main() {", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidAnnotation_importWithPrefix_constantVariable() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "const C = 0;"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "@p.C", "main() {", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidAnnotation_importWithPrefix_constConstructor() {
     addSource2("/lib.dart", EngineTestCase.createSource([
         "library lib;",
         "class A {",
         "  const A.named(int p);",
         "}"]));
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib.dart' as p;",
         "@p.A.named(42)",
         "main() {",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidAssignment() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var x;", "  var y;", "  x = y;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidAssignment_compoundAssignment() {
     Source source = addSource(EngineTestCase.createSource([
         "class byte {",
         "  int _value;",
         "  byte(this._value);",
         "  byte operator +(int val) {}",
         "}",
         "",
         "void main() {",
         "  byte b = new byte(52);",
         "  b += 3;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidAssignment_defaultValue_named() {
     Source source = addSource(EngineTestCase.createSource(["f({String x: '0'}) {", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidAssignment_defaultValue_optional() {
     Source source = addSource(EngineTestCase.createSource(["f([String x = '0']) {", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidAssignment_toDynamic() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var g;", "  g = () => 0;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidFactoryNameNotAClass() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A() {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidMethodOverrideNamedParamType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m({int a}) {}",
         "}",
         "class B implements A {",
         "  m({int a, int b}) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideDifferentDefaultValues_named() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m({int p : 0}) {}",
         "}",
         "class B extends A {",
         "  m({int p : 0}) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideDifferentDefaultValues_positional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m([int p = 0]) {}",
         "}",
         "class B extends A {",
         "  m([int p = 0]) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideDifferentDefaultValues_positional_changedOrder() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m([int a = 0, String b = '0']) {}",
         "}",
         "class B extends A {",
         "  m([int b = 0, String a = '0']) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideNamed_unorderedNamedParameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m({a, b}) {}",
         "}",
         "class B extends A {",
         "  m({b, a}) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_invalidOverrideRequired_less() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m(a, b) {}",
+        "}",
+        "class B extends A {",
+        "  m(a) {}",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_invalidOverrideRequired_same() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m(a) {}",
+        "}",
+        "class B extends A {",
+        "  m(a) {}",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_interface() {
     Source source = addSource2("/test.dart", EngineTestCase.createSource([
         "abstract class A {",
         "  num m();",
         "}",
         "class B implements A {",
         "  int m() { return 1; }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_interface2() {
     Source source = addSource2("/test.dart", EngineTestCase.createSource([
         "abstract class A {",
         "  num m();",
         "}",
         "abstract class B implements A {",
         "}",
         "class C implements B {",
         "  int m() { return 1; }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_mixin() {
     Source source = addSource2("/test.dart", EngineTestCase.createSource([
         "class A {",
         "  num m() { return 0; }",
         "}",
         "class B extends Object with A {",
         "  int m() { return 1; }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_parameterizedTypes() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A<E> {",
         "  List<E> m();",
         "}",
         "class B extends A<dynamic> {",
         "  List<dynamic> m() { return new List<dynamic>(); }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_sameType() {
     Source source = addSource2("/test.dart", EngineTestCase.createSource([
         "class A {",
         "  int m() { return 0; }",
         "}",
         "class B extends A {",
         "  int m() { return 1; }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_superclass() {
     Source source = addSource2("/test.dart", EngineTestCase.createSource([
         "class A {",
         "  num m() { return 0; }",
         "}",
         "class B extends A {",
         "  int m() { return 1; }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_superclass2() {
     Source source = addSource2("/test.dart", EngineTestCase.createSource([
         "class A {",
         "  num m() { return 0; }",
         "}",
         "class B extends A {",
         "}",
         "class C extends B {",
         "  int m() { return 1; }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_void() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void m() {}",
         "}",
         "class B extends A {",
         "  int m() {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidReferenceToThis_constructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {", "    var v = this;", "  }", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidReferenceToThis_instanceMethod() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {", "    var v = this;", "  }", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidTypeArgumentForKey() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {",
         "    return const <int, int>{};",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidTypeArgumentInConstList() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<E> {",
         "  m() {",
         "    return <E>[];",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invalidTypeArgumentInConstMap() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<E> {",
         "  m() {",
         "    return <String, E>{};",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invocationOfNonFunction_dynamic() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var f;",
         "}",
         "class B extends A {",
         "  g() {",
         "    f();",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invocationOfNonFunction_getter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var g;",
         "}",
         "f() {",
         "  A a;",
         "  a.g();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invocationOfNonFunction_localVariable() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var g;", "  g();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invocationOfNonFunction_localVariable_dynamic() {
     Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", "  var v = f;", "  v();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invocationOfNonFunction_localVariable_dynamic2() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {}",
         "main() {",
         "  var v = f;",
         "  v = 1;",
         "  v();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invocationOfNonFunction_Object() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  Object v = null;", "  v();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_listElementTypeNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["var v1 = <int> [42];", "var v2 = const <int> [42];"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_mapKeyTypeNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["var v = <String, int > {'a' : 1};"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_memberWithClassName_setter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set A(v) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_instance_sameTypes() {
     Source source = addSource(EngineTestCase.createSource([
         "class C {",
         "  int get x => 0;",
         "  set x(int v) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_instance_unspecifiedGetter() {
     Source source = addSource(EngineTestCase.createSource(["class C {", "  get x => 0;", "  set x(String v) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_instance_unspecifiedSetter() {
     Source source = addSource(EngineTestCase.createSource(["class C {", "  int get x => 0;", "  set x(v) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_topLevel_sameTypes() {
     Source source = addSource(EngineTestCase.createSource(["int get x => 0;", "set x(int v) {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_topLevel_unspecifiedGetter() {
     Source source = addSource(EngineTestCase.createSource(["get x => 0;", "set x(String v) {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_topLevel_unspecifiedSetter() {
     Source source = addSource(EngineTestCase.createSource(["int get x => 0;", "set x(v) {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_mixinDeclaresConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "}",
         "class B extends Object with A {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_mixinDeclaresConstructor_factory() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  factory A() {}",
         "}",
         "class B extends Object with A {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_classDeclaration_mixTypedef() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "typedef B = Object with A;",
         "class C extends Object with B {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_typedef_mixTypedef() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "typedef B = Object with A;",
         "typedef C = Object with B;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_multipleSuperInitializers_no() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {", "  B() {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_multipleSuperInitializers_single() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {",
         "  B() : super() {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_newWithAbstractClass_factory() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  factory A() { return new B(); }",
         "}",
         "class B implements A {",
         "  B() {}",
         "}",
         "A f() {",
         "  return new A();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_newWithUndefinedConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.name() {}",
         "}",
         "f() {",
         "  new A.name();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_newWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "f() {", "  new A();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_accessor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get g => 0;",
         "}",
         "abstract class B extends A {",
         "  int get g;",
         "}",
         "class C extends B {",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m(p) {}",
         "}",
         "abstract class B extends A {",
         "  m(p);",
         "}",
         "class C extends B {",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonBoolExpression_functionType() {
     Source source = addSource(EngineTestCase.createSource([
         "bool makeAssertion() => true;",
         "f() {",
         "  assert(makeAssertion);",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonBoolExpression_interfaceType() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  assert(true);", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstantDefaultValue_function_named() {
     Source source = addSource(EngineTestCase.createSource(["f({x : 2 + 3}) {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstantDefaultValue_function_positional() {
     Source source = addSource(EngineTestCase.createSource(["f([x = 2 + 3]) {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstantDefaultValue_inConstructor_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A({x : 2 + 3}) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstantDefaultValue_inConstructor_positional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A([x = 2 + 3]) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstantDefaultValue_method_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m({x : 2 + 3}) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstantDefaultValue_method_positional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m([x = 2 + 3]) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstantValueInInitializer_namedArgument() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final a;",
         "  const A({this.a});",
         "}",
         "class B extends A {",
         "  const B({b}) : super(a: b);",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstCaseExpression() {
     Source source = addSource(EngineTestCase.createSource([
         "f(Type t) {",
         "  switch (t) {",
         "    case bool:",
         "    case int:",
         "      return true;",
         "    default:",
         "      return false;",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstMapAsExpressionStatement_const() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  const {'a' : 0, 'b' : 1};", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstMapAsExpressionStatement_notExpressionStatement() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var m = {'a' : 0, 'b' : 1};", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstMapAsExpressionStatement_typeArguments() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  <String, int> {'a' : 0, 'b' : 1};", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_bool() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final v;",
         "  const A.a1(bool p) : v = p && true;",
         "  const A.a2(bool p) : v = true && p;",
         "  const A.b1(bool p) : v = p || true;",
         "  const A.b2(bool p) : v = true || p;",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_dynamic() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final v;",
         "  const A.a1(p) : v = p + 5;",
         "  const A.a2(p) : v = 5 + p;",
         "  const A.b1(p) : v = p - 5;",
         "  const A.b2(p) : v = 5 - p;",
         "  const A.c1(p) : v = p * 5;",
         "  const A.c2(p) : v = 5 * p;",
         "  const A.d1(p) : v = p / 5;",
         "  const A.d2(p) : v = 5 / p;",
         "  const A.e1(p) : v = p ~/ 5;",
         "  const A.e2(p) : v = 5 ~/ p;",
         "  const A.f1(p) : v = p > 5;",
         "  const A.f2(p) : v = 5 > p;",
         "  const A.g1(p) : v = p < 5;",
         "  const A.g2(p) : v = 5 < p;",
         "  const A.h1(p) : v = p >= 5;",
         "  const A.h2(p) : v = 5 >= p;",
         "  const A.i1(p) : v = p <= 5;",
         "  const A.i2(p) : v = 5 <= p;",
         "  const A.j1(p) : v = p % 5;",
         "  const A.j2(p) : v = 5 % p;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_nonConstValueInInitializer_binary_int() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final v;",
         "  const A.a1(int p) : v = p ^ 5;",
         "  const A.a2(int p) : v = 5 ^ p;",
         "  const A.b1(int p) : v = p & 5;",
         "  const A.b2(int p) : v = 5 & p;",
         "  const A.c1(int p) : v = p | 5;",
         "  const A.c2(int p) : v = 5 | p;",
         "  const A.d1(int p) : v = p >> 5;",
         "  const A.d2(int p) : v = 5 >> p;",
         "  const A.e1(int p) : v = p << 5;",
         "  const A.e2(int p) : v = 5 << p;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_num() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final v;",
         "  const A.a1(num p) : v = p + 5;",
         "  const A.a2(num p) : v = 5 + p;",
         "  const A.b1(num p) : v = p - 5;",
         "  const A.b2(num p) : v = 5 - p;",
         "  const A.c1(num p) : v = p * 5;",
         "  const A.c2(num p) : v = 5 * p;",
         "  const A.d1(num p) : v = p / 5;",
         "  const A.d2(num p) : v = 5 / p;",
         "  const A.e1(num p) : v = p ~/ 5;",
         "  const A.e2(num p) : v = 5 ~/ p;",
         "  const A.f1(num p) : v = p > 5;",
         "  const A.f2(num p) : v = 5 > p;",
         "  const A.g1(num p) : v = p < 5;",
         "  const A.g2(num p) : v = 5 < p;",
         "  const A.h1(num p) : v = p >= 5;",
         "  const A.h2(num p) : v = 5 >= p;",
         "  const A.i1(num p) : v = p <= 5;",
         "  const A.i2(num p) : v = 5 <= p;",
         "  const A.j1(num p) : v = p % 5;",
         "  const A.j2(num p) : v = 5 % p;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstValueInInitializer_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int a;",
         "  const A() : a = 5;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstValueInInitializer_redirecting() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A.named(p);",
         "  const A() : this.named(42);",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstValueInInitializer_super() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(p);",
         "}",
         "class B extends A {",
         "  const B() : super(42);",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonConstValueInInitializer_unary() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final v;",
         "  const A.a(bool p) : v = !p;",
         "  const A.b(int p) : v = ~p;",
         "  const A.c(num p) : v = -p;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonGenerativeConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.named() {}",
         "  factory A() {}",
         "}",
         "class B extends A {",
         "  B() : super.named();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonTypeInCatchClause_isClass() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  try {",
         "  } on String catch (e) {",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonTypeInCatchClause_isFunctionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "typedef F();",
         "f() {",
         "  try {",
         "  } on F catch (e) {",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
-  void test_nonTypeInCatchClause_isTypeVariable() {
+  void test_nonTypeInCatchClause_isTypeParameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<T> {",
         "  f() {",
         "    try {",
         "    } on T catch (e) {",
         "    }",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonTypeInCatchClause_noType() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  try {", "  } catch (e) {", "  }", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonVoidReturnForOperator_no() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator []=(a, b) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonVoidReturnForOperator_void() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  void operator []=(a, b) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonVoidReturnForSetter_function_no() {
     Source source = addSource("set x(v) {}");
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonVoidReturnForSetter_function_void() {
     Source source = addSource("void set x(v) {}");
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonVoidReturnForSetter_method_no() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set x(v) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_nonVoidReturnForSetter_method_void() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  void set x(v) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_optionalParameterInOperator_required() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator +(p) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A {}"]));
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib.dart' as p;",
         "typedef P();",
         "p2() {}",
         "var p3;",
         "class p4 {}",
         "p.A a;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_proxy_annotation_prefixed() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'meta.dart';",
         "@proxy",
         "class A {}",
         "f(A a) {",
         "  a.m();",
         "  var x = a.g;",
         "  a.s = 1;",
         "  var y = a + a;",
         "  a++;",
         "  ++a;",
         "}"]));
     addSource2("/meta.dart", EngineTestCase.createSource([
         "library meta;",
         "const proxy = const _Proxy();",
         "class _Proxy { const _Proxy(); }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_proxy_annotation_prefixed2() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'meta.dart';",
         "@proxy",
         "class A {}",
         "class B {",
         "  f(A a) {",
         "    a.m();",
         "    var x = a.g;",
         "    a.s = 1;",
         "    var y = a + a;",
         "    a++;",
         "    ++a;",
         "  }",
         "}"]));
     addSource2("/meta.dart", EngineTestCase.createSource([
         "library meta;",
         "const proxy = const _Proxy();",
         "class _Proxy { const _Proxy(); }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_proxy_annotation_prefixed3() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'meta.dart';",
         "class B {",
         "  f(A a) {",
         "    a.m();",
         "    var x = a.g;",
         "    a.s = 1;",
         "    var y = a + a;",
         "    a++;",
         "    ++a;",
         "  }",
         "}",
         "@proxy",
         "class A {}"]));
     addSource2("/meta.dart", EngineTestCase.createSource([
         "library meta;",
         "const proxy = const _Proxy();",
         "class _Proxy { const _Proxy(); }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_proxy_annotation_simple() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'meta.dart';",
         "@proxy",
         "class B {",
         "  m() {",
         "    n();",
         "    var x = g;",
         "    s = 1;",
         "    var y = this + this;",
         "  }",
         "}"]));
     addSource2("/meta.dart", EngineTestCase.createSource([
         "library meta;",
         "const proxy = const _Proxy();",
         "class _Proxy { const _Proxy(); }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_recursiveConstructorRedirect() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.a() : this.b();",
         "  A.b() : this.c();",
         "  A.c() {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_recursiveFactoryRedirect() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  factory A() = B;",
         "}",
         "class B implements A {",
         "  factory B() = C;",
         "}",
         "class C implements B {",
         "  factory C() {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_redirectToInvalidFunctionType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A implements B {",
         "  A(int p) {}",
         "}",
         "class B {",
         "  factory B(int p) = A;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_redirectToNonConstConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A.a();",
         "  const factory A.b() = A.a;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_constructorName() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.x() {}",
         "}",
         "f() {",
         "  var x = new A.x();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_methodName() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  x() {}",
         "}",
         "f(A a) {",
         "  var x = a.x();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_propertyName() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var x;",
         "}",
         "f(A a) {",
         "  var x = a.x;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_rethrowOutsideCatch() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void m() {",
         "    try {} catch (e) {rethrow;}",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_returnInGenerativeConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() { return; }", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_returnOfInvalidType_dynamic() {
     Source source = addSource(EngineTestCase.createSource([
         "class TypeError {}",
         "class A {",
         "  static void testLogicalOp() {",
         "    testOr(a, b, onTypeError) {",
         "      try {",
         "        return a || b;",
         "      } on TypeError catch (t) {",
         "        return onTypeError;",
         "      }",
         "    }",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_returnOfInvalidType_dynamicAsTypeArgument() {
     Source source = addSource(EngineTestCase.createSource([
         "class I<T> {",
         "  factory I() => new A<T>();",
         "}",
         "class A<T> implements I {",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_returnOfInvalidType_subtype() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "A f(B b) { return b; }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_returnOfInvalidType_supertype() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "B f(A a) { return a; }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_returnOfInvalidType_void() {
     Source source = addSource(EngineTestCase.createSource([
         "void f1() {}",
         "void f2() { return; }",
         "void f3() { return null; }",
         "void f4() { return g1(); }",
         "void f5() { return g2(); }",
         "g1() {}",
         "void g2() {}",
         ""]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_returnWithoutValue_noReturnType() {
     Source source = addSource(EngineTestCase.createSource(["f() { return; }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_returnWithoutValue_void() {
     Source source = addSource(EngineTestCase.createSource(["void f() { return; }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_annotation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A.name();",
         "}",
         "@A.name()",
         "main() {",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static m() {}",
         "}",
         "main() {",
         "  A.m;",
         "  A.m();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_propertyAccess_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static var f;",
         "}",
         "main() {",
         "  A.f;",
         "  A.f = 1;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_propertyAccess_propertyAccessor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static get f => 42;",
         "  static set f(x) {}",
         "}",
         "main() {",
         "  A.f;",
         "  A.f = 1;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_superInInvalidContext() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "}",
         "class B extends A {",
         "  B() {",
         "    var v = super.m();",
         "  }",
         "  n() {",
         "    var v = super.m();",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_returnClass_withTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef B A();", "class B {", "  A a;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
-  void test_typeAliasCannotReferenceItself_typeVariableBounds() {
+  void test_typeAliasCannotReferenceItself_typeParameterBounds() {
     Source source = addSource(EngineTestCase.createSource(["typedef A<T extends A>();"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_const() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "class G<E extends A> {",
         "  const G();",
         "}",
         "f() { return const G<B>(); }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_new() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "class G<E extends A> {}",
         "f() { return new G<B>(); }"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_typeArgumentList_0() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A<T extends A>{}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_typeArgumentList_1() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A<T extends A<A>>{}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_typeArgumentList_20() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A<T extends A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A>>>>>>>>>>>>>>>>>>>>>{}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_explicit_named() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.named() {}",
         "}",
         "class B extends A {",
         "  B() : super.named();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_explicit_unnamed() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "class B extends A {",
         "  B() : super();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_hasOptionalParameters() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A([p]) {}",
         "}",
         "class B extends A {",
         "  B();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_implicit() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "class B extends A {",
         "  B();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_implicit_typedef() {
     Source source = addSource(EngineTestCase.createSource([
         "class M {}",
         "typedef A = Object with M;",
         "class B extends A {",
         "  B();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_redirecting() {
     Source source = addSource(EngineTestCase.createSource([
         "class Foo {",
         "  Foo.ctor();",
         "}",
         "class Bar extends Foo {",
         "  Bar() : this.ctor();",
         "  Bar.ctor() : super.ctor();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedGetter_typeSubstitution() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<E> {",
         "  E element;",
         "}",
         "class B extends A<List> {",
         "  m() {",
         "    element.last;",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedIdentifier_hide() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart' hide a;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedIdentifier_show() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart' show a;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedMethod_functionExpression_callMethod() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  (() => null).call();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_undefinedMethod_functionExpression_directCall() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  (() => null)();", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_undefinedOperator_index() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  operator [](a) {}",
         "  operator []=(a, b) {}",
         "}",
         "f(A a) {",
         "  a[0];",
         "  a[0] = 1;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedOperator_tilde() {
     Source source = addSource(EngineTestCase.createSource(["const A = 3;", "const B = ~((1 << A) - 1);"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedSetter_importWithPrefix() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "set y(int value) {}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as x;", "main() {", "  x.y = 0;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedSuperMethod_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var m;",
         "}",
         "class B extends A {",
         "  f() {",
         "    super.m();",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedSuperMethod_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "}",
         "class B extends A {",
         "  f() {",
         "    super.m();",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_wrongNumberOfParametersForOperator_index() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator []=(a, b) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_wrongNumberOfParametersForOperator_minus() {
     check_wrongNumberOfParametersForOperator("-", "");
     check_wrongNumberOfParametersForOperator("-", "a");
   }
   void test_wrongNumberOfParametersForOperator1() {
     check_wrongNumberOfParametersForOperator1("<");
     check_wrongNumberOfParametersForOperator1(">");
     check_wrongNumberOfParametersForOperator1("<=");
     check_wrongNumberOfParametersForOperator1(">=");
     check_wrongNumberOfParametersForOperator1("+");
     check_wrongNumberOfParametersForOperator1("/");
     check_wrongNumberOfParametersForOperator1("~/");
     check_wrongNumberOfParametersForOperator1("*");
     check_wrongNumberOfParametersForOperator1("%");
     check_wrongNumberOfParametersForOperator1("|");
     check_wrongNumberOfParametersForOperator1("^");
     check_wrongNumberOfParametersForOperator1("&");
     check_wrongNumberOfParametersForOperator1("<<");
     check_wrongNumberOfParametersForOperator1(">>");
     check_wrongNumberOfParametersForOperator1("[]");
   }
   void test_wrongNumberOfParametersForSetter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set x(a) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void check_wrongNumberOfParametersForOperator(String name, String parameters) {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator ${name}(${parameters}) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
     reset();
   }
   void check_wrongNumberOfParametersForOperator1(String name) {
     check_wrongNumberOfParametersForOperator(name, "a");
   }
   static dartSuite() {
     _ut.group('NonErrorResolverTest', () {
       _ut.test('test_ambiguousExport', () {
         final __test = new NonErrorResolverTest();
@@ skipping 124 matching lines @@
         runJUnitTest(__test, __test.test_constEvalTypeBoolNumString_notEqual);
       });
       _ut.test('test_constEval_propertyExtraction_fieldStatic_targetType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constEval_propertyExtraction_fieldStatic_targetType);
       });
       _ut.test('test_constEval_propertyExtraction_methodStatic_targetType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constEval_propertyExtraction_methodStatic_targetType);
       });
+      _ut.test('test_constNotInitialized_field', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_constNotInitialized_field);
+      });
+      _ut.test('test_constNotInitialized_local', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_constNotInitialized_local);
+      });
       _ut.test('test_constWithNonConstantArgument_literals', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constWithNonConstantArgument_literals);
       });
       _ut.test('test_constWithTypeParameters_direct', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constWithTypeParameters_direct);
       });
       _ut.test('test_constWithUndefinedConstructor', () {
         final __test = new NonErrorResolverTest();
@@ skipping 144 matching lines @@
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_topLevelField);
       });
       _ut.test('test_implicitThisReferenceInInitializer_topLevelFunction', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_topLevelFunction);
       });
       _ut.test('test_implicitThisReferenceInInitializer_topLevelGetter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_topLevelGetter);
       });
-      _ut.test('test_implicitThisReferenceInInitializer_typeVariable', () {
+      _ut.test('test_implicitThisReferenceInInitializer_typeParameter', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_typeVariable);
+        runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_typeParameter);
       });
       _ut.test('test_importDuplicatedLibraryName', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_importDuplicatedLibraryName);
       });
       _ut.test('test_importOfNonLibrary_libraryDeclared', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_importOfNonLibrary_libraryDeclared);
       });
       _ut.test('test_importOfNonLibrary_libraryNotDeclared', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_importOfNonLibrary_libraryNotDeclared);
       });
       _ut.test('test_inconsistentCaseExpressionTypes', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_inconsistentCaseExpressionTypes);
       });
-      _ut.test('test_inconsistentMethodInheritance_accessors_typeVariables1', () {
+      _ut.test('test_inconsistentMethodInheritance_accessors_typeParameter2', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_accessors_typeVariables1);
+        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_accessors_typeParameter2);
       });
-      _ut.test('test_inconsistentMethodInheritance_accessors_typeVariables2', () {
+      _ut.test('test_inconsistentMethodInheritance_accessors_typeParameters1', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_accessors_typeVariables2);
+        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_accessors_typeParameters1);
       });
-      _ut.test('test_inconsistentMethodInheritance_accessors_typeVariables_diamond', () {
+      _ut.test('test_inconsistentMethodInheritance_accessors_typeParameters_diamond', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_accessors_typeVariables_diamond);
+        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_accessors_typeParameters_diamond);
       });
-      _ut.test('test_inconsistentMethodInheritance_methods_typeVariables1', () {
+      _ut.test('test_inconsistentMethodInheritance_methods_typeParameter2', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_methods_typeVariables1);
+        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_methods_typeParameter2);
       });
-      _ut.test('test_inconsistentMethodInheritance_methods_typeVariables2', () {
+      _ut.test('test_inconsistentMethodInheritance_methods_typeParameters1', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_methods_typeVariables2);
+        runJUnitTest(__test, __test.test_inconsistentMethodInheritance_methods_typeParameters1);
       });
       _ut.test('test_inconsistentMethodInheritance_simple', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_inconsistentMethodInheritance_simple);
       });
       _ut.test('test_initializingFormalForNonExistantField', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_initializingFormalForNonExistantField);
       });
       _ut.test('test_instanceAccessToStaticMember_fromComment', () {
@@ skipping 57 matching lines @@
         runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_positional);
       });
       _ut.test('test_invalidOverrideDifferentDefaultValues_positional_changedOrder', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_positional_changedOrder);
       });
       _ut.test('test_invalidOverrideNamed_unorderedNamedParameter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidOverrideNamed_unorderedNamedParameter);
       });
+      _ut.test('test_invalidOverrideRequired_less', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invalidOverrideRequired_less);
+      });
+      _ut.test('test_invalidOverrideRequired_same', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invalidOverrideRequired_same);
+      });
       _ut.test('test_invalidOverrideReturnType_returnType_interface', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidOverrideReturnType_returnType_interface);
       });
       _ut.test('test_invalidOverrideReturnType_returnType_interface2', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidOverrideReturnType_returnType_interface2);
       });
       _ut.test('test_invalidOverrideReturnType_returnType_mixin', () {
         final __test = new NonErrorResolverTest();
@@ skipping 232 matching lines @@
         runJUnitTest(__test, __test.test_nonGenerativeConstructor);
       });
       _ut.test('test_nonTypeInCatchClause_isClass', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonTypeInCatchClause_isClass);
       });
       _ut.test('test_nonTypeInCatchClause_isFunctionTypeAlias', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonTypeInCatchClause_isFunctionTypeAlias);
       });
-      _ut.test('test_nonTypeInCatchClause_isTypeVariable', () {
+      _ut.test('test_nonTypeInCatchClause_isTypeParameter', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_nonTypeInCatchClause_isTypeVariable);
+        runJUnitTest(__test, __test.test_nonTypeInCatchClause_isTypeParameter);
       });
       _ut.test('test_nonTypeInCatchClause_noType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonTypeInCatchClause_noType);
       });
       _ut.test('test_nonVoidReturnForOperator_no', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonVoidReturnForOperator_no);
       });
       _ut.test('test_nonVoidReturnForOperator_void', () {
@@ skipping 121 matching lines @@
         runJUnitTest(__test, __test.test_staticAccessToInstanceMember_propertyAccess_propertyAccessor);
       });
       _ut.test('test_superInInvalidContext', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_superInInvalidContext);
       });
       _ut.test('test_typeAliasCannotReferenceItself_returnClass_withTypeAlias', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_returnClass_withTypeAlias);
       });
-      _ut.test('test_typeAliasCannotReferenceItself_typeVariableBounds', () {
+      _ut.test('test_typeAliasCannotReferenceItself_typeParameterBounds', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_typeVariableBounds);
+        runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_typeParameterBounds);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_const', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_new', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_0', () {
@@ skipping 216 matching lines @@
         final __test = new LibraryTest();
         runJUnitTest(__test, __test.test_setLibraryElement);
       });
     });
   }
 }
 class StaticTypeWarningCodeTest extends ResolverTestCase {
   void fail_inaccessibleSetter() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INACCESSIBLE_SETTER]);
+    assertErrors(source, [StaticTypeWarningCode.INACCESSIBLE_SETTER]);
     verify([source]);
   }
   void test_inconsistentMethodInheritance_paramCount() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int x();",
         "}",
         "abstract class B {",
         "  int x(int y);",
         "}",
         "class C implements A, B {",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
+    assertErrors(source, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
     verify([source]);
   }
   void test_inconsistentMethodInheritance_paramType() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  x(int i);",
         "}",
         "abstract class B {",
         "  x(String s);",
         "}",
         "abstract class C implements A, B {}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
+    assertErrors(source, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
     verify([source]);
   }
   void test_inconsistentMethodInheritance_returnType() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int x();",
         "}",
         "abstract class B {",
         "  String x();",
         "}",
         "abstract class C implements A, B {}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
+    assertErrors(source, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
     verify([source]);
   }
   void test_instanceAccessToStaticMember_method_invocation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static m() {}",
         "}",
         "main(A a) {",
         "  a.m();",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
+    assertErrors(source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
     verify([source]);
   }
   void test_instanceAccessToStaticMember_method_reference() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static m() {}",
         "}",
         "main(A a) {",
         "  a.m;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
+    assertErrors(source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
     verify([source]);
   }
   void test_instanceAccessToStaticMember_propertyAccess_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static var f;",
         "}",
         "main(A a) {",
         "  a.f;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
+    assertErrors(source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
     verify([source]);
   }
   void test_instanceAccessToStaticMember_propertyAccess_getter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static get f => 42;",
         "}",
         "main(A a) {",
         "  a.f;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
+    assertErrors(source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
     verify([source]);
   }
   void test_instanceAccessToStaticMember_propertyAccess_setter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static set f(x) {}",
         "}",
         "main(A a) {",
         "  a.f = 42;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
+    assertErrors(source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
     verify([source]);
   }
   void test_invalidAssignment_compoundAssignment() {
     Source source = addSource(EngineTestCase.createSource([
         "class byte {",
         "  int _value;",
         "  byte(this._value);",
         "  int operator +(int val) {}",
         "}",
         "",
         "void main() {",
         "  byte b = new byte(52);",
         "  b += 3;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_invalidAssignment_defaultValue_named() {
     Source source = addSource(EngineTestCase.createSource(["f({String x: 0}) {", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_invalidAssignment_defaultValue_optional() {
     Source source = addSource(EngineTestCase.createSource(["f([String x = 0]) {", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_invalidAssignment_instanceVariable() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int x;",
         "}",
         "f() {",
         "  A a;",
         "  a.x = '0';",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_invalidAssignment_localVariable() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  int x;", "  x = '0';", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_invalidAssignment_staticVariable() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int x;",
         "}",
         "f() {",
         "  A.x = '0';",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_invalidAssignment_topLevelVariableDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["int x = 'string';"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_invalidAssignment_variableDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x = 'string';", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_invocationOfNonFunction_class() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  void m() {", "    A();", "  }", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
+    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
   void test_invocationOfNonFunction_localVariable() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  int x;", "  return x();", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
+    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
     verify([source]);
   }
   void test_invocationOfNonFunction_ordinaryInvocation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int x;",
         "}",
         "class B {",
         "  m() {",
         "    A.x();",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
+    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
   void test_invocationOfNonFunction_staticInvocation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int get g => 0;",
         "  f() {",
         "    A.g();",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
+    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
   void test_invocationOfNonFunction_superExpression() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get g => 0;",
         "}",
         "class B extends A {",
         "  m() {",
         "    var v = super.g();",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
+    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
     verify([source]);
   }
   void test_invocationOfNonFunctionExpression_literal() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  3(5);", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION]);
+    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION]);
     verify([source]);
   }
   void test_nonBoolCondition_conditional() {
     Source source = addSource(EngineTestCase.createSource(["f() { return 3 ? 2 : 1; }"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]);
+    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_CONDITION]);
     verify([source]);
   }
   void test_nonBoolCondition_do() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  do {} while (3);", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]);
+    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_CONDITION]);
     verify([source]);
   }
   void test_nonBoolCondition_if() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  if (3) return 2; else return 1;", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]);
+    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_CONDITION]);
     verify([source]);
   }
   void test_nonBoolCondition_while() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  while (3) {}", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]);
+    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_CONDITION]);
     verify([source]);
   }
   void test_nonBoolExpression_functionType() {
     Source source = addSource(EngineTestCase.createSource([
         "int makeAssertion() => 1;",
         "f() {",
         "  assert(makeAssertion);",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
+    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
     verify([source]);
   }
   void test_nonBoolExpression_interfaceType() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  assert(0);", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
+    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
     verify([source]);
   }
   void test_nonTypeAsTypeArgument_notAType() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B<E> {}", "f(B<A> b) {}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
+    assertErrors(source, [StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
     verify([source]);
   }
   void test_nonTypeAsTypeArgument_undefinedIdentifier() {
     Source source = addSource(EngineTestCase.createSource(["class B<E> {}", "f(B<A> b) {}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
+    assertErrors(source, [StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
     verify([source]);
   }
   void test_returnOfInvalidType_expressionFunctionBody_function() {
     Source source = addSource(EngineTestCase.createSource(["int f() => '0';"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_expressionFunctionBody_getter() {
     Source source = addSource(EngineTestCase.createSource(["int get g => '0';"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_expressionFunctionBody_localFunction() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  String m() {",
         "    int f() => '0';",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_expressionFunctionBody_method() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int f() => '0';", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_expressionFunctionBody_void() {
     Source source = addSource(EngineTestCase.createSource(["void f() => 42;"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_function() {
     Source source = addSource(EngineTestCase.createSource(["int f() { return '0'; }"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_getter() {
     Source source = addSource(EngineTestCase.createSource(["int get g { return '0'; }"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_localFunction() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  String m() {",
         "    int f() { return '0'; }",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_method() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int f() { return '0'; }", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_void() {
     Source source = addSource(EngineTestCase.createSource(["void f() { return 42; }"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_classTypeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class C {}",
         "class G<E extends A> {}",
         "typedef D = G<B> with C;"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_extends() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "class C extends G<B>{}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_fieldFormalParameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "class C {",
         "  var f;",
         "  C(G<B> this.f) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_functionReturnType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "G<B> f() {}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_functionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "typedef G<B> f();"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_functionTypedFormalParameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "f(G<B> h()) {}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_implements() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "class C implements G<B>{}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_is() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "var b = 1 is G<B>;"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_methodReturnType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "class C {",
         "  G<B> m() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_new() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "f() { return new G<B>(); }"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_new_superTypeOfUpperBound() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "class C extends B {}",
         "class G<E extends B> {}",
         "f() { return new G<A>(); }"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_parameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "f(G<B> g) {}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_redirectingConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class X<T extends A> {",
         "  X(int x, int y) {}",
         "  factory X.name(int x, int y) = X<B>;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_typeArgumentList() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class C<E> {}",
         "class D<E extends A> {}",
         "C<D<B>> Var;"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_typeParameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class C {}",
         "class G<E extends A> {}",
         "class D<F extends G<B>> {}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_variableDeclaration() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "G<B> g;"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_with() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "class C extends Object with G<B>{}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_undefinedGetter() {
     Source source = addSource(EngineTestCase.createSource(["class T {}", "f(T e) { return e.m; }"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_GETTER]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
   void test_undefinedGetter_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "var a = A.B;"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_GETTER]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
   void test_undefinedMethod() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  void m() {", "    n();", "  }", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_METHOD]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
   void test_undefinedMethod_ignoreTypePropagation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {",
         "  m() {}",
         "}",
         "class C {",
         "f() {",
         "    A a = new B();",
         "    a.m();",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_METHOD]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
   void test_undefinedOperator_indexBoth() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a[0]++;", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         StaticTypeWarningCode.UNDEFINED_OPERATOR,
         StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedOperator_indexGetter() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a[0];", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedOperator_indexSetter() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a[0] = 1;", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedOperator_plus() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a + 1;", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedSetter() {
     Source source = addSource(EngineTestCase.createSource(["class T {}", "f(T e1) { e1.m = 0; }"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_SETTER]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SETTER]);
   }
   void test_undefinedSetter_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f() { A.B = 0;}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_SETTER]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SETTER]);
   }
   void test_undefinedSuperMethod() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {",
         "  m() { return super.m(); }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_SUPER_METHOD]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SUPER_METHOD]);
   }
   void test_unqualifiedReferenceToNonLocalStaticMember_getter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int get a => 0;",
         "}",
         "class B extends A {",
         "  int b() {",
         "    return a;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER]);
+    assertErrors(source, [StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER]);
     verify([source]);
   }
   void test_unqualifiedReferenceToNonLocalStaticMember_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static void a() {}",
         "}",
         "class B extends A {",
         "  void b() {",
         "    a();",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER]);
+    assertErrors(source, [StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER]);
     verify([source]);
   }
   void test_unqualifiedReferenceToNonLocalStaticMember_setter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static set a(x) {}",
         "}",
         "class B extends A {",
         "  b(y) {",
         "    a = y;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER]);
+    assertErrors(source, [StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER]);
     verify([source]);
   }
   void test_wrongNumberOfTypeArguments_tooFew() {
     Source source = addSource(EngineTestCase.createSource(["class A<E, F> {}", "A<A> a = null;"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
+    assertErrors(source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
     verify([source]);
   }
   void test_wrongNumberOfTypeArguments_tooMany() {
     Source source = addSource(EngineTestCase.createSource(["class A<E> {}", "A<A, A> a = null;"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
+    assertErrors(source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
     verify([source]);
   }
   void test_wrongNumberOfTypeArguments_typeTest_tooFew() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class C<K, V> {}",
         "f(p) {",
         "  return p is C<A>;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
+    assertErrors(source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
     verify([source]);
   }
   void test_wrongNumberOfTypeArguments_typeTest_tooMany() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class C<E> {}",
         "f(p) {",
         "  return p is C<A, A>;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
+    assertErrors(source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
     verify([source]);
   }
   static dartSuite() {
     _ut.group('StaticTypeWarningCodeTest', () {
       _ut.test('test_inconsistentMethodInheritance_paramCount', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_inconsistentMethodInheritance_paramCount);
       });
       _ut.test('test_inconsistentMethodInheritance_paramType', () {
         final __test = new StaticTypeWarningCodeTest();
@@ skipping 288 matching lines @@
         runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_typeTest_tooFew);
       });
       _ut.test('test_wrongNumberOfTypeArguments_typeTest_tooMany', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_typeTest_tooMany);
       });
     });
   }
 }
 class HintCodeTest extends ResolverTestCase {
+  void fail_isInt() {
+    Source source = addSource(EngineTestCase.createSource(["var v = 1 is int;"]));
+    resolve(source);
+    assertErrors(source, [HintCode.IS_INT]);
+    verify([source]);
+  }
+  void fail_isNotInt() {
+    Source source = addSource(EngineTestCase.createSource(["var v = 1 is! int;"]));
+    resolve(source);
+    assertErrors(source, [HintCode.IS_NOT_INT]);
+    verify([source]);
+  }
+  void fail_overrideEqualsButNotHashCode() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  bool operator ==(x) {}", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE]);
+    verify([source]);
+  }
   void test_deadCode_deadBlock_conditionalElse() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  true ? 1 : 2;", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadBlock_conditionalElse_nested() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  true ? true : false && false;", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadBlock_conditionalIf() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  false ? 1 : 2;", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadBlock_conditionalIf_nested() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  false ? false && false : true;", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadBlock_else() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  if(true) {} else {}", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadBlock_else_nested() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  if(true) {} else {if (false) {}}", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadBlock_if() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  if(false) {}", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadBlock_if_nested() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  if(false) {if(false) {}}", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadBlock_while() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  while(false) {}", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadBlock_while_nested() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  while(false) {if(false) {}}", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadCatch_catchFollowingCatch() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "f() {",
         "  try {} catch (e) {} catch (e) {}",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
+    assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
   void test_deadCode_deadCatch_catchFollowingCatch_nested() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "f() {",
         "  try {} catch (e) {} catch (e) {if(false) {}}",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
+    assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
   void test_deadCode_deadCatch_catchFollowingCatch_object() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  try {} on Object catch (e) {} catch (e) {}",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
+    assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
   void test_deadCode_deadCatch_catchFollowingCatch_object_nested() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  try {} on Object catch (e) {} catch (e) {if(false) {}}",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
+    assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
   void test_deadCode_deadCatch_onCatchSubtype() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "f() {",
         "  try {} on A catch (e) {} on B catch (e) {}",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
+    assertErrors(source, [HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
     verify([source]);
   }
   void test_deadCode_deadCatch_onCatchSubtype_nested() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "f() {",
         "  try {} on A catch (e) {} on B catch (e) {if(false) {}}",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
+    assertErrors(source, [HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
     verify([source]);
   }
   void test_deadCode_deadOperandLHS_and() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = false && false;", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadOperandLHS_and_nested() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = false && (false && false);", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadOperandLHS_or() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = true || true;", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_deadOperandLHS_or_nested() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = true || (false && false);", "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_statementAfterReturn_function() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  var one = 1;",
         "  return;",
         "  var two = 2;",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_statementAfterReturn_ifStatement() {
     Source source = addSource(EngineTestCase.createSource([
         "f(bool b) {",
         "  if(b) {",
         "    var one = 1;",
         "    return;",
         "    var two = 2;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_statementAfterReturn_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {",
         "    var one = 1;",
         "    return;",
         "    var two = 2;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_statementAfterReturn_nested() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  var one = 1;",
         "  return;",
         "  if(false) {}",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_statementAfterReturn_twoReturns() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  var one = 1;",
         "  return;",
         "  var two = 2;",
         "  return;",
         "  var three = 3;",
         "}"]));
     resolve(source);
-    assertErrors([HintCode.DEAD_CODE]);
+    assertErrors(source, [HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_divisionOptimization_double() {
+    Source source = addSource(EngineTestCase.createSource([
+        "f(double x, double y) {",
+        "  var v = (x / y).toInt();",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
+    verify([source]);
+  }
+  void test_divisionOptimization_int() {
+    Source source = addSource(EngineTestCase.createSource(["f(int x, int y) {", "  var v = (x / y).toInt();", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
+    verify([source]);
+  }
+  void test_divisionOptimization_propagatedType() {
+    Source source = addSource(EngineTestCase.createSource([
+        "f(x, y) {",
+        "  x = 1;",
+        "  y = 1;",
+        "  var v = (x / y).toInt();",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
+    verify([source]);
+  }
+  void test_divisionOptimization_wrappedBinaryExpression() {
+    Source source = addSource(EngineTestCase.createSource([
+        "f(int x, int y) {",
+        "  var v = (((x / y))).toInt();",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
+    verify([source]);
+  }
+  void test_duplicateImport() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib1.dart';",
+        "import 'lib1.dart';",
+        "A a;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.DUPLICATE_IMPORT]);
+    verify([source]);
+  }
+  void test_duplicateImport2() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib1.dart';",
+        "import 'lib1.dart';",
+        "import 'lib1.dart';",
+        "A a;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.DUPLICATE_IMPORT, HintCode.DUPLICATE_IMPORT]);
+    verify([source]);
+  }
+  void test_duplicateImport3() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib1.dart' as M show A hide B;",
+        "import 'lib1.dart' as M show A hide B;",
+        "M.A a;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.DUPLICATE_IMPORT, HintCode.UNUSED_IMPORT]);
+    verify([source]);
+  }
+  void test_isDouble() {
+    Source source = addSource(EngineTestCase.createSource(["var v = 1 is double;"]));
+    resolve(source);
+    assertErrors(source, [HintCode.IS_DOUBLE]);
+    verify([source]);
+  }
+  void test_isNotDouble() {
+    Source source = addSource(EngineTestCase.createSource(["var v = 1 is! double;"]));
+    resolve(source);
+    assertErrors(source, [HintCode.IS_NOT_DOUBLE]);
+    verify([source]);
+  }
+  void test_overriddingPrivateMember_getter() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "class B extends A {",
+        "  get _g => 0;",
+        "}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  get _g => 0;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    verify([source, source2]);
+  }
+  void test_overriddingPrivateMember_method() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "class B extends A {",
+        "  _m(int x) => 0;",
+        "}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  _m(int x) => 0;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    verify([source, source2]);
+  }
+  void test_overriddingPrivateMember_method2() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "class B extends A {}",
+        "class C extends B {",
+        "  _m(int x) => 0;",
+        "}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  _m(int x) => 0;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    verify([source, source2]);
+  }
+  void test_overriddingPrivateMember_setter() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "class B extends A {",
+        "  set _s(int x) {}",
+        "}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  set _s(int x) {}", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    verify([source, source2]);
+  }
+  void test_typeCheck_type_is_Null() {
+    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is Null;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.TYPE_CHECK_IS_NULL]);
+    verify([source]);
+  }
+  void test_typeCheck_type_not_Null() {
+    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is! Null;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.TYPE_CHECK_IS_NOT_NULL]);
+    verify([source]);
+  }
+  void test_unnecessaryCast_type_supertype() {
+    Source source = addSource(EngineTestCase.createSource(["m(int i) {", "  var b = i as Object;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNNECESSARY_CAST]);
+    verify([source]);
+  }
+  void test_unnecessaryCast_type_type() {
+    Source source = addSource(EngineTestCase.createSource(["m(num i) {", "  var b = i as num;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNNECESSARY_CAST]);
+    verify([source]);
+  }
+  void test_unnecessaryTypeCheck_null_is_Null() {
+    Source source = addSource(EngineTestCase.createSource(["bool b = null is Null;"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_TRUE]);
+    verify([source]);
+  }
+  void test_unnecessaryTypeCheck_null_not_Null() {
+    Source source = addSource(EngineTestCase.createSource(["bool b = null is! Null;"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_FALSE]);
+    verify([source]);
+  }
+  void test_unnecessaryTypeCheck_type_is_dynamic() {
+    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is dynamic;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_TRUE]);
+    verify([source]);
+  }
+  void test_unnecessaryTypeCheck_type_is_object() {
+    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is Object;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_TRUE]);
+    verify([source]);
+  }
+  void test_unnecessaryTypeCheck_type_not_dynamic() {
+    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is! dynamic;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_FALSE]);
+    verify([source]);
+  }
+  void test_unnecessaryTypeCheck_type_not_object() {
+    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is! Object;", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_FALSE]);
     verify([source]);
   }
   void test_unusedImport() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
-    resolve(source);
-    assertErrors([HintCode.UNUSED_IMPORT]);
-    verify([source]);
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNUSED_IMPORT]);
+    assertNoErrors(source2);
+    verify([source, source2]);
   }
   void test_unusedImport_as() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'lib1.dart';",
         "import 'lib1.dart' as one;",
         "one.A a;"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
     resolve(source);
-    assertErrors([HintCode.UNUSED_IMPORT]);
-    verify([source]);
+    assertErrors(source, [HintCode.UNUSED_IMPORT]);
+    assertNoErrors(source2);
+    verify([source, source2]);
   }
   void test_unusedImport_hide() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'lib1.dart';",
         "import 'lib1.dart' hide A;",
         "A a;"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
     resolve(source);
-    assertErrors([HintCode.UNUSED_IMPORT]);
-    verify([source]);
+    assertErrors(source, [HintCode.UNUSED_IMPORT]);
+    assertNoErrors(source2);
+    verify([source, source2]);
   }
   void test_unusedImport_show() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'lib1.dart' show A;",
         "import 'lib1.dart' show B;",
         "A a;"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
+    Source source2 = addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
     resolve(source);
-    assertErrors([HintCode.UNUSED_IMPORT]);
-    verify([source]);
+    assertErrors(source, [HintCode.UNUSED_IMPORT]);
+    assertNoErrors(source2);
+    verify([source, source2]);
   }
   static dartSuite() {
     _ut.group('HintCodeTest', () {
       _ut.test('test_deadCode_deadBlock_conditionalElse', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalElse);
       });
       _ut.test('test_deadCode_deadBlock_conditionalElse_nested', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalElse_nested);
@@ skipping 83 matching lines @@
         runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_method);
       });
       _ut.test('test_deadCode_statementAfterReturn_nested', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_nested);
       });
       _ut.test('test_deadCode_statementAfterReturn_twoReturns', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_twoReturns);
       });
+      _ut.test('test_divisionOptimization_double', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_divisionOptimization_double);
+      });
+      _ut.test('test_divisionOptimization_int', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_divisionOptimization_int);
+      });
+      _ut.test('test_divisionOptimization_propagatedType', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_divisionOptimization_propagatedType);
+      });
+      _ut.test('test_divisionOptimization_wrappedBinaryExpression', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_divisionOptimization_wrappedBinaryExpression);
+      });
+      _ut.test('test_duplicateImport', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_duplicateImport);
+      });
+      _ut.test('test_duplicateImport2', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_duplicateImport2);
+      });
+      _ut.test('test_duplicateImport3', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_duplicateImport3);
+      });
+      _ut.test('test_isDouble', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_isDouble);
+      });
+      _ut.test('test_isNotDouble', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_isNotDouble);
+      });
+      _ut.test('test_overriddingPrivateMember_getter', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_overriddingPrivateMember_getter);
+      });
+      _ut.test('test_overriddingPrivateMember_method', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_overriddingPrivateMember_method);
+      });
+      _ut.test('test_overriddingPrivateMember_method2', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_overriddingPrivateMember_method2);
+      });
+      _ut.test('test_overriddingPrivateMember_setter', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_overriddingPrivateMember_setter);
+      });
+      _ut.test('test_typeCheck_type_is_Null', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_typeCheck_type_is_Null);
+      });
+      _ut.test('test_typeCheck_type_not_Null', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_typeCheck_type_not_Null);
+      });
+      _ut.test('test_unnecessaryCast_type_supertype', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryCast_type_supertype);
+      });
+      _ut.test('test_unnecessaryCast_type_type', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryCast_type_type);
+      });
+      _ut.test('test_unnecessaryTypeCheck_null_is_Null', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryTypeCheck_null_is_Null);
+      });
+      _ut.test('test_unnecessaryTypeCheck_null_not_Null', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryTypeCheck_null_not_Null);
+      });
+      _ut.test('test_unnecessaryTypeCheck_type_is_dynamic', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryTypeCheck_type_is_dynamic);
+      });
+      _ut.test('test_unnecessaryTypeCheck_type_is_object', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryTypeCheck_type_is_object);
+      });
+      _ut.test('test_unnecessaryTypeCheck_type_not_dynamic', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryTypeCheck_type_not_dynamic);
+      });
+      _ut.test('test_unnecessaryTypeCheck_type_not_object', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryTypeCheck_type_not_object);
+      });
       _ut.test('test_unusedImport', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_unusedImport);
       });
       _ut.test('test_unusedImport_as', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_unusedImport_as);
       });
       _ut.test('test_unusedImport_hide', () {
         final __test = new HintCodeTest();
@@ skipping 383 matching lines @@
    */
   Source addSource2(String filePath, String contents) {
     Source source = cacheSource(filePath, contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.added(source);
     analysisContext.applyChanges(changeSet);
     return source;
   }
 
   /**
-   * Assert that the number of errors that have been gathered matches the number of errors that are
-   * given and that they have the expected error codes. The order in which the errors were gathered
-   * is ignored.
+   * Assert that the number of errors reported against the given source matches the number of errors
+   * that are given and that they have the expected error codes. The order in which the errors were
+   * gathered is ignored.
    *
-   * @param expectedErrorCodes the error codes of the errors that should have been gathered
-   * @throws AssertionFailedError if a different number of errors have been gathered than were
+   * @param source the source against which the errors should have been reported
+   * @param expectedErrorCodes the error codes of the errors that should have been reported
+   * @throws AnalysisException if the reported errors could not be computed
+   * @throws AssertionFailedError if a different number of errors have been reported than were
    *           expected
    */
-  void assertErrors(List<ErrorCode> expectedErrorCodes) {
+  void assertErrors(Source source, List<ErrorCode> expectedErrorCodes) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    for (ChangeNotice notice in analysisContext.performAnalysisTask()) {
-      for (AnalysisError error in notice.errors) {
-        errorListener.onError(error);
-      }
+    for (AnalysisError error in analysisContext.computeErrors(source)) {
+      errorListener.onError(error);
     }
     errorListener.assertErrors2(expectedErrorCodes);
   }
 
   /**
-   * Assert that no errors have been gathered.
+   * Assert that no errors have been reported against the given source.
    *
-   * @throws AssertionFailedError if any errors have been gathered
+   * @param source the source against which no errors should have been reported
+   * @throws AnalysisException if the reported errors could not be computed
+   * @throws AssertionFailedError if any errors have been reported
    */
-  void assertNoErrors() {
-    GatheringErrorListener errorListener = new GatheringErrorListener();
-    for (ChangeNotice notice in analysisContext.performAnalysisTask()) {
-      for (AnalysisError error in notice.errors) {
-        errorListener.onError(error);
-      }
-    }
-    errorListener.assertNoErrors();
+  void assertNoErrors(Source source) {
+    EngineTestCase.assertLength(0, analysisContext.computeErrors(source));
   }
 
   /**
    * Cache the source file content in the source factory but don't add the source to the analysis
    * context. The file path should be absolute.
    *
    * @param filePath the path of the file being cached
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the cached file
    */
@@ skipping 157 matching lines @@
     JUnitTestCase.assertSame(symbolType, provider.symbolType);
     JUnitTestCase.assertSame(typeType, provider.typeType);
   }
   ClassElement classElement(String typeName, InterfaceType superclassType, List<String> parameterNames) {
     ClassElementImpl element = new ClassElementImpl(ASTFactory.identifier3(typeName));
     element.supertype = superclassType;
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(element);
     element.type = type;
     int count = parameterNames.length;
     if (count > 0) {
-      List<TypeVariableElementImpl> typeVariables = new List<TypeVariableElementImpl>(count);
-      List<TypeVariableTypeImpl> typeArguments = new List<TypeVariableTypeImpl>(count);
+      List<TypeParameterElementImpl> typeParameters = new List<TypeParameterElementImpl>(count);
+      List<TypeParameterTypeImpl> typeArguments = new List<TypeParameterTypeImpl>(count);
       for (int i = 0; i < count; i++) {
-        TypeVariableElementImpl variable = new TypeVariableElementImpl(ASTFactory.identifier3(parameterNames[i]));
-        typeVariables[i] = variable;
-        typeArguments[i] = new TypeVariableTypeImpl(variable);
-        variable.type = typeArguments[i];
+        TypeParameterElementImpl typeParameter = new TypeParameterElementImpl(ASTFactory.identifier3(parameterNames[i]));
+        typeParameters[i] = typeParameter;
+        typeArguments[i] = new TypeParameterTypeImpl(typeParameter);
+        typeParameter.type = typeArguments[i];
       }
-      element.typeVariables = typeVariables;
+      element.typeParameters = typeParameters;
       type.typeArguments = typeArguments;
     }
     return element;
   }
   static dartSuite() {
     _ut.group('TypeProviderImplTest', () {
       _ut.test('test_creation', () {
         final __test = new TypeProviderImplTest();
         runJUnitTest(__test, __test.test_creation);
       });
@@ skipping 679 matching lines @@
         final __test = new InheritanceManagerTest();
         runJUnitTest(__test, __test.test_lookupMember_setter_static);
       });
     });
   }
 }
 class CompileTimeErrorCodeTest extends ResolverTestCase {
   void fail_compileTimeConstantRaisesException() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION]);
+    assertErrors(source, [CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION]);
     verify([source]);
   }
   void fail_constEvalThrowsException() {
     Source source = addSource(EngineTestCase.createSource([
         "class C {",
         "  const C();",
         "}",
         "f() { return const C(); }"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION]);
     verify([source]);
   }
   void fail_mixinDeclaresConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "class B extends Object mixin A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
   void fail_mixinOfNonClass() {
     Source source = addSource(EngineTestCase.createSource(["var A;", "class B extends Object mixin A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
     verify([source]);
   }
   void fail_objectCannotExtendAnotherClass() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.OBJECT_CANNOT_EXTEND_ANOTHER_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.OBJECT_CANNOT_EXTEND_ANOTHER_CLASS]);
     verify([source]);
   }
   void fail_recursiveCompileTimeConstant() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "  final m = const A();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT]);
+    assertErrors(source, [CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT]);
     verify([source]);
   }
   void fail_recursiveCompileTimeConstant_cycle() {
     Source source = addSource(EngineTestCase.createSource(["const x = y + 1;", "const y = x + 1;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT]);
+    assertErrors(source, [CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT]);
     verify([source]);
   }
   void fail_superInitializerInObject() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_INITIALIZER_IN_OBJECT]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_INITIALIZER_IN_OBJECT]);
     verify([source]);
   }
   void test_ambiguousExport() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "export 'lib1.dart';",
         "export 'lib2.dart';"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.AMBIGUOUS_EXPORT]);
+    assertErrors(source, [CompileTimeErrorCode.AMBIGUOUS_EXPORT]);
     verify([source]);
   }
   void test_ambiguousImport_function() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "g() { return f(); }"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "f() {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "f() {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         StaticWarningCode.AMBIGUOUS_IMPORT,
         CompileTimeErrorCode.UNDEFINED_FUNCTION]);
   }
   void test_argumentDefinitionTestNonParameter() {
     Source source = addSource(EngineTestCase.createSource(["f() {", " var v = 0;", " return ?v;", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST,
         CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_const() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(String p);",
         "}",
         "main() {",
         "  const A(42);",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_const_super() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(String p);",
         "}",
         "class B extends A {",
         "  const B() : super(42);",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_builtInIdentifierAsType() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  typedef x;", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE,
         StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
   void test_builtInIdentifierAsTypedefName_classTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "typedef as = A with B;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
     verify([source]);
   }
   void test_builtInIdentifierAsTypedefName_functionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef bool as();"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
     verify([source]);
   }
   void test_builtInIdentifierAsTypeName() {
     Source source = addSource(EngineTestCase.createSource(["class as {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME]);
     verify([source]);
   }
-  void test_builtInIdentifierAsTypeVariableName() {
+  void test_builtInIdentifierAsTypeParameterName() {
     Source source = addSource(EngineTestCase.createSource(["class A<as> {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME]);
     verify([source]);
   }
   void test_caseExpressionTypeImplementsEquals() {
     Source source = addSource(EngineTestCase.createSource([
         "class IntWrapper {",
         "  final int value;",
         "  const IntWrapper(this.value);",
         "  bool operator ==(IntWrapper x) {",
         "    return value == x.value;",
         "  }",
+        "  get hashCode => value;",
         "}",
         "",
         "f(var a) {",
         "  switch(a) {",
         "    case(const IntWrapper(1)) : return 1;",
         "    default: return 0;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
+    assertErrors(source, [CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
     verify([source]);
   }
   void test_conflictingConstructorNameAndMember_field() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A.x() {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD]);
     verify([source]);
   }
   void test_conflictingConstructorNameAndMember_method() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A.x();", "  void x() {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD]);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD]);
     verify([source]);
   }
   void test_conflictingGetterAndMethod_field_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int m;",
         "}",
         "class B extends A {",
         "  m() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD]);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD]);
     verify([source]);
   }
   void test_conflictingGetterAndMethod_getter_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  get m => 0;",
         "}",
         "class B extends A {",
         "  m() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD]);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD]);
     verify([source]);
   }
   void test_conflictingGetterAndMethod_method_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "}",
         "class B extends A {",
         "  int m;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
     verify([source]);
   }
   void test_conflictingGetterAndMethod_method_getter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "}",
         "class B extends A {",
         "  get m => 0;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
     verify([source]);
   }
   void test_constConstructorWithNonConstSuper_explicit() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A();",
         "}",
         "class B extends A {",
         "  const B(): super();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER]);
     verify([source]);
   }
   void test_constConstructorWithNonConstSuper_implicit() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A();",
         "}",
         "class B extends A {",
         "  const B();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER]);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_mixin() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var a;",
         "}",
         "class B extends Object with A {",
         "  const B();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_super() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var a;",
         "}",
         "class B extends A {",
         "  const B();",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD,
         CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER]);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_this() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  const A();", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]);
     verify([source]);
   }
   void test_constEval_newInstance_constConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "const a = new A();"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
   void test_constEval_propertyExtraction_targetNotConst() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "  m() {}",
         "}",
         "final a = const A();",
         "const C = a.m;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
   void test_constEvalThrowsException_binaryMinus_null() {
     check_constEvalThrowsException_binary_null("null - 5", false);
     check_constEvalThrowsException_binary_null("5 - null", true);
   }
   void test_constEvalThrowsException_binaryPlus_null() {
     check_constEvalThrowsException_binary_null("null + 5", false);
     check_constEvalThrowsException_binary_null("5 + null", true);
   }
   void test_constEvalThrowsException_divisionByZero() {
     Source source = addSource("const C = 1 ~/ 0;");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE]);
     verify([source]);
   }
   void test_constEvalThrowsException_unaryBitNot_null() {
     Source source = addSource("const C = ~null;");
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
         StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_constEvalThrowsException_unaryNegated_null() {
     Source source = addSource("const C = -null;");
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
         StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_constEvalThrowsException_unaryNot_null() {
     Source source = addSource("const C = !null;");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
     verify([source]);
   }
   void test_constEvalTypeBool_binary() {
     check_constEvalTypeBool_withParameter_binary("p && ''");
     check_constEvalTypeBool_withParameter_binary("p || ''");
   }
   void test_constEvalTypeBool_binary_leftTrue() {
     Source source = addSource("const C = (true || 0);");
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL,
         HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_constEvalTypeBoolNumString_equal() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "class B {",
         "  final a;",
         "  const B(num p) : a = p == const A();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING]);
     verify([source]);
   }
   void test_constEvalTypeBoolNumString_notEqual() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "class B {",
         "  final a;",
         "  const B(String p) : a = p != const A();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING]);
     verify([source]);
   }
   void test_constEvalTypeInt_binary() {
     check_constEvalTypeInt_withParameter_binary("p ^ ''");
     check_constEvalTypeInt_withParameter_binary("p & ''");
     check_constEvalTypeInt_withParameter_binary("p | ''");
     check_constEvalTypeInt_withParameter_binary("p >> ''");
     check_constEvalTypeInt_withParameter_binary("p << ''");
   }
   void test_constEvalTypeNum_binary() {
     check_constEvalTypeNum_withParameter_binary("p + ''");
     check_constEvalTypeNum_withParameter_binary("p - ''");
     check_constEvalTypeNum_withParameter_binary("p * ''");
     check_constEvalTypeNum_withParameter_binary("p / ''");
     check_constEvalTypeNum_withParameter_binary("p ~/ ''");
     check_constEvalTypeNum_withParameter_binary("p > ''");
     check_constEvalTypeNum_withParameter_binary("p < ''");
     check_constEvalTypeNum_withParameter_binary("p >= ''");
     check_constEvalTypeNum_withParameter_binary("p <= ''");
     check_constEvalTypeNum_withParameter_binary("p % ''");
   }
   void test_constEvalTypeNum_plus_String() {
     Source source = addSource("const C = 'a' + 'b';");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_NUM]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_NUM]);
     verify([source]);
   }
   void test_constFormalParameter_fieldFormalParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  var x;", "  A(const this.x) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
     verify([source]);
   }
   void test_constFormalParameter_simpleFormalParameter() {
     Source source = addSource(EngineTestCase.createSource(["f(const x) {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
     verify([source]);
   }
   void test_constInitializedWithNonConstValue() {
     Source source = addSource(EngineTestCase.createSource(["f(p) {", "  const C = p;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
   void test_constInitializedWithNonConstValue_missingConstInListLiteral() {
     Source source = addSource("const List L = [0];");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
   void test_constInitializedWithNonConstValue_missingConstInMapLiteral() {
     Source source = addSource("const Map M = {'a' : 0};");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
   void test_constInstanceField() {
     Source source = addSource(EngineTestCase.createSource(["class C {", "  const int f = 0;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_INSTANCE_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_INSTANCE_FIELD]);
     verify([source]);
   }
   void test_constWithInvalidTypeParameters() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "f() { return const A<A>(); }"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_constWithInvalidTypeParameters_tooFew() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class C<K, V> {",
         "  const C();",
         "}",
         "f(p) {",
         "  return const C<A>();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_constWithInvalidTypeParameters_tooMany() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class C<E> {",
         "  const C();",
         "}",
         "f(p) {",
         "  return const C<A, A>();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_constWithNonConst() {
     Source source = addSource(EngineTestCase.createSource([
         "class T {",
         "  T(a, b, {c, d}) {}",
         "}",
         "f() { return const T(0, 1, c: 2, d: 3); }"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONST]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_CONST]);
     verify([source]);
   }
   void test_constWithNonConstantArgument_annotation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(int p);",
         "}",
         "var v = 42;",
         "@A(v)",
         "main() {",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT]);
     verify([source]);
   }
   void test_constWithNonConstantArgument_instanceCreation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(a);",
         "}",
         "f(p) { return const A(p); }"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT]);
     verify([source]);
   }
   void test_constWithNonType() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "f() {", "  return const A();", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
     verify([source]);
   }
   void test_constWithNonType_fromLibrary() {
     Source source1 = addSource2("lib.dart", "");
     Source source2 = addSource2("lib2.dart", EngineTestCase.createSource([
         "import 'lib.dart' as lib;",
         "void f() {",
         "  const lib.A();",
         "}"]));
     resolve(source1);
     resolve(source2);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
+    assertErrors(source2, [CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
     verify([source1]);
   }
   void test_constWithTypeParameters_direct() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<T> {",
         "  static const V = const A<T>();",
         "  const A();",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS,
         StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
   void test_constWithTypeParameters_indirect() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<T> {",
         "  static const V = const A<List<T>>();",
         "  const A();",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS,
         StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
   void test_constWithUndefinedConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "f() {",
         "  return const A.noSuchConstructor();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]);
   }
   void test_constWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A.name();",
         "}",
         "f() {",
         "  return const A();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
     verify([source]);
   }
   void test_defaultValueInFunctionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef F([x = 0]);"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS]);
+    assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS]);
     verify([source]);
   }
   void test_defaultValueInFunctionTypedParameter_named() {
     Source source = addSource(EngineTestCase.createSource(["f(g({p: null})) {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
+    assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
     verify([source]);
   }
   void test_defaultValueInFunctionTypedParameter_optional() {
     Source source = addSource(EngineTestCase.createSource(["f(g([p = null])) {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
+    assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
     verify([source]);
   }
   void test_duplicateConstructorName_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A.a() {}", "  A.a() {}", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME,
         CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME]);
     verify([source]);
   }
   void test_duplicateConstructorName_unnamed() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "  A() {}", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT,
         CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT]);
     verify([source]);
   }
   void test_duplicateDefinition() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  int m = 0;", "  m(a) {}", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_acrossLibraries() {
     Source librarySource = addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part 'a.dart';", "part 'b.dart';"]));
     Source sourceA = addSource2("/a.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
     Source sourceB = addSource2("/b.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
     resolve(librarySource);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors(sourceB, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource, sourceA, sourceB]);
   }
   void test_duplicateDefinition_classMembers_fields() {
-    Source librarySource = addSource(EngineTestCase.createSource(["class A {", "  int a;", "  int a;", "}"]));
-    resolve(librarySource);
-    assertErrors([
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  int a;", "  int a;", "}"]));
+    resolve(source);
+    assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION]);
-    verify([librarySource]);
+    verify([source]);
   }
   void test_duplicateDefinition_classMembers_fields_oneStatic() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  static int x;", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_classMembers_methods() {
-    Source librarySource = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "  m() {}", "}"]));
-    resolve(librarySource);
-    assertErrors([
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "  m() {}", "}"]));
+    resolve(source);
+    assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION]);
-    verify([librarySource]);
+    verify([source]);
   }
   void test_duplicateDefinition_localFields() {
-    Source librarySource = addSource(EngineTestCase.createSource([
+    Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {",
         "    int a;",
         "    int a;",
         "  }",
         "}"]));
-    resolve(librarySource);
-    assertErrors([
+    resolve(source);
+    assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION]);
-    verify([librarySource]);
+    verify([source]);
   }
   void test_duplicateDefinition_parameterWithFunctionName_local() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  f(f) {}", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_parameterWithFunctionName_topLevel() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  f(f) {}", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_DEFINITION,
         CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinitionInheritance_instanceGetter_staticGetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get x => 0;",
         "}",
         "class B extends A {",
         "  static int get x => 0;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
   void test_duplicateDefinitionInheritance_instanceGetterAbstract_staticGetter() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int get x;",
         "}",
         "class B extends A {",
         "  static int get x => 0;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
   void test_duplicateDefinitionInheritance_instanceMethod_staticMethod() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  x() {}",
         "}",
         "class B extends A {",
         "  static x() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
   void test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  x();",
         "}",
         "abstract class B extends A {",
         "  static x() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
   void test_duplicateDefinitionInheritance_instanceSetter_staticSetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  set x(value) {}",
         "}",
         "class B extends A {",
         "  static set x(value) {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
   void test_duplicateDefinitionInheritance_instanceSetterAbstract_staticSetter() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  set x(value);",
         "}",
         "class B extends A {",
         "  static set x(value) {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
   void test_duplicateNamedArgument() {
     Source source = addSource(EngineTestCase.createSource(["f({a, b}) {}", "main() {", "  f(a: 1, a: 2);", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT]);
     verify([source]);
   }
   void test_exportInternalLibrary() {
     Source source = addSource(EngineTestCase.createSource(["export 'dart:_interceptors';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY]);
+    assertErrors(source, [CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY]);
     verify([source]);
   }
   void test_exportOfNonLibrary() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["part of lib;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY]);
+    assertErrors(source, [CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY]);
     verify([source]);
   }
   void test_extendsDisallowedClass_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A extends bool {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsDisallowedClass_double() {
     Source source = addSource(EngineTestCase.createSource(["class A extends double {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsDisallowedClass_int() {
     Source source = addSource(EngineTestCase.createSource(["class A extends int {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsDisallowedClass_Null() {
     Source source = addSource(EngineTestCase.createSource(["class A extends Null {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsDisallowedClass_num() {
     Source source = addSource(EngineTestCase.createSource(["class A extends num {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsDisallowedClass_String() {
     Source source = addSource(EngineTestCase.createSource(["class A extends String {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
         CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsNonClass_class() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B extends A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_NON_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.EXTENDS_NON_CLASS]);
     verify([source]);
   }
   void test_extendsNonClass_dynamic() {
     Source source = addSource(EngineTestCase.createSource(["class B extends dynamic {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_NON_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.EXTENDS_NON_CLASS]);
     verify([source]);
   }
   void test_extraPositionalArguments_const() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "main() {",
         "  const A(0);",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS]);
+    assertErrors(source, [CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS]);
     verify([source]);
   }
   void test_extraPositionalArguments_const_super() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "class B extends A {",
         "  const B() : super(0);",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS]);
+    assertErrors(source, [CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS]);
     verify([source]);
   }
   void test_fieldInitializedByMultipleInitializers() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A() : x = 0, x = 1 {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
+    assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
   void test_fieldInitializedByMultipleInitializers_multipleInits() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int x;",
         "  A() : x = 0, x = 1, x = 2 {}",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS,
         CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
   void test_fieldInitializedByMultipleInitializers_multipleNames() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int x;",
         "  int y;",
         "  A() : x = 0, x = 1, y = 0, y = 1 {}",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS,
         CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
   void test_fieldInitializedInParameterAndInitializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) : x = 1 {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
     verify([source]);
   }
   void test_fieldInitializerFactoryConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  factory A(this.x) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR]);
     verify([source]);
   }
   void test_fieldInitializerNotAssignable() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int x;",
         "  const A() : x = '';",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_fieldInitializerOutsideConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  m(this.x) {}", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         ParserErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR,
         CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_fieldInitializerOutsideConstructor_defaultParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  m([this.x]) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_fieldInitializerRedirectingConstructor_afterRedirection() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int x;",
         "  A.named() {}",
         "  A() : this.named(), x = 42;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
   void test_fieldInitializerRedirectingConstructor_beforeRedirection() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int x;",
         "  A.named() {}",
         "  A() : x = 42, this.named();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
   void test_fieldInitializingFormalRedirectingConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int x;",
         "  A.named() {}",
         "  A(this.x) : this.named();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
   void test_finalInitializedMultipleTimes_initializers() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x;", "  A() : x = 0, x = 0 {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
+    assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
 
   /**
    * This test doesn't test the FINAL_INITIALIZED_MULTIPLE_TIMES code, but tests the
    * FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER code instead. It is provided here to show
    * coverage over all of the permutations of initializers in constructor declarations.
    *
    * Note: FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER covers a subset of
    * FINAL_INITIALIZED_MULTIPLE_TIMES, since it more specific, we use it instead of the broader code
    */
   void test_finalInitializedMultipleTimes_initializingFormal_initializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x;", "  A(this.x) : x = 0 {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
     verify([source]);
   }
   void test_finalInitializedMultipleTimes_initializingFormals() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x;", "  A(this.x, this.x) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES]);
+    assertErrors(source, [CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES]);
+    verify([source]);
+  }
+  void test_finalNotInitialized_instanceField_const_static() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  static const F;", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONST_NOT_INITIALIZED]);
+    verify([source]);
+  }
+  void test_finalNotInitialized_library_const() {
+    Source source = addSource(EngineTestCase.createSource(["const F;"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONST_NOT_INITIALIZED]);
+    verify([source]);
+  }
+  void test_finalNotInitialized_local_const() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  const int x;", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONST_NOT_INITIALIZED]);
     verify([source]);
   }
   void test_getterAndMethodWithSameName() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  x(y) {}", "  get x => 0;", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME,
         CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME]);
     verify([source]);
   }
   void test_implementsDisallowedClass_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A implements bool {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_implementsDisallowedClass_double() {
     Source source = addSource(EngineTestCase.createSource(["class A implements double {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_implementsDisallowedClass_int() {
     Source source = addSource(EngineTestCase.createSource(["class A implements int {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_implementsDisallowedClass_Null() {
     Source source = addSource(EngineTestCase.createSource(["class A implements Null {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_implementsDisallowedClass_num() {
     Source source = addSource(EngineTestCase.createSource(["class A implements num {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_implementsDisallowedClass_String() {
     Source source = addSource(EngineTestCase.createSource(["class A implements String {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_implementsDynamic() {
     Source source = addSource(EngineTestCase.createSource(["class A implements dynamic {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_DYNAMIC]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DYNAMIC]);
     verify([source]);
   }
   void test_implementsNonClass_class() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B implements A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
     verify([source]);
   }
   void test_implementsNonClass_typedef() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "int B;", "typedef C = A implements B;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
     verify([source]);
   }
   void test_implementsRepeated() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B implements A, A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_REPEATED]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_REPEATED]);
     verify([source]);
   }
   void test_implementsRepeated_3times() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {} class C{}",
         "class B implements A, A, A, A {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.IMPLEMENTS_REPEATED,
         CompileTimeErrorCode.IMPLEMENTS_REPEATED,
         CompileTimeErrorCode.IMPLEMENTS_REPEATED]);
     verify([source]);
   }
   void test_implementsSuperClass() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A implements A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS]);
     verify([source]);
   }
   void test_implementsSuperClass_Object() {
     Source source = addSource(EngineTestCase.createSource(["class A implements Object {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var v;",
         "  A() : v = f;",
         "  var f;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_field2() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x = 0;", "  final y = x;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_invocation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var v;",
         "  A() : v = f();",
         "  f() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_invocationInStatic() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static var F = m();", "  m() {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_redirectingConstructorInvocation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A(p) {}",
         "  A.named() : this(f);",
         "  var f;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_superConstructorInvocation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A(p) {}",
         "}",
         "class B extends A {",
         "  B() : super(f);",
         "  var f;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_importInternalLibrary() {
     Source source = addSource(EngineTestCase.createSource(["import 'dart:_interceptors';"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
         HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
   void test_importInternalLibrary_collection() {
     Source source = addSource(EngineTestCase.createSource(["import 'dart:_collection-dev';"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
         HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
   void test_importOfNonLibrary() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';", "A a;"]));
     addSource2("/part.dart", EngineTestCase.createSource(["part of lib;", "class A{}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]);
+    assertErrors(source, [CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]);
     verify([source]);
   }
   void test_inconsistentCaseExpressionTypes() {
     Source source = addSource(EngineTestCase.createSource([
         "f(var p) {",
         "  switch (p) {",
         "    case 1:",
         "      break;",
         "    case 'a':",
         "      break;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES]);
+    assertErrors(source, [CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES]);
     verify([source]);
   }
   void test_inconsistentCaseExpressionTypes_repeated() {
     Source source = addSource(EngineTestCase.createSource([
         "f(var p) {",
         "  switch (p) {",
         "    case 1:",
         "      break;",
         "    case 'a':",
         "      break;",
         "    case 'b':",
         "      break;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES,
         CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES]);
     verify([source]);
   }
   void test_initializerForNonExistant_initializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() : x = 0 {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD]);
   }
   void test_initializerForStaticField() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static int x;", "  A() : x = 0 {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD]);
     verify([source]);
   }
   void test_initializingFormalForNonExistantField() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A(this.x) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
     verify([source]);
   }
   void test_initializingFormalForNonExistantField_notInEnclosingClass() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "int x;",
         "}",
         "class B extends A {",
         "  B(this.x) {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
     verify([source]);
   }
   void test_initializingFormalForNonExistantField_optional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A([this.x]) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
     verify([source]);
   }
   void test_initializingFormalForNonExistantField_synthetic() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int get x => 1;", "  A(this.x) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
     verify([source]);
   }
   void test_initializingFormalForStaticField() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static int x;", "  A([this.x]) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD]);
+    assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD]);
     verify([source]);
   }
   void test_instanceMemberAccessFromStatic_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int f;",
         "  static foo() {",
         "    f;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
+    assertErrors(source, [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
     verify([source]);
   }
   void test_instanceMemberAccessFromStatic_getter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  get g => null;",
         "  static foo() {",
         "    g;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
+    assertErrors(source, [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
     verify([source]);
   }
   void test_instanceMemberAccessFromStatic_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "  static foo() {",
         "    m();",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
+    assertErrors(source, [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
     verify([source]);
   }
   void test_invalidAnnotation_getter() {
     Source source = addSource(EngineTestCase.createSource(["get V => 0;", "@V", "main() {", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidAnnotation_importWithPrefix_getter() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "get V => 0;"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "@p.V", "main() {", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidAnnotation_importWithPrefix_notConstantVariable() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "final V = 0;"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "@p.V", "main() {", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidAnnotation_importWithPrefix_notVariableOrConstructorInvocation() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "typedef V();"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "@p.V", "main() {", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidAnnotation_notConstantVariable() {
     Source source = addSource(EngineTestCase.createSource(["final V = 0;", "@V", "main() {", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidAnnotation_notVariableOrConstructorInvocation() {
     Source source = addSource(EngineTestCase.createSource(["typedef V();", "@V", "main() {", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidAnnotation_staticMethodReference() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static f() {}",
         "}",
         "@A.f",
         "main() {",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidConstructorName_notEnclosingClassName_defined() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  B() : super();", "}", "class B {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]);
   }
   void test_invalidConstructorName_notEnclosingClassName_undefined() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  B() : super();", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]);
   }
   void test_invalidFactoryNameNotAClass_notClassName() {
     Source source = addSource(EngineTestCase.createSource(["int B;", "class A {", "  factory B() {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS]);
     verify([source]);
   }
   void test_invalidFactoryNameNotAClass_notEnclosingClassName() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  factory B() {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS]);
   }
   void test_invalidReferenceToThis_factoryConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A() { return this; }", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
     verify([source]);
   }
   void test_invalidReferenceToThis_instanceVariableInitializer_inConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  var f;", "  A() : f = this;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
     verify([source]);
   }
   void test_invalidReferenceToThis_instanceVariableInitializer_inDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  var f = this;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
     verify([source]);
   }
   void test_invalidReferenceToThis_staticMethod() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static m() { return this; }", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
     verify([source]);
   }
   void test_invalidReferenceToThis_staticVariableInitializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static A f = this;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
     verify([source]);
   }
   void test_invalidReferenceToThis_superInitializer() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A(var x) {}",
         "}",
         "class B extends A {",
         "  B() : super(this);",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
     verify([source]);
   }
   void test_invalidReferenceToThis_topLevelFunction() {
     Source source = addSource("f() { return this; }");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
     verify([source]);
   }
   void test_invalidReferenceToThis_variableInitializer() {
     Source source = addSource("int x = this;");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
     verify([source]);
   }
   void test_invalidTypeArgumentInConstList() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<E> {",
         "  m() {",
         "    return const <E>[];",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST]);
     verify([source]);
   }
   void test_invalidTypeArgumentInConstMap() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<E> {",
         "  m() {",
         "    return const <String, E>{};",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP]);
     verify([source]);
   }
   void test_invalidUri_export() {
     Source source = addSource(EngineTestCase.createSource(["export 'ht:';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_URI]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_URI]);
   }
   void test_invalidUri_import() {
     Source source = addSource(EngineTestCase.createSource(["import 'ht:';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_URI]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_URI]);
   }
   void test_invalidUri_part() {
     Source source = addSource(EngineTestCase.createSource(["part 'ht:';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_URI]);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_URI]);
   }
   void test_labelInOuterScope() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void m(int i) {",
         "    l: while (i > 0) {",
         "      void f() {",
         "        break l;",
         "      };",
         "    }",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE]);
+    assertErrors(source, [CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE]);
   }
   void test_labelUndefined_break() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  x: while (true) {",
         "    break y;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.LABEL_UNDEFINED]);
+    assertErrors(source, [CompileTimeErrorCode.LABEL_UNDEFINED]);
   }
   void test_labelUndefined_continue() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  x: while (true) {",
         "    continue y;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.LABEL_UNDEFINED]);
+    assertErrors(source, [CompileTimeErrorCode.LABEL_UNDEFINED]);
   }
   void test_listElementTypeNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["var v = const <String> [42];"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_mapKeyTypeNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["var v = const <String, int > {1 : 2};"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_mapValueTypeNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["var v = const <String, String> {'a' : 2};"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_memberWithClassName_field() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int A = 0;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
     verify([source]);
   }
   void test_memberWithClassName_field2() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int z, A, b = 0;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
     verify([source]);
   }
   void test_memberWithClassName_getter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  get A => 0;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
     verify([source]);
   }
   void test_memberWithClassName_method() {
   }
   void test_methodAndGetterWithSameName() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  get x => 0;", "  x(y) {}", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME,
         CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME]);
     verify([source]);
   }
   void test_mixinDeclaresConstructor_classDeclaration() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "class B extends Object with A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
   void test_mixinDeclaresConstructor_typedef() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "typedef B = Object with A;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_classDeclaration_extends() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "class C extends Object with B {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_classDeclaration_with() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends Object with A {}",
         "class C extends Object with B {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_typedef_extends() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "typedef C = Object with B;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_typedef_with() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends Object with A {}",
         "typedef C = Object with B;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
   void test_mixinOfDisallowedClass_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A extends Object with bool {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_mixinOfDisallowedClass_double() {
     Source source = addSource(EngineTestCase.createSource(["class A extends Object with double {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_mixinOfDisallowedClass_int() {
     Source source = addSource(EngineTestCase.createSource(["class A extends Object with int {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_mixinOfDisallowedClass_Null() {
     Source source = addSource(EngineTestCase.createSource(["class A extends Object with Null {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_mixinOfDisallowedClass_num() {
     Source source = addSource(EngineTestCase.createSource(["class A extends Object with num {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_mixinOfDisallowedClass_String() {
     Source source = addSource(EngineTestCase.createSource(["class A extends Object with String {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_mixinOfNonClass_class() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B extends Object with A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
     verify([source]);
   }
   void test_mixinOfNonClass_typedef() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "int B;", "typedef C = A with B;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
     verify([source]);
   }
   void test_mixinReferencesSuper() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  toString() => super.toString();",
         "}",
         "class B extends Object with A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_REFERENCES_SUPER]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER]);
     verify([source]);
   }
   void test_mixinWithNonClassSuperclass_class() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B {}", "class C extends A with B {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS]);
     verify([source]);
   }
   void test_mixinWithNonClassSuperclass_typedef() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B {}", "typedef C = A with B;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS]);
+    assertErrors(source, [CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS]);
     verify([source]);
   }
   void test_multipleRedirectingConstructorInvocations() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() : this.a(), this.b();",
         "  A.a() {}",
         "  A.b() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS]);
+    assertErrors(source, [CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS]);
     verify([source]);
   }
   void test_multipleSuperInitializers() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {",
         "  B() : super(), super() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS]);
+    assertErrors(source, [CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS]);
     verify([source]);
   }
   void test_nativeClauseInNonSDKCode() {
     Source source = addSource(EngineTestCase.createSource(["class A native 'string' {}"]));
     resolve(source);
-    assertErrors([ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
+    assertErrors(source, [ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
     verify([source]);
   }
   void test_nativeFunctionBodyInNonSDKCode_function() {
     Source source = addSource(EngineTestCase.createSource(["int m(a) native 'string';"]));
     resolve(source);
-    assertErrors([ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
+    assertErrors(source, [ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
     verify([source]);
   }
   void test_nativeFunctionBodyInNonSDKCode_method() {
     Source source = addSource(EngineTestCase.createSource(["class A{", "  static int m(a) native 'string';", "}"]));
     resolve(source);
-    assertErrors([ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
+    assertErrors(source, [ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
     verify([source]);
   }
   void test_noAnnotationConstructorArguments() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "@A", "main() {", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS]);
+    assertErrors(source, [CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS]);
     verify([source]);
   }
   void test_noDefaultSuperConstructorExplicit() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A(p);",
         "}",
         "class B extends A {",
         "  B() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
+    assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
     verify([source]);
   }
   void test_noDefaultSuperConstructorImplicit_superHasParameters() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A(p);", "}", "class B extends A {", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_noDefaultSuperConstructorImplicit_superOnlyNamed() {
     Source source = addSource(EngineTestCase.createSource(["class A { A.named() {} }", "class B extends A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_nonConstantAnnotationConstructor_named() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.fromInt() {}",
         "}",
         "@A.fromInt()",
         "main() {",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR]);
     verify([source]);
   }
   void test_nonConstantAnnotationConstructor_unnamed() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "@A()", "main() {", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR]);
     verify([source]);
   }
   void test_nonConstantDefaultValue_function_named() {
     Source source = addSource(EngineTestCase.createSource(["int y;", "f({x : y}) {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
   void test_nonConstantDefaultValue_function_positional() {
     Source source = addSource(EngineTestCase.createSource(["int y;", "f([x = y]) {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
   void test_nonConstantDefaultValue_inConstructor_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int y;", "  A({x : y}) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
   void test_nonConstantDefaultValue_inConstructor_positional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int y;", "  A([x = y]) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
   void test_nonConstantDefaultValue_method_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int y;", "  m({x : y}) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
   void test_nonConstantDefaultValue_method_positional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int y;", "  m([x = y]) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
   void test_nonConstCaseExpression() {
     Source source = addSource(EngineTestCase.createSource([
         "f(int p, int q) {",
         "  switch (p) {",
         "    case 3 + q:",
         "      break;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION]);
     verify([source]);
   }
   void test_nonConstListElement() {
     Source source = addSource(EngineTestCase.createSource(["f(a) {", "  return const [a];", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT]);
     verify([source]);
   }
   void test_nonConstMapAsExpressionStatement_begin() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  {'a' : 0, 'b' : 1}.length;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT]);
     verify([source]);
   }
   void test_nonConstMapAsExpressionStatement_only() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  {'a' : 0, 'b' : 1};", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT]);
     verify([source]);
   }
   void test_nonConstMapKey() {
     Source source = addSource(EngineTestCase.createSource(["f(a) {", "  return const {a : 0};", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_MAP_KEY]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_MAP_KEY]);
     verify([source]);
   }
   void test_nonConstMapValue() {
     Source source = addSource(EngineTestCase.createSource(["f(a) {", "  return const {'a' : a};", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_notBool_left() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final bool a;",
         "  const A(String p) : a = p && true;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_notBool_right() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final bool a;",
         "  const A(String p) : a = true && p;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_notInt() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int a;",
         "  const A(String p) : a = 5 & p;",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_TYPE_INT,
         CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_notNum() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int a;",
         "  const A(String p) : a = 5 + p;",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_TYPE_NUM,
         CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int C;",
         "  final int a;",
         "  const A() : a = C;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_redirecting() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static var C;",
         "  const A.named(p);",
         "  const A() : this.named(C);",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_super() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(p);",
         "}",
         "class B extends A {",
         "  static var C;",
         "  const B() : super(C);",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_nonGenerativeConstructor_explicit() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  factory A.named() {}",
         "}",
         "class B extends A {",
         "  B() : super.named();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_nonGenerativeConstructor_implicit() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  factory A() {}",
         "}",
         "class B extends A {",
         "  B();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_nonGenerativeConstructor_implicit2() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  factory A() {}",
         "}",
         "class B extends A {",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_notEnoughRequiredArguments_const() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(int p);",
         "}",
         "main() {",
         "  const A();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
+    assertErrors(source, [CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
     verify([source]);
   }
   void test_notEnoughRequiredArguments_const_super() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(int p);",
         "}",
         "class B extends A {",
         "  const B() : super();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
+    assertErrors(source, [CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
     verify([source]);
   }
   void test_optionalParameterInOperator_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator +({p}) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR]);
+    assertErrors(source, [CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR]);
     verify([source]);
   }
   void test_optionalParameterInOperator_positional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator +([p]) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR]);
+    assertErrors(source, [CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR]);
     verify([source]);
   }
   void test_partOfNonPart() {
     Source source = addSource(EngineTestCase.createSource(["library l1;", "part 'l2.dart';"]));
     addSource2("/l2.dart", EngineTestCase.createSource(["library l2;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.PART_OF_NON_PART]);
+    assertErrors(source, [CompileTimeErrorCode.PART_OF_NON_PART]);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers_functionTypeAlias() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "typedef p();", "p.A a;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
+    assertErrors(source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers_topLevelFunction() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "p() {}", "p.A a;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
+    assertErrors(source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers_topLevelVariable() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "var p = null;", "p.A a;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
+    assertErrors(source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers_type() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "class p {}", "p.A a;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
+    assertErrors(source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
   void test_privateOptionalParameter() {
     Source source = addSource(EngineTestCase.createSource(["f({var _p}) {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
+    assertErrors(source, [CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
     verify([source]);
   }
   void test_privateOptionalParameter_fieldFormal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  var _p;", "  A({this._p: 0});", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
+    assertErrors(source, [CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
     verify([source]);
   }
   void test_privateOptionalParameter_withDefaultValue() {
     Source source = addSource(EngineTestCase.createSource(["f({_p : 0}) {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
+    assertErrors(source, [CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
     verify([source]);
   }
   void test_recursiveConstructorRedirect() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.a() : this.b();",
         "  A.b() : this.a();",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT]);
     verify([source]);
   }
   void test_recursiveConstructorRedirect_directSelfReference() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() : this();", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT]);
+    assertErrors(source, [CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT]);
     verify([source]);
   }
   void test_recursiveFactoryRedirect() {
     Source source = addSource(EngineTestCase.createSource([
         "class A implements B {",
         "  factory A() = C;",
         "}",
         "class B implements C {",
         "  factory B() = A;",
         "}",
         "class C implements A {",
         "  factory C() = B;",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
     verify([source]);
   }
   void test_recursiveFactoryRedirect_directSelfReference() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A() = A;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT]);
+    assertErrors(source, [CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT]);
     verify([source]);
   }
   void test_recursiveFactoryRedirect_generic() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<T> implements B<T> {",
         "  factory A() = C;",
         "}",
         "class B<T> implements C<T> {",
         "  factory B() = A;",
         "}",
         "class C<T> implements A<T> {",
         "  factory C() = B;",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
     verify([source]);
   }
   void test_recursiveFactoryRedirect_named() {
     Source source = addSource(EngineTestCase.createSource([
         "class A implements B {",
         "  factory A.nameA() = C.nameC;",
         "}",
         "class B implements C {",
         "  factory B.nameB() = A.nameA;",
         "}",
         "class C implements A {",
         "  factory C.nameC() = B.nameB;",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
     verify([source]);
   }
 
   /**
    * "A" references "C" which has cycle with "B". But we should not report problem for "A" - it is
    * not the part of a cycle.
    */
   void test_recursiveFactoryRedirect_outsideCycle() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  factory A() = C;",
         "}",
         "class B implements C {",
         "  factory B() = C;",
         "}",
         "class C implements A, B {",
         "  factory C() = B;",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritance_extends() {
     Source source = addSource(EngineTestCase.createSource(["class A extends B {}", "class B extends A {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritance_extends_implements() {
     Source source = addSource(EngineTestCase.createSource(["class A extends B {}", "class B implements A {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritance_implements() {
     Source source = addSource(EngineTestCase.createSource(["class A implements B {}", "class B implements A {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritance_tail() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A implements A {}",
         "class B implements A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
+    assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritance_tail2() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A implements B {}",
         "abstract class B implements A {}",
         "class C implements A {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritance_tail3() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A implements B {}",
         "abstract class B implements C {}",
         "abstract class C implements A {}",
         "class D implements A {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
         CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritanceBaseCaseExtends() {
     Source source = addSource(EngineTestCase.createSource(["class A extends A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS]);
+    assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritanceBaseCaseImplements() {
     Source source = addSource(EngineTestCase.createSource(["class A implements A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
+    assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritanceBaseCaseImplements_typedef() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class M {}",
         "typedef B = A with M implements B;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
+    assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
     verify([source]);
   }
   void test_redirectToNonConstConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.a() {}",
         "  const factory A.b() = A.a;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR]);
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_closure() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var x = (x) {};", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_getter() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  int x = x + 1;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_setter() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  int x = x++;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_unqualifiedInvocation() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var x = x();", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_rethrowOutsideCatch() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  rethrow;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH]);
+    assertErrors(source, [CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH]);
     verify([source]);
   }
   void test_returnInGenerativeConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() { return 0; }", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_returnInGenerativeConstructor_expressionFunctionBody() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() => null;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_superInInvalidContext_binaryExpression() {
     Source source = addSource(EngineTestCase.createSource(["var v = super + 0;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
   }
   void test_superInInvalidContext_constructorFieldInitializer() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "}",
         "class B extends A {",
         "  var f;",
         "  B() : f = super.m();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
   }
   void test_superInInvalidContext_factoryConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "}",
         "class B extends A {",
         "  factory B() {",
         "    super.m();",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
   }
   void test_superInInvalidContext_instanceVariableInitializer() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var a;",
         "}",
         "class B extends A {",
         " var b = super.a;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
   }
   void test_superInInvalidContext_staticMethod() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static m() {}",
         "}",
         "class B extends A {",
         "  static n() { return super.m(); }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
   }
   void test_superInInvalidContext_staticVariableInitializer() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int a = 0;",
         "}",
         "class B extends A {",
         "  static int b = super.a;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
   }
   void test_superInInvalidContext_topLevelFunction() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  super.f();", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
   }
   void test_superInInvalidContext_topLevelVariableInitializer() {
     Source source = addSource(EngineTestCase.createSource(["var v = super.y;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
   }
   void test_superInRedirectingConstructor_redirectionSuper() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {",
         "  B() : this.name(), super();",
         "  B.name() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
   void test_superInRedirectingConstructor_superRedirection() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {",
         "  B() : super(), this.name();",
         "  B.name() {}",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR]);
+    assertErrors(source, [CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_parameterType_named() {
     Source source = addSource(EngineTestCase.createSource(["typedef A({A a});"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_parameterType_positional() {
     Source source = addSource(EngineTestCase.createSource(["typedef A([A a]);"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_parameterType_required() {
     Source source = addSource(EngineTestCase.createSource(["typedef A(A a);"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_parameterType_typeArgument() {
     Source source = addSource(EngineTestCase.createSource(["typedef A(List<A> a);"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_returnClass_withTypeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "typedef C A();",
         "typedef A B();",
         "class C {",
         "  B a;",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_returnType() {
     Source source = addSource(EngineTestCase.createSource(["typedef A A();"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_returnType_indirect() {
     Source source = addSource(EngineTestCase.createSource(["typedef B A();", "typedef A B();"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotRereferenceItself_mixin_direct() {
     Source source = addSource(EngineTestCase.createSource(["typedef M = Object with M;"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotRereferenceItself_mixin_indirect() {
     Source source = addSource(EngineTestCase.createSource([
         "typedef M1 = Object with M2;",
         "typedef M2 = Object with M1;"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_const() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {",
         "  const G();",
         "}",
         "f() { return const G<B>(); }"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    assertErrors(source, [CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_undefinedClass_const() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  return const A();", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.UNDEFINED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.UNDEFINED_CLASS]);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_explicit_named() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {",
         "  B() : super.named();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER]);
+    assertErrors(source, [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER]);
   }
   void test_undefinedConstructorInInitializer_explicit_unnamed() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.named() {}",
         "}",
         "class B extends A {",
         "  B() : super();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
+    assertErrors(source, [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_implicit() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.named() {}",
         "}",
         "class B extends A {",
         "  B();",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
+    assertErrors(source, [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
   void test_undefinedFunction() {
     Source source = addSource(EngineTestCase.createSource(["void f() {", "  g();", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.UNDEFINED_FUNCTION]);
+    assertErrors(source, [CompileTimeErrorCode.UNDEFINED_FUNCTION]);
   }
   void test_undefinedFunction_hasImportPrefix() {
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as f;", "main() { return f(); }"]));
     addSource2("/lib.dart", "library lib;");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.UNDEFINED_FUNCTION]);
+    assertErrors(source, [CompileTimeErrorCode.UNDEFINED_FUNCTION]);
   }
   void test_undefinedFunction_inCatch() {
     Source source = addSource(EngineTestCase.createSource([
         "void f() {",
         "  try {",
         "  } on Object {",
         "    g();",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.UNDEFINED_FUNCTION]);
+    assertErrors(source, [CompileTimeErrorCode.UNDEFINED_FUNCTION]);
   }
   void test_undefinedNamedParameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "main() {",
         "  const A(p: 0);",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER]);
+    assertErrors(source, [CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER]);
   }
   void test_uriDoesNotExist_export() {
     Source source = addSource(EngineTestCase.createSource(["export 'unknown.dart';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+    assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
   void test_uriDoesNotExist_import() {
     Source source = addSource(EngineTestCase.createSource(["import 'unknown.dart';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+    assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
   void test_uriDoesNotExist_part() {
     Source source = addSource(EngineTestCase.createSource(["part 'unknown.dart';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+    assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
   void test_uriWithInterpolation_constant() {
     Source source = addSource(EngineTestCase.createSource(["import 'stuff_\$platform.dart';"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.URI_WITH_INTERPOLATION,
         StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_uriWithInterpolation_nonConstant() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "part '\${'a'}.dart';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.URI_WITH_INTERPOLATION]);
+    assertErrors(source, [CompileTimeErrorCode.URI_WITH_INTERPOLATION]);
   }
   void test_wrongNumberOfParametersForOperator_minus() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator -(a, b) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS]);
     verify([source]);
     reset();
   }
   void test_wrongNumberOfParametersForOperator_tilde() {
     check_wrongNumberOfParametersForOperator("~", "a");
     check_wrongNumberOfParametersForOperator("~", "a, b");
   }
   void test_wrongNumberOfParametersForOperator1() {
     check_wrongNumberOfParametersForOperator1("<");
     check_wrongNumberOfParametersForOperator1(">");
     check_wrongNumberOfParametersForOperator1("<=");
     check_wrongNumberOfParametersForOperator1(">=");
     check_wrongNumberOfParametersForOperator1("+");
     check_wrongNumberOfParametersForOperator1("/");
     check_wrongNumberOfParametersForOperator1("~/");
     check_wrongNumberOfParametersForOperator1("*");
     check_wrongNumberOfParametersForOperator1("%");
     check_wrongNumberOfParametersForOperator1("|");
     check_wrongNumberOfParametersForOperator1("^");
     check_wrongNumberOfParametersForOperator1("&");
     check_wrongNumberOfParametersForOperator1("<<");
     check_wrongNumberOfParametersForOperator1(">>");
     check_wrongNumberOfParametersForOperator1("[]");
   }
   void test_wrongNumberOfParametersForSetter_function_named() {
     Source source = addSource("set x({p}) {}");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void test_wrongNumberOfParametersForSetter_function_optional() {
     Source source = addSource("set x([p]) {}");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void test_wrongNumberOfParametersForSetter_function_tooFew() {
     Source source = addSource("set x() {}");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void test_wrongNumberOfParametersForSetter_function_tooMany() {
     Source source = addSource("set x(a, b) {}");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void test_wrongNumberOfParametersForSetter_method_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set x({p}) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void test_wrongNumberOfParametersForSetter_method_optional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set x([p]) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void test_wrongNumberOfParametersForSetter_method_tooFew() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set x() {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void test_wrongNumberOfParametersForSetter_method_tooMany() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set x(a, b) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void check_constEvalThrowsException_binary_null(String expr, bool resolved) {
     Source source = addSource("const C = ${expr};");
     resolve(source);
     if (resolved) {
-      assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
+      assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
       verify([source]);
     } else {
-      assertErrors([
+      assertErrors(source, [
           CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
           StaticTypeWarningCode.UNDEFINED_OPERATOR]);
     }
     reset();
   }
   void check_constEvalTypeBool_withParameter_binary(String expr) {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final a;",
         "  const A(bool p) : a = ${expr};",
         "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
     verify([source]);
     reset();
   }
   void check_constEvalTypeInt_withParameter_binary(String expr) {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final a;",
         "  const A(int p) : a = ${expr};",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_TYPE_INT,
         CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
     reset();
   }
   void check_constEvalTypeNum_withParameter_binary(String expr) {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final a;",
         "  const A(num p) : a = ${expr};",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_TYPE_NUM,
         CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
     reset();
   }
   void check_wrongNumberOfParametersForOperator(String name, String parameters) {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator ${name}(${parameters}) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR]);
+    assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR]);
     verify([source]);
     reset();
   }
   void check_wrongNumberOfParametersForOperator1(String name) {
     check_wrongNumberOfParametersForOperator(name, "");
     check_wrongNumberOfParametersForOperator(name, "a, b");
   }
   static dartSuite() {
     _ut.group('CompileTimeErrorCodeTest', () {
       _ut.test('test_ambiguousExport', () {
@@ skipping 17 matching lines @@
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_const_super);
       });
       _ut.test('test_builtInIdentifierAsType', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsType);
       });
       _ut.test('test_builtInIdentifierAsTypeName', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypeName);
       });
-      _ut.test('test_builtInIdentifierAsTypeVariableName', () {
+      _ut.test('test_builtInIdentifierAsTypeParameterName', () {
         final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_builtInIdentifierAsTypeVariableName);
+        runJUnitTest(__test, __test.test_builtInIdentifierAsTypeParameterName);
       });
       _ut.test('test_builtInIdentifierAsTypedefName_classTypeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_classTypeAlias);
       });
       _ut.test('test_builtInIdentifierAsTypedefName_functionTypeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_functionTypeAlias);
       });
       _ut.test('test_caseExpressionTypeImplementsEquals', () {
@@ skipping 353 matching lines @@
         runJUnitTest(__test, __test.test_finalInitializedMultipleTimes_initializers);
       });
       _ut.test('test_finalInitializedMultipleTimes_initializingFormal_initializer', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_finalInitializedMultipleTimes_initializingFormal_initializer);
       });
       _ut.test('test_finalInitializedMultipleTimes_initializingFormals', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_finalInitializedMultipleTimes_initializingFormals);
       });
+      _ut.test('test_finalNotInitialized_instanceField_const_static', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_finalNotInitialized_instanceField_const_static);
+      });
+      _ut.test('test_finalNotInitialized_library_const', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_finalNotInitialized_library_const);
+      });
+      _ut.test('test_finalNotInitialized_local_const', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_finalNotInitialized_local_const);
+      });
       _ut.test('test_getterAndMethodWithSameName', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_getterAndMethodWithSameName);
       });
       _ut.test('test_implementsDisallowedClass_Null', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsDisallowedClass_Null);
       });
       _ut.test('test_implementsDisallowedClass_String', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 971 matching lines @@
 class StrictModeTest extends ResolverTestCase {
   void fail_for() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(List<int> list) {",
         "  num sum = 0;",
         "  for (num i = 0; i < list.length; i++) {",
         "    sum += list[i];",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strictMode = true;
+    options.hint = false;
     analysisContext.analysisOptions = options;
   }
   void test_assert_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  assert (n is int);",
         "  return n & 0x0F;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_conditional_and_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  return (n is int && n > 0) ? n & 0x0F : 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_conditional_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  return (n is int) ? n & 0x0F : 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_conditional_isNot() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  return (n is! int) ? 0 : n & 0x0F;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_conditional_or_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  return (n is! int || n < 0) ? 0 : n & 0x0F;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_forEach() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(List<int> list) {",
         "  num sum = 0;",
         "  for (num n in list) {",
         "    sum += n & 0x0F;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_if_and_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  if (n is int && n > 0) {",
         "    return n & 0x0F;",
         "  }",
         "  return 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_if_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  if (n is int) {",
         "    return n & 0x0F;",
         "  }",
         "  return 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_if_isNot() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  if (n is! int) {",
         "    return 0;",
         "  } else {",
         "    return n & 0x0F;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_if_isNot_abrupt() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  if (n is! int) {",
         "    return 0;",
         "  }",
         "  return n & 0x0F;",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_if_or_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  if (n is! int || n < 0) {",
         "    return 0;",
         "  } else {",
         "    return n & 0x0F;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_localVar() {
     Source source = addSource(EngineTestCase.createSource(["int f() {", "  num n = 1234;", "  return n & 0x0F;", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   static dartSuite() {
     _ut.group('StrictModeTest', () {
       _ut.test('test_assert_is', () {
         final __test = new StrictModeTest();
         runJUnitTest(__test, __test.test_assert_is);
       });
       _ut.test('test_conditional_and_is', () {
         final __test = new StrictModeTest();
         runJUnitTest(__test, __test.test_conditional_and_is);
@@ skipping 429 matching lines @@
   }
   void test_visitSuperConstructorInvocation() {
     ClassElementImpl superclass = ElementFactory.classElement2("A", []);
     ConstructorElementImpl superConstructor = ElementFactory.constructorElement(superclass, null);
     superclass.constructors = <ConstructorElement> [superConstructor];
     ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type, []);
     ConstructorElementImpl subConstructor = ElementFactory.constructorElement(subclass, null);
     subclass.constructors = <ConstructorElement> [subConstructor];
     SuperConstructorInvocation invocation = ASTFactory.superConstructorInvocation([]);
     resolveInClass(invocation, subclass);
-    JUnitTestCase.assertEquals(superConstructor, invocation.element);
+    JUnitTestCase.assertEquals(superConstructor, invocation.staticElement);
     _listener.assertNoErrors();
   }
   void test_visitSuperConstructorInvocation_namedParameter() {
     ClassElementImpl superclass = ElementFactory.classElement2("A", []);
     ConstructorElementImpl superConstructor = ElementFactory.constructorElement(superclass, null);
     String parameterName = "p";
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     superConstructor.parameters = <ParameterElement> [parameter];
     superclass.constructors = <ConstructorElement> [superConstructor];
     ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type, []);
     ConstructorElementImpl subConstructor = ElementFactory.constructorElement(subclass, null);
     subclass.constructors = <ConstructorElement> [subConstructor];
     SuperConstructorInvocation invocation = ASTFactory.superConstructorInvocation([ASTFactory.namedExpression2(parameterName, ASTFactory.integer(0))]);
     resolveInClass(invocation, subclass);
-    JUnitTestCase.assertEquals(superConstructor, invocation.element);
+    JUnitTestCase.assertEquals(superConstructor, invocation.staticElement);
     JUnitTestCase.assertSame(parameter, ((invocation.argumentList.arguments[0] as NamedExpression)).name.label.staticElement);
     _listener.assertNoErrors();
   }
 
   /**
    * Create the resolver used by the tests.
    *
    * @return the resolver that was created
    */
   ElementResolver createResolver() {
@@ skipping 377 matching lines @@
         final __test = new TypeOverrideManagerTest();
         runJUnitTest(__test, __test.test_getType_noScope);
       });
     });
   }
 }
 class PubSuggestionCodeTest extends ResolverTestCase {
   void test_import_package() {
     Source source = addSource(EngineTestCase.createSource(["import 'package:somepackage/other.dart';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+    assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
   void test_import_packageWithDotDot() {
     Source source = addSource(EngineTestCase.createSource(["import 'package:somepackage/../other.dart';"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.URI_DOES_NOT_EXIST,
         PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT]);
   }
   void test_import_packageWithLeadingDotDot() {
     Source source = addSource(EngineTestCase.createSource(["import 'package:../other.dart';"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         CompileTimeErrorCode.URI_DOES_NOT_EXIST,
         PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT]);
   }
   void test_import_referenceIntoLibDirectory() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/lib/other.dart", "");
     Source source = addSource2("/myproj/web/test.dart", EngineTestCase.createSource(["import '../lib/other.dart';"]));
     resolve(source);
-    assertErrors([PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE]);
+    assertErrors(source, [PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE]);
   }
   void test_import_referenceIntoLibDirectory_no_pubspec() {
     cacheSource("/myproj/lib/other.dart", "");
     Source source = addSource2("/myproj/web/test.dart", EngineTestCase.createSource(["import '../lib/other.dart';"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_import_referenceOutOfLibDirectory() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/web/other.dart", "");
     Source source = addSource2("/myproj/lib/test.dart", EngineTestCase.createSource(["import '../web/other.dart';"]));
     resolve(source);
-    assertErrors([PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE]);
+    assertErrors(source, [PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE]);
   }
   void test_import_referenceOutOfLibDirectory_no_pubspec() {
     cacheSource("/myproj/web/other.dart", "");
     Source source = addSource2("/myproj/lib/test.dart", EngineTestCase.createSource(["import '../web/other.dart';"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_import_valid_inside_lib1() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/lib/other.dart", "");
     Source source = addSource2("/myproj/lib/test.dart", EngineTestCase.createSource(["import 'other.dart';"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_import_valid_inside_lib2() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/lib/bar/other.dart", "");
     Source source = addSource2("/myproj/lib/foo/test.dart", EngineTestCase.createSource(["import '../bar/other.dart';"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   void test_import_valid_outside_lib() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/web/other.dart", "");
     Source source = addSource2("/myproj/lib2/test.dart", EngineTestCase.createSource(["import '../web/other.dart';"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
   }
   static dartSuite() {
     _ut.group('PubSuggestionCodeTest', () {
       _ut.test('test_import_package', () {
         final __test = new PubSuggestionCodeTest();
         runJUnitTest(__test, __test.test_import_package);
       });
       _ut.test('test_import_packageWithDotDot', () {
         final __test = new PubSuggestionCodeTest();
         runJUnitTest(__test, __test.test_import_packageWithDotDot);
@@ skipping 35 matching lines @@
 }
 class StaticWarningCodeTest extends ResolverTestCase {
   void fail_argumentTypeNotAssignable_invocation_functionParameter_generic() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<K, V> {",
         "  m(f(K k), V v) {",
         "    f(v);",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void fail_commentReferenceConstructorNotVisible() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([StaticWarningCode.COMMENT_REFERENCE_CONSTRUCTOR_NOT_VISIBLE]);
+    assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_CONSTRUCTOR_NOT_VISIBLE]);
     verify([source]);
   }
   void fail_commentReferenceIdentifierNotVisible() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([StaticWarningCode.COMMENT_REFERENCE_IDENTIFIER_NOT_VISIBLE]);
+    assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_IDENTIFIER_NOT_VISIBLE]);
     verify([source]);
   }
   void fail_commentReferenceUndeclaredConstructor() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([StaticWarningCode.COMMENT_REFERENCE_UNDECLARED_CONSTRUCTOR]);
+    assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_UNDECLARED_CONSTRUCTOR]);
     verify([source]);
   }
   void fail_commentReferenceUndeclaredIdentifier() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([StaticWarningCode.COMMENT_REFERENCE_UNDECLARED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_UNDECLARED_IDENTIFIER]);
     verify([source]);
   }
   void fail_commentReferenceUriNotLibrary() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([StaticWarningCode.COMMENT_REFERENCE_URI_NOT_LIBRARY]);
+    assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_URI_NOT_LIBRARY]);
     verify([source]);
   }
   void fail_mismatchedAccessorTypes_getterAndSuperSetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get g { return 0; }",
         "  set g(int v) {}",
         "}",
         "class B extends A {",
         "  set g(String v) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
+    assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
   void fail_mismatchedAccessorTypes_superGetterAndSetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get g { return 0; }",
         "  set g(int v) {}",
         "}",
         "class B extends A {",
         "  String get g { return ''; }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
+    assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
   void fail_undefinedGetter() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_GETTER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_GETTER]);
     verify([source]);
   }
   void fail_undefinedIdentifier_commentReference() {
     Source source = addSource(EngineTestCase.createSource(["/** [m] xxx [new B.c] */", "class A {", "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         StaticWarningCode.UNDEFINED_IDENTIFIER,
         StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void fail_undefinedSetter() {
     Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", "  C.m = 0;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_SETTER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_SETTER]);
     verify([source]);
   }
   void fail_undefinedStaticMethodOrGetter_getter() {
     Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", "  f(C.m);", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]);
     verify([source]);
   }
   void fail_undefinedStaticMethodOrGetter_method() {
     Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", "  f(C.m());", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]);
     verify([source]);
   }
   void test_ambiguousImport_as() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "f(p) {p as N;}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+    assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_extends() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "class A extends N {}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         StaticWarningCode.AMBIGUOUS_IMPORT,
         CompileTimeErrorCode.EXTENDS_NON_CLASS]);
   }
   void test_ambiguousImport_implements() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "class A implements N {}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         StaticWarningCode.AMBIGUOUS_IMPORT,
         CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
   }
   void test_ambiguousImport_instanceCreation() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "f() {new N();}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+    assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_is() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "f(p) {p is N;}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+    assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_qualifier() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "g() { N.FOO; }"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+    assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_typeAnnotation() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "typedef N FT(N p);",
         "N f(N p) {",
         "  N v;",
         "}",
         "class A {",
         "  N m() {}",
         "}",
         "class B<T extends N> {}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_typeArgument_annotation() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "class A<T> {}",
         "A<N> f() {}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+    assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_typeArgument_instanceCreation() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "class A<T> {}",
         "f() {new A<N>();}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+    assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_varRead() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "f() { g(v); }",
         "g(p) {}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "var v;"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "var v;"]));
     resolve(source);
-    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+    assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_varWrite() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "f() { v = 0; }"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "var v;"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "var v;"]));
     resolve(source);
-    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+    assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
   void test_argumentTypeNotAssignable_annotation_namedConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A.fromInt(int p);",
         "}",
         "@A.fromInt('0')",
         "main() {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_annotation_unnamedConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(int p);",
         "}",
         "@A('0')",
         "main() {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_binary() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  operator +(int p) {}",
         "}",
         "f(A a) {",
         "  a + '0';",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_index() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  operator [](int index) {}",
         "}",
         "f(A a) {",
         "  a['0'];",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_callParameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  call(int p) {}",
         "}",
         "f(A a) {",
         "  a('0');",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_callVariable() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  call(int p) {}",
         "}",
         "main() {",
         "  A a = new A();",
         "  a('0');",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_functionParameter() {
     Source source = addSource(EngineTestCase.createSource(["a(b(int p)) {", "  b('0');", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_functionTypes_optional() {
     Source source = addSource(EngineTestCase.createSource([
         "void acceptFunNumOptBool(void funNumOptBool([bool b])) {}",
         "void funNumBool(bool b) {}",
         "main() {",
         "  acceptFunNumOptBool(funNumBool);",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_generic() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<T> {",
         "  m(T t) {}",
         "}",
         "f(A<String> a) {",
         "  a.m(1);",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_named() {
     Source source = addSource(EngineTestCase.createSource(["f({String p}) {}", "main() {", "  f(p: 42);", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_optional() {
     Source source = addSource(EngineTestCase.createSource(["f([String p]) {}", "main() {", "  f(42);", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_required() {
     Source source = addSource(EngineTestCase.createSource(["f(String p) {}", "main() {", "  f(42);", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_typedef_generic() {
     Source source = addSource(EngineTestCase.createSource(["typedef A<T>(T p);", "f(A<int> a) {", "  a('1');", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_typedef_local() {
     Source source = addSource(EngineTestCase.createSource([
         "typedef A(int p);",
         "A getA() => null;",
         "main() {",
         "  A a = getA();",
         "  a('1');",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_typedef_parameter() {
     Source source = addSource(EngineTestCase.createSource(["typedef A(int p);", "f(A a) {", "  a('1');", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_new_generic() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<T> {",
         "  A(T p) {}",
         "}",
         "main() {",
         "  new A<String>(42);",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_new_optional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A([String p]) {}",
         "}",
         "main() {",
         "  new A(42);",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_new_required() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A(String p) {}",
         "}",
         "main() {",
         "  new A(42);",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_assignmentToConst_instanceVariable() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static const v = 0;",
         "}",
         "f() {",
         "  A.v = 1;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_CONST]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_CONST]);
     verify([source]);
   }
   void test_assignmentToConst_localVariable() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  const x = 0;", "  x = 1;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_CONST]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_CONST]);
     verify([source]);
   }
   void test_assignmentToFinal_instanceVariable() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final v = 0;",
         "}",
         "f() {",
         "  A a = new A();",
         "  a.v = 1;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_FINAL]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
     verify([source]);
   }
   void test_assignmentToFinal_localVariable() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  x = 1;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_FINAL]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
     verify([source]);
   }
   void test_assignmentToFinal_prefixMinusMinus() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  --x;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_FINAL]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
     verify([source]);
   }
   void test_assignmentToFinal_prefixPlusPlus() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  ++x;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_FINAL]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
     verify([source]);
   }
   void test_assignmentToFinal_propertyAccess() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get x => 0;",
         "}",
         "class B {",
         "  static A a;",
         "}",
         "main() {",
         "  B.a.x = 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_FINAL]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
     verify([source]);
   }
   void test_assignmentToFinal_suffixMinusMinus() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  x--;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_FINAL]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
     verify([source]);
   }
   void test_assignmentToFinal_suffixPlusPlus() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  x++;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_FINAL]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
     verify([source]);
   }
   void test_assignmentToFinal_topLevelVariable() {
     Source source = addSource(EngineTestCase.createSource(["final x = 0;", "f() { x = 1; }"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_FINAL]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
     verify([source]);
   }
   void test_assignmentToMethod() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "}",
         "f(A a) {",
         "  a.m = () {};",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.ASSIGNMENT_TO_METHOD]);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_METHOD]);
     verify([source]);
   }
   void test_caseBlockNotTerminated() {
     Source source = addSource(EngineTestCase.createSource([
         "f(int p) {",
         "  switch (p) {",
         "    case 0:",
         "      f(p);",
         "    case 1:",
         "      break;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CASE_BLOCK_NOT_TERMINATED]);
+    assertErrors(source, [StaticWarningCode.CASE_BLOCK_NOT_TERMINATED]);
     verify([source]);
   }
   void test_castToNonType() {
     Source source = addSource(EngineTestCase.createSource(["var A = 0;", "f(String s) { var x = s as A; }"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CAST_TO_NON_TYPE]);
+    assertErrors(source, [StaticWarningCode.CAST_TO_NON_TYPE]);
     verify([source]);
   }
   void test_concreteClassWithAbstractMember() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m();", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER]);
     verify([source]);
   }
   void test_conflictingInstanceGetterAndSuperclassMember_direct_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int v;",
         "}",
         "class B extends A {",
         "  get v => 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
   void test_conflictingInstanceGetterAndSuperclassMember_direct_getter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static get v => 0;",
         "}",
         "class B extends A {",
         "  get v => 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
   void test_conflictingInstanceGetterAndSuperclassMember_direct_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static v() {}",
         "}",
         "class B extends A {",
         "  get v => 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
   void test_conflictingInstanceGetterAndSuperclassMember_direct_setter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static set v(x) {}",
         "}",
         "class B extends A {",
         "  get v => 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
   void test_conflictingInstanceGetterAndSuperclassMember_indirect() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int v;",
         "}",
         "class B extends A {}",
         "class C extends B {",
         "  get v => 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
   void test_conflictingInstanceGetterAndSuperclassMember_mixin() {
     Source source = addSource(EngineTestCase.createSource([
         "class M {",
         "  static int v;",
         "}",
         "class B extends Object with M {",
         "  get v => 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
   void test_conflictingInstanceSetterAndSuperclassMember() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int v;",
         "}",
         "class B extends A {",
         "  set v(x) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
   void test_conflictingStaticGetterAndInstanceSetter_mixin() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  set x(int p) {}",
         "}",
         "class B extends Object with A {",
         "  static get x => 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
     verify([source]);
   }
   void test_conflictingStaticGetterAndInstanceSetter_superClass() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  set x(int p) {}",
         "}",
         "class B extends A {",
         "  static get x => 0;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
     verify([source]);
   }
   void test_conflictingStaticGetterAndInstanceSetter_thisClass() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static get x => 0;",
         "  set x(int p) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
     verify([source]);
   }
   void test_conflictingStaticSetterAndInstanceMember_thisClass_getter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  get x => 0;",
         "  static set x(int p) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER]);
     verify([source]);
   }
   void test_conflictingStaticSetterAndInstanceMember_thisClass_method() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  x() {}", "  static set x(int p) {}", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER]);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER]);
     verify([source]);
   }
   void test_constWithAbstractClass() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  const A();",
         "}",
         "void f() {",
         "  A a = const A();",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.CONST_WITH_ABSTRACT_CLASS]);
+    assertErrors(source, [StaticWarningCode.CONST_WITH_ABSTRACT_CLASS]);
     verify([source]);
   }
   void test_equalKeysInMap() {
     Source source = addSource(EngineTestCase.createSource(["var m = {'a' : 0, 'b' : 1, 'a' : 2};"]));
     resolve(source);
-    assertErrors([StaticWarningCode.EQUAL_KEYS_IN_MAP]);
+    assertErrors(source, [StaticWarningCode.EQUAL_KEYS_IN_MAP]);
     verify([source]);
   }
   void test_exportDuplicatedLibraryName() {
     Source source = addSource(EngineTestCase.createSource([
         "library test;",
         "export 'lib1.dart';",
         "export 'lib2.dart';"]));
     addSource2("/lib1.dart", "library lib;");
     addSource2("/lib2.dart", "library lib;");
     resolve(source);
-    assertErrors([StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAME]);
+    assertErrors(source, [StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAME]);
     verify([source]);
   }
   void test_extraPositionalArguments() {
     Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", "  f(0, 1, '2');", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS]);
+    assertErrors(source, [StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS]);
     verify([source]);
   }
   void test_fieldInitializedInInitializerAndDeclaration_final() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int x = 0;",
         "  A() : x = 1 {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
+    assertErrors(source, [StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
     verify([source]);
   }
   void test_fieldInitializerNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A() : x = '';", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_fieldInitializingFormalNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A(String this.x) {}", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   /**
    * This test doesn't test the FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR code, but tests the
    * FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION code instead. It is provided here to show
    * coverage over all of the permutations of initializers in constructor declarations.
    *
    * Note: FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION covers a subset of
    * FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR, since it more specific, we use it instead of
    * the broader code
    */
   void test_finalInitializedInDeclarationAndConstructor_initializers() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x = 0;", "  A() : x = 0 {}", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
+    assertErrors(source, [StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
     verify([source]);
   }
   void test_finalInitializedInDeclarationAndConstructor_initializingFormal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x = 0;", "  A(this.x) {}", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR]);
+    assertErrors(source, [StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR]);
     verify([source]);
   }
   void test_finalNotInitialized_inConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x;", "  A() {}", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
-    verify([source]);
-  }
-  void test_finalNotInitialized_instanceField_const_static() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static const F;", "}"]));
-    resolve(source);
-    assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
+    assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
     verify([source]);
   }
   void test_finalNotInitialized_instanceField_final() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final F;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
+    assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
     verify([source]);
   }
   void test_finalNotInitialized_instanceField_final_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static final F;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
-    verify([source]);
-  }
-  void test_finalNotInitialized_library_const() {
-    Source source = addSource(EngineTestCase.createSource(["const F;"]));
-    resolve(source);
-    assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
+    assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
     verify([source]);
   }
   void test_finalNotInitialized_library_final() {
     Source source = addSource(EngineTestCase.createSource(["final F;"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
-    verify([source]);
-  }
-  void test_finalNotInitialized_local_const() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  const int x;", "}"]));
-    resolve(source);
-    assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
+    assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
     verify([source]);
   }
   void test_finalNotInitialized_local_final() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final int x;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
+    assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
     verify([source]);
   }
   void test_importDuplicatedLibraryName() {
     Source source = addSource(EngineTestCase.createSource([
         "library test;",
         "import 'lib1.dart';",
         "import 'lib2.dart';"]));
     addSource2("/lib1.dart", "library lib;");
     addSource2("/lib2.dart", "library lib;");
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAME,
         HintCode.UNUSED_IMPORT,
         HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
   void test_inconsistentMethodInheritanceGetterAndMethod() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int x();",
         "}",
         "abstract class B {",
         "  int get x;",
         "}",
         "class C implements A, B {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
+    assertErrors(source, [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static var n;",
         "}",
         "class B extends A {",
         "  void n() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
+    assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_field2() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static var n;",
         "}",
         "class B extends A {",
         "}",
         "class C extends B {",
         "  void n() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
+    assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_getter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static get n {return 0;}",
         "}",
         "class B extends A {",
         "  void n() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
+    assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_getter2() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static get n {return 0;}",
         "}",
         "class B extends A {",
         "}",
         "class C extends B {",
         "  void n() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
+    assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static n () {}",
         "}",
         "class B extends A {",
         "  void n() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
+    assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_method2() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static n () {}",
         "}",
         "class B extends A {",
         "}",
         "class C extends B {",
         "  void n() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
+    assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_setter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static set n(int x) {}",
         "}",
         "class B extends A {",
         "  void n() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
+    assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_setter2() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static set n(int x) {}",
         "}",
         "class B extends A {",
         "}",
         "class C extends B {",
         "  void n() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
+    assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
     verify([source]);
   }
   void test_invalidGetterOverrideReturnType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get g { return 0; }",
         "}",
         "class B extends A {",
         "  String get g { return 'a'; }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
   void test_invalidGetterOverrideReturnType_implicit() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  String f;",
         "}",
         "class B extends A {",
         "  int f;",
         "}"]));
     resolve(source);
-    assertErrors([
+    assertErrors(source, [
         StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE,
         StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideNamedParamType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m({int a}) {}",
         "}",
         "class B implements A {",
         "  m({String a}) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideNormalParamType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m(int a) {}",
         "}",
         "class B implements A {",
         "  m(String a) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideOptionalParamType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m([int a]) {}",
         "}",
         "class B implements A {",
         "  m([String a]) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideReturnType_interface() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int m() { return 0; }",
         "}",
         "class B implements A {",
         "  String m() { return 'a'; }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideReturnType_interface2() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int m();",
         "}",
         "abstract class B implements A {",
         "}",
         "class C implements B {",
         "  String m() { return 'a'; }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideReturnType_mixin() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int m() { return 0; }",
         "}",
         "class B extends Object with A {",
         "  String m() { return 'a'; }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideReturnType_superclass() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int m() { return 0; }",
         "}",
         "class B extends A {",
         "  String m() { return 'a'; }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideReturnType_superclass2() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int m() { return 0; }",
         "}",
         "class B extends A {",
         "}",
         "class C extends B {",
         "  String m() { return 'a'; }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
   void test_invalidMethodOverrideReturnType_void() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int m() {}",
         "}",
         "class B extends A {",
         "  void m() {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
   void test_invalidOverrideDifferentDefaultValues_named() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m({int p : 0}) {}",
         "}",
         "class B extends A {",
         "  m({int p : 1}) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED]);
+    assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED]);
     verify([source]);
   }
   void test_invalidOverrideDifferentDefaultValues_positional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m([int p = 0]) {}",
         "}",
         "class B extends A {",
         "  m([int p = 1]) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL]);
+    assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL]);
     verify([source]);
   }
   void test_invalidOverrideNamed_fewerNamedParameters() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m({a, b}) {}",
         "}",
         "class B extends A {",
         "  m({a}) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_OVERRIDE_NAMED]);
+    assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_NAMED]);
     verify([source]);
   }
   void test_invalidOverrideNamed_missingNamedParameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m({a, b}) {}",
         "}",
         "class B extends A {",
         "  m({a, c}) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_OVERRIDE_NAMED]);
+    assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_NAMED]);
     verify([source]);
   }
   void test_invalidOverridePositional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m([a, b]) {}",
         "}",
         "class B extends A {",
         "  m([a]) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
+    assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
     verify([source]);
   }
   void test_invalidOverrideRequired() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m(a) {}",
         "}",
         "class B extends A {",
         "  m(a, b) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_OVERRIDE_REQUIRED]);
+    assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_REQUIRED]);
     verify([source]);
   }
   void test_invalidSetterOverrideNormalParamType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void set s(int v) {}",
         "}",
         "class B extends A {",
         "  void set s(String v) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
+    assertErrors(source, [StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
     verify([source]);
   }
   void test_listElementTypeNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["var v = <String> [42];"]));
     resolve(source);
-    assertErrors([StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_mapKeyTypeNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["var v = <String, int > {1 : 2};"]));
     resolve(source);
-    assertErrors([StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_mapValueTypeNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["var v = <String, String> {'a' : 2};"]));
     resolve(source);
-    assertErrors([StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_mismatchedAccessorTypes_class() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get g { return 0; }",
         "  set g(String v) {}",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
+    assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
   void test_mismatchedAccessorTypes_topLevel() {
     Source source = addSource(EngineTestCase.createSource(["int get g { return 0; }", "set g(String v) {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
+    assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
   void test_newWithAbstractClass() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {}",
         "void f() {",
         "  A a = new A();",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NEW_WITH_ABSTRACT_CLASS]);
+    assertErrors(source, [StaticWarningCode.NEW_WITH_ABSTRACT_CLASS]);
     verify([source]);
   }
   void test_newWithInvalidTypeParameters() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f() { return new A<A>(); }"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
+    assertErrors(source, [StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_newWithInvalidTypeParameters_tooFew() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class C<K, V> {}",
         "f(p) {",
         "  return new C<A>();",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
+    assertErrors(source, [StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_newWithInvalidTypeParameters_tooMany() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class C<E> {}",
         "f(p) {",
         "  return new C<A, A>();",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
+    assertErrors(source, [StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_newWithNonType() {
     Source source = addSource(EngineTestCase.createSource(["var A = 0;", "void f() {", "  var a = new A();", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NEW_WITH_NON_TYPE]);
+    assertErrors(source, [StaticWarningCode.NEW_WITH_NON_TYPE]);
     verify([source]);
   }
   void test_newWithNonType_fromLibrary() {
     Source source1 = addSource2("lib.dart", "class B {}");
     Source source2 = addSource2("lib2.dart", EngineTestCase.createSource([
         "import 'lib.dart' as lib;",
         "void f() {",
         "  var a = new lib.A();",
         "}",
         "lib.B b;"]));
     resolve(source1);
     resolve(source2);
-    assertErrors([StaticWarningCode.NEW_WITH_NON_TYPE]);
+    assertErrors(source2, [StaticWarningCode.NEW_WITH_NON_TYPE]);
     verify([source1]);
   }
   void test_newWithUndefinedConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "f() {",
         "  new A.name();",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR]);
+    assertErrors(source, [StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR]);
   }
   void test_newWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.name() {}",
         "}",
         "f() {",
         "  new A();",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
+    assertErrors(source, [StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberFivePlus() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  m();",
         "  n();",
         "  o();",
         "  p();",
         "  q();",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberFour() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  m();",
         "  n();",
         "  o();",
         "  p();",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface() {
     Source source = addSource(EngineTestCase.createSource([
         "class I {",
         "  int get g {return 1;}",
         "}",
         "class C implements I {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromSuperclass() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int get g;",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface() {
     Source source = addSource(EngineTestCase.createSource([
         "class I {",
         "  m(p) {}",
         "}",
         "class C implements I {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_method_fromSuperclass() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  m(p);",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int x(int a);",
         "}",
         "abstract class B {",
         "  int x(int a, [int b]);",
         "}",
         "class C implements A, B {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface() {
     Source source = addSource(EngineTestCase.createSource([
         "class I {",
         "  set s(int i) {}",
         "}",
         "class C implements I {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  set s(int i);",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  get a => 'a';",
         "}",
         "abstract class B implements A {",
         "  get b => 'b';",
         "}",
         "class C extends B {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberThree() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  m();",
         "  n();",
         "  o();",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberTwo() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  m();",
         "  n();",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
     verify([source]);
   }
   void test_nonTypeInCatchClause_noElement() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  try {", "  } on T catch (e) {", "  }", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE]);
+    assertErrors(source, [StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE]);
     verify([source]);
   }
   void test_nonTypeInCatchClause_notType() {
     Source source = addSource(EngineTestCase.createSource([
         "var T = 0;",
         "f() {",
         "  try {",
         "  } on T catch (e) {",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE]);
+    assertErrors(source, [StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE]);
     verify([source]);
   }
   void test_nonVoidReturnForOperator() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int operator []=(a, b) {}", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR]);
+    assertErrors(source, [StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR]);
     verify([source]);
   }
   void test_nonVoidReturnForSetter_function() {
     Source source = addSource(EngineTestCase.createSource(["int set x(int v) {", "  return 42;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_VOID_RETURN_FOR_SETTER]);
+    assertErrors(source, [StaticWarningCode.NON_VOID_RETURN_FOR_SETTER]);
     verify([source]);
   }
   void test_nonVoidReturnForSetter_method() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int set x(int v) {",
         "    return 42;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NON_VOID_RETURN_FOR_SETTER]);
+    assertErrors(source, [StaticWarningCode.NON_VOID_RETURN_FOR_SETTER]);
     verify([source]);
   }
   void test_notAType() {
     Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", "  f v = null;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NOT_A_TYPE]);
+    assertErrors(source, [StaticWarningCode.NOT_A_TYPE]);
     verify([source]);
   }
   void test_notEnoughRequiredArguments() {
     Source source = addSource(EngineTestCase.createSource(["f(int a, String b) {}", "main() {", "  f();", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
+    assertErrors(source, [StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
     verify([source]);
   }
   void test_partOfDifferentLibrary() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "part 'part.dart';"]));
     addSource2("/part.dart", EngineTestCase.createSource(["part of lub;"]));
     resolve(source);
-    assertErrors([StaticWarningCode.PART_OF_DIFFERENT_LIBRARY]);
+    assertErrors(source, [StaticWarningCode.PART_OF_DIFFERENT_LIBRARY]);
     verify([source]);
   }
   void test_redirectToInvalidFunctionType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A implements B {",
         "  A(int p) {}",
         "}",
         "class B {",
         "  factory B() = A;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE]);
+    assertErrors(source, [StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE]);
     verify([source]);
   }
   void test_redirectToInvalidReturnType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "class B {",
         "  factory B() = A;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE]);
+    assertErrors(source, [StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE]);
     verify([source]);
   }
   void test_redirectToMissingConstructor_named() {
     Source source = addSource(EngineTestCase.createSource([
         "class A implements B{",
         "  A() {}",
         "}",
         "class B {",
         "  factory B() = A.name;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
+    assertErrors(source, [StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
   }
   void test_redirectToMissingConstructor_unnamed() {
     Source source = addSource(EngineTestCase.createSource([
         "class A implements B{",
         "  A.name() {}",
         "}",
         "class B {",
         "  factory B() = A;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
+    assertErrors(source, [StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
   }
   void test_redirectToNonClass_notAType() {
     Source source = addSource(EngineTestCase.createSource(["class B {", "  int A;", "  factory B() = A;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.REDIRECT_TO_NON_CLASS]);
+    assertErrors(source, [StaticWarningCode.REDIRECT_TO_NON_CLASS]);
     verify([source]);
   }
   void test_redirectToNonClass_undefinedIdentifier() {
     Source source = addSource(EngineTestCase.createSource(["class B {", "  factory B() = A;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.REDIRECT_TO_NON_CLASS]);
+    assertErrors(source, [StaticWarningCode.REDIRECT_TO_NON_CLASS]);
     verify([source]);
   }
   void test_returnWithoutValue() {
     Source source = addSource(EngineTestCase.createSource(["int f() { return; }"]));
     resolve(source);
-    assertErrors([StaticWarningCode.RETURN_WITHOUT_VALUE]);
+    assertErrors(source, [StaticWarningCode.RETURN_WITHOUT_VALUE]);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_method_invocation() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "}", "main() {", "  A.m();", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
+    assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_method_reference() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "}", "main() {", "  A.m;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
+    assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_propertyAccess_field() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  var f;", "}", "main() {", "  A.f;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
+    assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_propertyAccess_getter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  get f => 42;",
         "}",
         "main() {",
         "  A.f;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
+    assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_propertyAccess_setter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  set f(x) {}",
         "}",
         "main() {",
         "  A.f = 42;",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
+    assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
     verify([source]);
   }
   void test_switchExpressionNotAssignable() {
     Source source = addSource(EngineTestCase.createSource([
         "f(int p) {",
         "  switch (p) {",
         "    case 'a': break;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE]);
+    assertErrors(source, [StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_typeParameterReferencedByStatic_field() {
     Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static K k;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
+    assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
   void test_typeParameterReferencedByStatic_getter() {
     Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static K get k => 0;", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
+    assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
   void test_typeParameterReferencedByStatic_methodBodyReference() {
     Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static m() {", "    K k;", "  }", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
+    assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
   void test_typeParameterReferencedByStatic_methodParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static m(K k) {}", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
+    assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
   void test_typeParameterReferencedByStatic_methodReturn() {
     Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static K m() {}", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
+    assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
   void test_typeParameterReferencedByStatic_setter() {
     Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static set s(K k) {}", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
+    assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
   void test_typeTestNonType() {
     Source source = addSource(EngineTestCase.createSource(["var A = 0;", "f(var p) {", "  if (p is A) {", "  }", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.TYPE_TEST_NON_TYPE]);
+    assertErrors(source, [StaticWarningCode.TYPE_TEST_NON_TYPE]);
     verify([source]);
   }
   void test_undefinedClass_instanceCreation() {
     Source source = addSource(EngineTestCase.createSource(["f() { new C(); }"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_CLASS]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
   }
   void test_undefinedClass_variableDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["f() { C c; }"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_CLASS]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
   }
   void test_undefinedClassBoolean_variableDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["f() { boolean v; }"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_CLASS_BOOLEAN]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS_BOOLEAN]);
   }
   void test_undefinedGetter_fromLibrary() {
     Source source1 = addSource2("lib.dart", "");
     Source source2 = addSource2("lib2.dart", EngineTestCase.createSource([
         "import 'lib.dart' as lib;",
         "void f() {",
         "  var g = lib.gg;",
         "}"]));
     resolve(source1);
     resolve(source2);
-    assertErrors([StaticWarningCode.UNDEFINED_GETTER]);
+    assertErrors(source2, [StaticWarningCode.UNDEFINED_GETTER]);
     verify([source1]);
   }
+  void test_undefinedIdentifier_for() {
+    Source source = addSource(EngineTestCase.createSource(["f(var l) {", "  for (e in l) {", "  }", "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
+  }
   void test_undefinedIdentifier_function() {
     Source source = addSource(EngineTestCase.createSource(["int a() => b;"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_function_prefix() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as b;", "", "int a() => b;", "b.C c;"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
     verify([source]);
   }
   void test_undefinedIdentifier_hideInBlock_function() {
     Source source = addSource(EngineTestCase.createSource([
         "var v = 1;",
         "main() {",
         "  print(v);",
         "  v() {}",
         "}",
         "print(x) {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_hideInBlock_local() {
     Source source = addSource(EngineTestCase.createSource([
         "var v = 1;",
         "main() {",
         "  print(v);",
         "  var v = 2;",
         "}",
         "print(x) {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_hideInBlock_subBlock() {
     Source source = addSource(EngineTestCase.createSource([
         "var v = 1;",
         "main() {",
         "  {",
         "    print(v);",
         "  }",
         "  var v = 2;",
         "}",
         "print(x) {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_initializer() {
     Source source = addSource(EngineTestCase.createSource(["var a = b;"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_initializer_prefix() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as b;", "", "var a = b;", "b.C c;"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_metadata() {
     Source source = addSource(EngineTestCase.createSource(["@undefined class A {}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_methodInvocation() {
     Source source = addSource(EngineTestCase.createSource(["f() { C.m(); }"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedNamedParameter() {
     Source source = addSource(EngineTestCase.createSource(["f({a, b}) {}", "main() {", "  f(c: 1);", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_NAMED_PARAMETER]);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_NAMED_PARAMETER]);
   }
   void test_undefinedSetter() {
     Source source1 = addSource2("lib.dart", "");
     Source source2 = addSource2("lib2.dart", EngineTestCase.createSource([
         "import 'lib.dart' as lib;",
         "void f() {",
         "  lib.gg = null;",
         "}"]));
     resolve(source1);
     resolve(source2);
-    assertErrors([StaticWarningCode.UNDEFINED_SETTER]);
+    assertErrors(source2, [StaticWarningCode.UNDEFINED_SETTER]);
   }
   static dartSuite() {
     _ut.group('StaticWarningCodeTest', () {
       _ut.test('test_ambiguousImport_as', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_as);
       });
       _ut.test('test_ambiguousImport_extends', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_extends);
@@ skipping 243 matching lines @@
         runJUnitTest(__test, __test.test_finalInitializedInDeclarationAndConstructor_initializers);
       });
       _ut.test('test_finalInitializedInDeclarationAndConstructor_initializingFormal', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_finalInitializedInDeclarationAndConstructor_initializingFormal);
       });
       _ut.test('test_finalNotInitialized_inConstructor', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_finalNotInitialized_inConstructor);
       });
-      _ut.test('test_finalNotInitialized_instanceField_const_static', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_finalNotInitialized_instanceField_const_static);
-      });
       _ut.test('test_finalNotInitialized_instanceField_final', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_finalNotInitialized_instanceField_final);
       });
       _ut.test('test_finalNotInitialized_instanceField_final_static', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_finalNotInitialized_instanceField_final_static);
       });
-      _ut.test('test_finalNotInitialized_library_const', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_finalNotInitialized_library_const);
-      });
       _ut.test('test_finalNotInitialized_library_final', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_finalNotInitialized_library_final);
       });
-      _ut.test('test_finalNotInitialized_local_const', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_finalNotInitialized_local_const);
-      });
       _ut.test('test_finalNotInitialized_local_final', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_finalNotInitialized_local_final);
       });
       _ut.test('test_importDuplicatedLibraryName', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_importDuplicatedLibraryName);
       });
       _ut.test('test_inconsistentMethodInheritanceGetterAndMethod', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 324 matching lines @@
         runJUnitTest(__test, __test.test_undefinedClass_instanceCreation);
       });
       _ut.test('test_undefinedClass_variableDeclaration', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedClass_variableDeclaration);
       });
       _ut.test('test_undefinedGetter_fromLibrary', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedGetter_fromLibrary);
       });
+      _ut.test('test_undefinedIdentifier_for', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_undefinedIdentifier_for);
+      });
       _ut.test('test_undefinedIdentifier_function', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_function);
       });
       _ut.test('test_undefinedIdentifier_function_prefix', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_function_prefix);
       });
       _ut.test('test_undefinedIdentifier_hideInBlock_function', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 41 matching lines @@
         "  void m(int i) {",
         "    switch (i) {",
         "      l: case 0:",
         "        break;",
         "      case 1:",
         "        break l;",
         "    }",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER]);
+    assertErrors(source, [ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER]);
     verify([source]);
   }
   void test_continueLabelOnSwitch() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void m(int i) {",
         "    l: switch (i) {",
         "      case 0:",
         "        continue l;",
         "    }",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors([ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH]);
+    assertErrors(source, [ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH]);
     verify([source]);
   }
   static dartSuite() {
     _ut.group('ErrorResolverTest', () {
       _ut.test('test_breakLabelOnSwitchMember', () {
         final __test = new ErrorResolverTest();
         runJUnitTest(__test, __test.test_breakLabelOnSwitchMember);
       });
       _ut.test('test_continueLabelOnSwitch', () {
         final __test = new ErrorResolverTest();
@@ skipping 125 matching lines @@
   InterfaceType get intType {
     if (_intType == null) {
       initializeNumericTypes();
     }
     return _intType;
   }
   InterfaceType get iterableType {
     if (_iterableType == null) {
       ClassElementImpl iterableElement = ElementFactory.classElement2("Iterable", ["E"]);
       _iterableType = iterableElement.type;
-      Type2 eType = iterableElement.typeVariables[0].type;
+      Type2 eType = iterableElement.typeParameters[0].type;
       iterableElement.accessors = <PropertyAccessorElement> [
           ElementFactory.getterElement("iterator", false, iteratorType.substitute4(<Type2> [eType])),
           ElementFactory.getterElement("last", false, eType)];
       propagateTypeArguments(iterableElement);
     }
     return _iterableType;
   }
   InterfaceType get iteratorType {
     if (_iteratorType == null) {
       ClassElementImpl iteratorElement = ElementFactory.classElement2("Iterator", ["E"]);
       _iteratorType = iteratorElement.type;
-      Type2 eType = iteratorElement.typeVariables[0].type;
+      Type2 eType = iteratorElement.typeParameters[0].type;
       iteratorElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("current", false, eType)];
       propagateTypeArguments(iteratorElement);
     }
     return _iteratorType;
   }
   InterfaceType get listType {
     if (_listType == null) {
       ClassElementImpl listElement = ElementFactory.classElement2("List", ["E"]);
       listElement.constructors = <ConstructorElement> [ElementFactory.constructorElement(listElement, null)];
       _listType = listElement.type;
-      Type2 eType = listElement.typeVariables[0].type;
+      Type2 eType = listElement.typeParameters[0].type;
       InterfaceType iterableType = this.iterableType.substitute4(<Type2> [eType]);
       listElement.interfaces = <InterfaceType> [iterableType];
       listElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("length", false, intType)];
       listElement.methods = <MethodElement> [
           ElementFactory.methodElement("[]", eType, [intType]),
           ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [intType, eType]),
           ElementFactory.methodElement("add", VoidTypeImpl.instance, [eType])];
       propagateTypeArguments(listElement);
     }
     return _listType;
@@ skipping 152 matching lines @@
         ElementFactory.methodElement("toString", _stringType, [])];
   }
 
   /**
    * Given a class element representing a class with type parameters, propagate those type
    * parameters to all of the accessors, methods and constructors defined for the class.
    *
    * @param classElement the element representing the class with type parameters
    */
   void propagateTypeArguments(ClassElementImpl classElement) {
-    List<Type2> typeArguments = TypeVariableTypeImpl.getTypes(classElement.typeVariables);
+    List<Type2> typeArguments = TypeParameterTypeImpl.getTypes(classElement.typeParameters);
     for (PropertyAccessorElement accessor in classElement.accessors) {
       FunctionTypeImpl functionType = accessor.type as FunctionTypeImpl;
       functionType.typeArguments = typeArguments;
     }
     for (MethodElement method in classElement.methods) {
       FunctionTypeImpl functionType = method.type as FunctionTypeImpl;
       functionType.typeArguments = typeArguments;
     }
     for (ConstructorElement constructor in classElement.constructors) {
       FunctionTypeImpl functionType = constructor.type as FunctionTypeImpl;
       functionType.typeArguments = typeArguments;
     }
   }
 }
 /**
  * The class `AnalysisContextFactory` defines utility methods used to create analysis contexts
  * for testing purposes.
  */
 class AnalysisContextFactory {
 
   /**
    * Create an analysis context that has a fake core library already resolved.
    *
-   * Added in order to test AnalysisContextImpl2.
-   *
-   * @return the analysis context that was created
-   */
-  static AnalysisContextImpl2 context2WithCore() {
-    AnalysisContextImpl2 sdkContext = DirectoryBasedDartSdk.defaultSdk2.context as AnalysisContextImpl2;
-    SourceFactory sourceFactory = sdkContext.sourceFactory;
-    TestTypeProvider provider = new TestTypeProvider();
-    CompilationUnitElementImpl coreUnit = new CompilationUnitElementImpl("core.dart");
-    Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
-    sdkContext.setContents(coreSource, "");
-    coreUnit.source = coreSource;
-    coreUnit.types = <ClassElement> [
-        provider.boolType.element,
-        provider.doubleType.element,
-        provider.functionType.element,
-        provider.intType.element,
-        provider.listType.element,
-        provider.mapType.element,
-        provider.nullType.element,
-        provider.numType.element,
-        provider.objectType.element,
-        provider.stackTraceType.element,
-        provider.stringType.element,
-        provider.typeType.element];
-    LibraryElementImpl coreLibrary = new LibraryElementImpl(sdkContext, ASTFactory.libraryIdentifier2(["dart", "core"]));
-    coreLibrary.definingCompilationUnit = coreUnit;
-    CompilationUnitElementImpl htmlUnit = new CompilationUnitElementImpl("html_dartium.dart");
-    Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
-    sdkContext.setContents(htmlSource, "");
-    htmlUnit.source = htmlSource;
-    ClassElementImpl elementElement = ElementFactory.classElement2("Element", []);
-    InterfaceType elementType = elementElement.type;
-    ClassElementImpl documentElement = ElementFactory.classElement("Document", elementType, []);
-    ClassElementImpl htmlDocumentElement = ElementFactory.classElement("HtmlDocument", documentElement.type, []);
-    htmlDocumentElement.methods = <MethodElement> [ElementFactory.methodElement("query", elementType, <Type2> [provider.stringType])];
-    htmlUnit.types = <ClassElement> [
-        ElementFactory.classElement("AnchorElement", elementType, []),
-        ElementFactory.classElement("BodyElement", elementType, []),
-        ElementFactory.classElement("ButtonElement", elementType, []),
-        ElementFactory.classElement("DivElement", elementType, []),
-        documentElement,
-        elementElement,
-        htmlDocumentElement,
-        ElementFactory.classElement("InputElement", elementType, []),
-        ElementFactory.classElement("SelectElement", elementType, [])];
-    htmlUnit.functions = <FunctionElement> [ElementFactory.functionElement3("query", elementElement, <ClassElement> [provider.stringType.element], ClassElementImpl.EMPTY_ARRAY)];
-    TopLevelVariableElementImpl document = ElementFactory.topLevelVariableElement3("document", true, htmlDocumentElement.type);
-    htmlUnit.topLevelVariables = <TopLevelVariableElement> [document];
-    htmlUnit.accessors = <PropertyAccessorElement> [document.getter];
-    LibraryElementImpl htmlLibrary = new LibraryElementImpl(sdkContext, ASTFactory.libraryIdentifier2(["dart", "dom", "html"]));
-    htmlLibrary.definingCompilationUnit = htmlUnit;
-    Map<Source, LibraryElement> elementMap = new Map<Source, LibraryElement>();
-    elementMap[coreSource] = coreLibrary;
-    elementMap[htmlSource] = htmlLibrary;
-    sdkContext.recordLibraryElements(elementMap);
-    AnalysisContextImpl2 context = new DelegatingAnalysisContextImpl2();
-    sourceFactory = new SourceFactory.con2([
-        new DartUriResolver(sdkContext.sourceFactory.dartSdk),
-        new FileUriResolver()]);
-    context.sourceFactory = sourceFactory;
-    return context;
-  }
-
-  /**
-   * Create an analysis context that has a fake core library already resolved.
-   *
    * @return the analysis context that was created
    */
   static AnalysisContextImpl contextWithCore() {
-    AnalysisContextImpl sdkContext = DirectoryBasedDartSdk.defaultSdk.context as AnalysisContextImpl;
+    AnalysisContext sdkContext = DirectoryBasedDartSdk.defaultSdk.context;
     SourceFactory sourceFactory = sdkContext.sourceFactory;
     TestTypeProvider provider = new TestTypeProvider();
     CompilationUnitElementImpl coreUnit = new CompilationUnitElementImpl("core.dart");
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     sdkContext.setContents(coreSource, "");
     coreUnit.source = coreSource;
     coreUnit.types = <ClassElement> [
         provider.boolType.element,
         provider.doubleType.element,
         provider.functionType.element,
@@ skipping 29 matching lines @@
         ElementFactory.classElement("SelectElement", elementType, [])];
     htmlUnit.functions = <FunctionElement> [ElementFactory.functionElement3("query", elementElement, <ClassElement> [provider.stringType.element], ClassElementImpl.EMPTY_ARRAY)];
     TopLevelVariableElementImpl document = ElementFactory.topLevelVariableElement3("document", true, htmlDocumentElement.type);
     htmlUnit.topLevelVariables = <TopLevelVariableElement> [document];
     htmlUnit.accessors = <PropertyAccessorElement> [document.getter];
     LibraryElementImpl htmlLibrary = new LibraryElementImpl(sdkContext, ASTFactory.libraryIdentifier2(["dart", "dom", "html"]));
     htmlLibrary.definingCompilationUnit = htmlUnit;
     Map<Source, LibraryElement> elementMap = new Map<Source, LibraryElement>();
     elementMap[coreSource] = coreLibrary;
     elementMap[htmlSource] = htmlLibrary;
-    sdkContext.recordLibraryElements(elementMap);
+    ((sdkContext as AnalysisContextImpl)).recordLibraryElements(elementMap);
     AnalysisContextImpl context = new DelegatingAnalysisContextImpl();
     sourceFactory = new SourceFactory.con2([
         new DartUriResolver(sdkContext.sourceFactory.dartSdk),
         new FileUriResolver()]);
     context.sourceFactory = sourceFactory;
     return context;
   }
 }
 class LibraryImportScopeTest extends ResolverTestCase {
   void test_conflictingImports() {
@@ skipping 17 matching lines @@
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       JUnitTestCase.assertEquals(typeA, scope.lookup(ASTFactory.identifier3(typeNameA), importingLibrary));
       errorListener.assertNoErrors();
       JUnitTestCase.assertEquals(typeC, scope.lookup(ASTFactory.identifier3(typeNameC), importingLibrary));
       errorListener.assertNoErrors();
       Element element = scope.lookup(ASTFactory.identifier3(typeNameB), importingLibrary);
       errorListener.assertErrors2([StaticWarningCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf(MultiplyDefinedElement, element);
       List<Element> conflictingElements = ((element as MultiplyDefinedElement)).conflictingElements;
-      JUnitTestCase.assertEquals(typeB1, conflictingElements[0]);
-      JUnitTestCase.assertEquals(typeB2, conflictingElements[1]);
-      JUnitTestCase.assertEquals(2, conflictingElements.length);
+      EngineTestCase.assertLength(2, conflictingElements);
+      if (identical(conflictingElements[0], typeB1)) {
+        JUnitTestCase.assertSame(typeB2, conflictingElements[1]);
+      } else if (identical(conflictingElements[0], typeB2)) {
+        JUnitTestCase.assertSame(typeB1, conflictingElements[1]);
+      } else {
+        JUnitTestCase.assertSame(typeB1, conflictingElements[0]);
+      }
     }
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       Identifier identifier = ASTFactory.identifier3(typeNameB);
       ASTFactory.methodDeclaration(null, ASTFactory.typeName3(identifier, []), null, null, ASTFactory.identifier3("foo"), null);
       Element element = scope.lookup(identifier, importingLibrary);
       errorListener.assertErrors2([StaticWarningCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf(MultiplyDefinedElement, element);
     }
@@ skipping 22 matching lines @@
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryImportScope scope = new LibraryImportScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary);
   }
   void test_getErrorListener() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryImportScope scope = new LibraryImportScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(errorListener, scope.errorListener);
   }
+  void test_nonConflictingImports_fromSdk() {
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
+    String typeName = "List";
+    ClassElement type = ElementFactory.classElement2(typeName, []);
+    LibraryElement importedLibrary = createTestLibrary2(context, "lib", []);
+    ((importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [type];
+    ImportElementImpl importCore = ElementFactory.importFor(context.getLibraryElement(context.sourceFactory.forUri("dart:core")), null, []);
+    ImportElementImpl importLib = ElementFactory.importFor(importedLibrary, null, []);
+    LibraryElementImpl importingLibrary = createTestLibrary2(context, "importing", []);
+    importingLibrary.imports = <ImportElement> [importCore, importLib];
+    GatheringErrorListener errorListener = new GatheringErrorListener();
+    Scope scope = new LibraryImportScope(importingLibrary, errorListener);
+    JUnitTestCase.assertEquals(type, scope.lookup(ASTFactory.identifier3(typeName), importingLibrary));
+    errorListener.assertNoErrors();
+  }
+  void test_nonConflictingImports_sameElement() {
+    AnalysisContext context = new AnalysisContextImpl();
+    String typeNameA = "A";
+    String typeNameB = "B";
+    ClassElement typeA = ElementFactory.classElement2(typeNameA, []);
+    ClassElement typeB = ElementFactory.classElement2(typeNameB, []);
+    LibraryElement importedLibrary = createTestLibrary2(context, "imported", []);
+    ((importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [typeA, typeB];
+    ImportElementImpl import1 = ElementFactory.importFor(importedLibrary, null, []);
+    ImportElementImpl import2 = ElementFactory.importFor(importedLibrary, null, []);
+    LibraryElementImpl importingLibrary = createTestLibrary2(context, "importing", []);
+    importingLibrary.imports = <ImportElement> [import1, import2];
+    GatheringErrorListener errorListener = new GatheringErrorListener();
+    Scope scope = new LibraryImportScope(importingLibrary, errorListener);
+    JUnitTestCase.assertEquals(typeA, scope.lookup(ASTFactory.identifier3(typeNameA), importingLibrary));
+    errorListener.assertNoErrors();
+    JUnitTestCase.assertEquals(typeB, scope.lookup(ASTFactory.identifier3(typeNameB), importingLibrary));
+    errorListener.assertNoErrors();
+  }
   void test_prefixedAndNonPrefixed() {
     AnalysisContext context = new AnalysisContextImpl();
     String typeName = "C";
     String prefixName = "p";
     ClassElement prefixedType = ElementFactory.classElement2(typeName, []);
     ClassElement nonPrefixedType = ElementFactory.classElement2(typeName, []);
     LibraryElement prefixedLibrary = createTestLibrary2(context, "import.prefixed", []);
     ((prefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [prefixedType];
     ImportElementImpl prefixedImport = ElementFactory.importFor(prefixedLibrary, ElementFactory.prefix(prefixName), []);
     LibraryElement nonPrefixedLibrary = createTestLibrary2(context, "import.nonPrefixed", []);
@@ skipping 25 matching lines @@
         runJUnitTest(__test, __test.test_creation_nonEmpty);
       });
       _ut.test('test_getDefiningLibrary', () {
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_getDefiningLibrary);
       });
       _ut.test('test_getErrorListener', () {
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_getErrorListener);
       });
+      _ut.test('test_nonConflictingImports_fromSdk', () {
+        final __test = new LibraryImportScopeTest();
+        runJUnitTest(__test, __test.test_nonConflictingImports_fromSdk);
+      });
+      _ut.test('test_nonConflictingImports_sameElement', () {
+        final __test = new LibraryImportScopeTest();
+        runJUnitTest(__test, __test.test_nonConflictingImports_sameElement);
+      });
       _ut.test('test_prefixedAndNonPrefixed', () {
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_prefixedAndNonPrefixed);
       });
     });
   }
 }
 /**
  * Instances of the class `ResolutionVerifier` verify that all of the nodes in an AST
  * structure that should have been resolved were resolved.
@@ skipping 409 matching lines @@
     Expression node = ASTFactory.doubleLiteral(4.33);
     JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_named_block() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p1"), resolvedInteger(0));
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
-    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
+    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
     expectedNamedTypes["p1"] = dynamicType;
     expectedNamedTypes["p2"] = dynamicType;
     assertFunctionType(dynamicType, null, null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_named_expression() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p"), resolvedInteger(0));
     setType(p, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
     expectedNamedTypes["p"] = dynamicType;
     assertFunctionType(_typeProvider.intType, null, null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normal_block() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.simpleFormalParameter3("p2");
     setType(p2, dynamicType);
-    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
+    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     assertFunctionType(dynamicType, <Type2> [dynamicType, dynamicType], null, null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normal_expression() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.simpleFormalParameter3("p");
     setType(p, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p);
     Type2 resultType = analyze(node);
     assertFunctionType(_typeProvider.intType, <Type2> [dynamicType], null, null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normalAndNamed_block() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
-    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
+    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p2);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
     expectedNamedTypes["p2"] = dynamicType;
     assertFunctionType(dynamicType, <Type2> [dynamicType], null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normalAndNamed_expression() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p2);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
     expectedNamedTypes["p2"] = dynamicType;
     assertFunctionType(_typeProvider.intType, <Type2> [dynamicType], null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normalAndPositional_block() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
-    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
+    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     assertFunctionType(dynamicType, <Type2> [dynamicType], <Type2> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normalAndPositional_expression() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     assertFunctionType(_typeProvider.intType, <Type2> [dynamicType], <Type2> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_positional_block() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p1"), resolvedInteger(0));
     setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
     setType(p2, dynamicType);
-    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
+    FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody2([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     assertFunctionType(dynamicType, null, <Type2> [dynamicType, dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_positional_expression() {
     Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p"), resolvedInteger(0));
     setType(p, dynamicType);
@@ skipping 51 matching lines @@
   }
   void test_visitInstanceCreationExpression_named() {
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     String constructorName = "m";
     ConstructorElementImpl constructor = ElementFactory.constructorElement(classElement, constructorName);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, ASTFactory.typeName(classElement, []), [ASTFactory.identifier3(constructorName)]);
-    node.element = constructor;
+    node.staticElement = constructor;
     JUnitTestCase.assertSame(classElement.type, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_typeParameters() {
     ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]);
     ClassElementImpl elementI = ElementFactory.classElement2("I", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement(elementC, null);
     elementC.constructors = <ConstructorElement> [constructor];
     constructor.returnType = elementC.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     TypeName typeName = ASTFactory.typeName(elementC, [ASTFactory.typeName(elementI, [])]);
     typeName.type = elementC.type.substitute4(<Type2> [elementI.type]);
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, typeName, []);
-    node.element = constructor;
+    node.staticElement = constructor;
     InterfaceType interfaceType = analyze(node) as InterfaceType;
     List<Type2> typeArgs = interfaceType.typeArguments;
     JUnitTestCase.assertEquals(1, typeArgs.length);
     JUnitTestCase.assertEquals(elementI.type, typeArgs[0]);
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_unnamed() {
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement(classElement, null);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, ASTFactory.typeName(classElement, []), []);
-    node.element = constructor;
+    node.staticElement = constructor;
     JUnitTestCase.assertSame(classElement.type, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitIntegerLiteral() {
     Expression node = resolvedInteger(42);
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitIsExpression_negated() {
     Expression node = ASTFactory.isExpression(resolvedString("a"), true, ASTFactory.typeName4("String", []));
@@ skipping 669 matching lines @@
         runJUnitTest(__test, __test.test_visitThrowExpression_withValue);
       });
       _ut.test('test_visitThrowExpression_withoutValue', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitThrowExpression_withoutValue);
       });
     });
   }
 }
 class NonHintCodeTest extends ResolverTestCase {
+  void test_deadCode_deadBlock_conditionalElse_debugConst() {
+    Source source = addSource(EngineTestCase.createSource([
+        "const bool DEBUG = true;",
+        "f() {",
+        "  DEBUG ? 1 : 2;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_conditionalIf_debugConst() {
+    Source source = addSource(EngineTestCase.createSource([
+        "const bool DEBUG = false;",
+        "f() {",
+        "  DEBUG ? 1 : 2;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_else() {
+    Source source = addSource(EngineTestCase.createSource([
+        "const bool DEBUG = true;",
+        "f() {",
+        "  if(DEBUG) {} else {}",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_if_debugConst_prefixedIdentifier() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static const bool DEBUG = false;",
+        "}",
+        "f() {",
+        "  if(A.DEBUG) {}",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_if_debugConst_prefixedIdentifier2() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib2.dart';",
+        "f() {",
+        "  if(A.DEBUG) {}",
+        "}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource([
+        "library lib2;",
+        "class A {",
+        "  static const bool DEBUG = false;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_if_debugConst_propertyAccessor() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib2.dart' as LIB;",
+        "f() {",
+        "  if(LIB.A.DEBUG) {}",
+        "}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource([
+        "library lib2;",
+        "class A {",
+        "  static const bool DEBUG = false;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_if_debugConst_simpleIdentifier() {
+    Source source = addSource(EngineTestCase.createSource([
+        "const bool DEBUG = false;",
+        "f() {",
+        "  if(DEBUG) {}",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_while_debugConst() {
+    Source source = addSource(EngineTestCase.createSource([
+        "const bool DEBUG = false;",
+        "f() {",
+        "  while(DEBUG) {}",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_deadCode_deadCatch_onCatchSubtype() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "f() {",
         "  try {} on B catch (e) {} on A catch (e) {} catch (e) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_deadCode_deadOperandLHS_and_debugConst() {
+    Source source = addSource(EngineTestCase.createSource([
+        "const bool DEBUG = false;",
+        "f() {",
+        "  bool b = DEBUG && false;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_deadCode_deadOperandLHS_or_debugConst() {
+    Source source = addSource(EngineTestCase.createSource([
+        "const bool DEBUG = true;",
+        "f() {",
+        "  bool b = DEBUG || true;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_divisionOptimization() {
+    Source source = addSource(EngineTestCase.createSource(["f(int x, int y) {", "  var v = x / y.toInt();", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_divisionOptimization_supressIfDivisionNotDefinedInCore() {
+    Source source = addSource(EngineTestCase.createSource(["f(x, y) {", "  var v = (x / y).toInt();", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_divisionOptimization_supressIfDivisionOverridden() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  num operator /(x) {}",
+        "}",
+        "f(A x, A y) {",
+        "  var v = (x / y).toInt();",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_duplicateImport_as() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib1.dart';",
+        "import 'lib1.dart' as one;",
+        "A a;",
+        "one.A a2;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_duplicateImport_hide() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib1.dart';",
+        "import 'lib1.dart' hide A;",
+        "A a;",
+        "B b;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_duplicateImport_show() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib1.dart';",
+        "import 'lib1.dart' show A;",
+        "A a;",
+        "B b;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_overriddingPrivateMember_sameLibrary() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  _m(int x) => 0;",
+        "}",
+        "class B extends A {",
+        "  _m(int x) => 0;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_overrideEqualsButNotHashCode() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  bool operator ==(x) {}",
+        "  get hashCode => 0;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_unnecessaryCast_dynamic_type() {
+    Source source = addSource(EngineTestCase.createSource(["m(v) {", "  var b = v as Object;", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_unnecessaryCast_type_dynamic() {
+    Source source = addSource(EngineTestCase.createSource(["m(v) {", "  var b = Object as dynamic;", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_unusedImport_core_library() {
+    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'dart:core';"]));
+    resolve(source);
+    assertNoErrors(source);
     verify([source]);
   }
   void test_unusedImport_export() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "Two two;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "export 'lib2.dart';", "class One {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class Two {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_unusedImport_export_infiniteLoop() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "Two two;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "export 'lib2.dart';", "class One {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "export 'lib3.dart';", "class Two {}"]));
     addSource2("/lib3.dart", EngineTestCase.createSource(["library lib3;", "export 'lib2.dart';", "class Three {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_unusedImport_export2() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "Three three;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "export 'lib2.dart';", "class One {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "export 'lib3.dart';", "class Two {}"]));
     addSource2("/lib3.dart", EngineTestCase.createSource(["library lib3;", "class Three {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_unusedImport_prefix_topLevelFunction() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'lib1.dart' hide topLevelFunction;",
         "import 'lib1.dart' as one show topLevelFunction;",
         "class A {",
         "  static void x() {",
         "    One o;",
         "    one.topLevelFunction();",
         "  }",
         "}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class One {}", "topLevelFunction() {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   static dartSuite() {
     _ut.group('NonHintCodeTest', () {
+      _ut.test('test_deadCode_deadBlock_conditionalElse_debugConst', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalElse_debugConst);
+      });
+      _ut.test('test_deadCode_deadBlock_conditionalIf_debugConst', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalIf_debugConst);
+      });
+      _ut.test('test_deadCode_deadBlock_else', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_else);
+      });
+      _ut.test('test_deadCode_deadBlock_if_debugConst_prefixedIdentifier', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_if_debugConst_prefixedIdentifier);
+      });
+      _ut.test('test_deadCode_deadBlock_if_debugConst_prefixedIdentifier2', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_if_debugConst_prefixedIdentifier2);
+      });
+      _ut.test('test_deadCode_deadBlock_if_debugConst_propertyAccessor', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_if_debugConst_propertyAccessor);
+      });
+      _ut.test('test_deadCode_deadBlock_if_debugConst_simpleIdentifier', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_if_debugConst_simpleIdentifier);
+      });
+      _ut.test('test_deadCode_deadBlock_while_debugConst', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_while_debugConst);
+      });
       _ut.test('test_deadCode_deadCatch_onCatchSubtype', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_deadCatch_onCatchSubtype);
       });
+      _ut.test('test_deadCode_deadOperandLHS_and_debugConst', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadOperandLHS_and_debugConst);
+      });
+      _ut.test('test_deadCode_deadOperandLHS_or_debugConst', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadOperandLHS_or_debugConst);
+      });
+      _ut.test('test_divisionOptimization', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_divisionOptimization);
+      });
+      _ut.test('test_divisionOptimization_supressIfDivisionNotDefinedInCore', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_divisionOptimization_supressIfDivisionNotDefinedInCore);
+      });
+      _ut.test('test_divisionOptimization_supressIfDivisionOverridden', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_divisionOptimization_supressIfDivisionOverridden);
+      });
+      _ut.test('test_duplicateImport_as', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_duplicateImport_as);
+      });
+      _ut.test('test_duplicateImport_hide', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_duplicateImport_hide);
+      });
+      _ut.test('test_duplicateImport_show', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_duplicateImport_show);
+      });
+      _ut.test('test_overriddingPrivateMember_sameLibrary', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_overriddingPrivateMember_sameLibrary);
+      });
+      _ut.test('test_overrideEqualsButNotHashCode', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_overrideEqualsButNotHashCode);
+      });
+      _ut.test('test_unnecessaryCast_dynamic_type', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryCast_dynamic_type);
+      });
+      _ut.test('test_unnecessaryCast_type_dynamic', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_unnecessaryCast_type_dynamic);
+      });
+      _ut.test('test_unusedImport_core_library', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_unusedImport_core_library);
+      });
       _ut.test('test_unusedImport_export', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_unusedImport_export);
       });
       _ut.test('test_unusedImport_export2', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_unusedImport_export2);
       });
       _ut.test('test_unusedImport_export_infiniteLoop', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_unusedImport_export_infiniteLoop);
       });
       _ut.test('test_unusedImport_prefix_topLevelFunction', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_unusedImport_prefix_topLevelFunction);
       });
     });
   }
 }
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     LibraryElement definingLibrary2 = createTestLibrary();
     GatheringErrorListener errorListener2 = new GatheringErrorListener();
-    Scope rootScope = new Scope_23(definingLibrary2, errorListener2);
+    Scope rootScope = new Scope_20(definingLibrary2, errorListener2);
     EnclosedScope scope = new EnclosedScope(rootScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
     errorListener2.assertErrors3([ErrorSeverity.ERROR]);
   }
   void test_define_normal() {
     LibraryElement definingLibrary3 = createTestLibrary();
     GatheringErrorListener errorListener3 = new GatheringErrorListener();
-    Scope rootScope = new Scope_24(definingLibrary3, errorListener3);
+    Scope rootScope = new Scope_21(definingLibrary3, errorListener3);
     EnclosedScope outerScope = new EnclosedScope(rootScope);
     EnclosedScope innerScope = new EnclosedScope(outerScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v2"));
     outerScope.define(element1);
     innerScope.define(element2);
     errorListener3.assertNoErrors();
   }
   static dartSuite() {
     _ut.group('EnclosedScopeTest', () {
       _ut.test('test_define_duplicate', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_duplicate);
       });
       _ut.test('test_define_normal', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_normal);
       });
     });
   }
 }
-class Scope_23 extends Scope {
+class Scope_20 extends Scope {
   LibraryElement definingLibrary2;
   GatheringErrorListener errorListener2;
-  Scope_23(this.definingLibrary2, this.errorListener2) : super();
+  Scope_20(this.definingLibrary2, this.errorListener2) : super();
   LibraryElement get definingLibrary => definingLibrary2;
   AnalysisErrorListener get errorListener => errorListener2;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
-class Scope_24 extends Scope {
+class Scope_21 extends Scope {
   LibraryElement definingLibrary3;
   GatheringErrorListener errorListener3;
-  Scope_24(this.definingLibrary3, this.errorListener3) : super();
+  Scope_21(this.definingLibrary3, this.errorListener3) : super();
   LibraryElement get definingLibrary => definingLibrary3;
   AnalysisErrorListener get errorListener => errorListener3;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 class LibraryElementBuilderTest extends EngineTestCase {
 
   /**
    * The source factory used to create [Source].
    */
   SourceFactory _sourceFactory;
@@ skipping 272 matching lines @@
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int get g => (a,b) => 0;",
         "}",
         "class B {",
         "  f() {",
         "    A.g(1,0);",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_argumentResolution_required_matching() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void f() {",
         "    g(1, 2, 3);",
         "  }",
         "  void g(a, b, c) {}",
         "}"]));
@@ skipping 81 matching lines @@
   }
   void test_class_definesCall() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int call(int x) { return x; }",
         "}",
         "int f(A a) {",
         "  return a(0);",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_class_extends_implements() {
     Source source = addSource(EngineTestCase.createSource([
         "class A extends B implements C {}",
         "class B {}",
         "class C {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_commentReference_class() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {}",
         "/** [A] [new A] [A.n] [new A.n] [m] [f] */",
         "class A {",
         "  A() {}",
         "  A.n() {}",
         "  m() {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_commentReference_parameter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "  A.n() {}",
         "  /** [e] [f] */",
         "  m(e, f()) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_commentReference_singleLine() {
     Source source = addSource(EngineTestCase.createSource(["/// [A]", "class A {}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_empty() {
     Source source = addSource("");
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_extractedMethodAsConstant() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class Comparable<T> {",
         "  int compareTo(T other);",
         "  static int compare(Comparable a, Comparable b) => a.compareTo(b);",
         "}",
         "class A {",
         "  void sort([compare = Comparable.compare]) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_fieldFormalParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) {}", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_forEachLoops_nonConflicting() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  List list = [1,2,3];",
         "  for (int x in list) {}",
         "  for (int x in list) {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_forLoops_nonConflicting() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  for (int i = 0; i < 3; i++) {",
         "  }",
         "  for (int i = 0; i < 3; i++) {",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_functionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "typedef bool P(e);",
         "class A {",
         "  P p;",
         "  m(e) {",
         "    if (p(e)) {}",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_getterAndSetterWithDifferentTypes() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get f => 0;",
         "  void set f(String s) {}",
         "}",
         "g (A a) {",
         "  a.f = a.f.toString();",
         "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
+    assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
   void test_hasReferenceToSuper() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {toString() => super.toString();}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(2, classes);
     JUnitTestCase.assertFalse(classes[0].hasReferenceToSuper());
     JUnitTestCase.assertTrue(classes[1].hasReferenceToSuper());
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_import_hide() {
     addSource2("lib1.dart", EngineTestCase.createSource(["library lib1;", "set foo(value) {}", "class A {}"]));
     addSource2("lib2.dart", EngineTestCase.createSource(["library lib2;", "set foo(value) {}"]));
     Source source = addSource2("lib3.dart", EngineTestCase.createSource([
         "import 'lib1.dart' hide foo;",
         "import 'lib2.dart';",
         "",
         "main() {",
         "  foo = 0;",
         "}",
         "A a;"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_import_prefix() {
     addSource2("/two.dart", EngineTestCase.createSource(["library two;", "f(int x) {", "  return x * x;", "}"]));
     Source source = addSource2("/one.dart", EngineTestCase.createSource([
         "library one;",
         "import 'two.dart' as _two;",
         "main() {",
         "  _two.f(0);",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_import_spaceInUri() {
     addSource2("sub folder/lib.dart", EngineTestCase.createSource(["library lib;", "foo() {}"]));
     Source source = addSource2("app.dart", EngineTestCase.createSource([
         "import 'sub folder/lib.dart';",
         "",
         "main() {",
         "  foo();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_indexExpression_typeParameters() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  List<int> a;",
         "  a[0];",
         "  List<List<int>> b;",
         "  b[0][0];",
         "  List<List<List<int>>> c;",
         "  c[0][0][0];",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_indexExpression_typeParameters_invalidAssignmentWarning() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  List<List<int>> b;", "  b[0][0] = 'hi';", "}"]));
     resolve(source);
-    assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_indirectOperatorThroughCall() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  B call() { return new B(); }",
         "}",
         "",
         "class B {",
         "  int operator [](int i) { return i; }",
         "}",
         "",
         "A f = new A();",
         "",
         "g(int x) {}",
         "",
         "main() {",
         "  g(f()[0]);",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_invoke_dynamicThroughGetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  List get X => [() => 0];",
         "  m(A a) {",
         "    X.last;",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_isValidMixin_badSuperclass() {
     Source source = addSource(EngineTestCase.createSource(["class A extends B {}", "class B {}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(2, classes);
     JUnitTestCase.assertFalse(classes[0].isValidMixin);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_isValidMixin_constructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     JUnitTestCase.assertFalse(classes[0].isValidMixin);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_isValidMixin_super() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  toString() {",
         "    return super.toString();",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     JUnitTestCase.assertFalse(classes[0].isValidMixin);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_isValidMixin_valid() {
     Source source = addSource(EngineTestCase.createSource(["class A {}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     JUnitTestCase.assertTrue(classes[0].isValidMixin);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_labels_switch() {
     Source source = addSource(EngineTestCase.createSource([
         "void doSwitch(int target) {",
         "  switch (target) {",
         "    l0: case 0:",
         "      continue l1;",
         "    l1: case 1:",
         "      continue l0;",
         "    default:",
         "      continue l1;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_metadata_class() {
     Source source = addSource(EngineTestCase.createSource(["const A = null;", "@A class C {}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     List<ElementAnnotation> annotations = classes[0].metadata;
     EngineTestCase.assertLength(1, annotations);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_metadata_field() {
     Source source = addSource(EngineTestCase.createSource(["const A = null;", "class C {", "  @A int f;", "}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     FieldElement field = classes[0].fields[0];
     List<ElementAnnotation> annotations = field.metadata;
     EngineTestCase.assertLength(1, annotations);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_metadata_libraryDirective() {
     Source source = addSource(EngineTestCase.createSource(["@A library lib;", "const A = null;"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     List<ElementAnnotation> annotations = library.metadata;
     EngineTestCase.assertLength(1, annotations);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_metadata_method() {
     Source source = addSource(EngineTestCase.createSource(["const A = null;", "class C {", "  @A void m() {}", "}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     MethodElement method = classes[0].methods[0];
     List<ElementAnnotation> annotations = method.metadata;
     EngineTestCase.assertLength(1, annotations);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_method_fromMixin() {
     Source source = addSource(EngineTestCase.createSource([
         "class B {",
         "  bar() => 1;",
         "}",
         "class A {",
         "  foo() => 2;",
         "}",
         "",
         "class C extends B with A {",
         "  bar() => super.bar();",
         "  foo() => super.foo();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_method_fromSuperclassMixin() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void m1() {}",
         "}",
         "class B extends Object with A {",
         "}",
         "class C extends B {",
         "}",
         "f(C c) {",
         "  c.m1();",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_methodCascades() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void m1() {}",
         "  void m2() {}",
         "  void m() {",
         "    A a = new A();",
         "    a..m1()",
         "     ..m2();",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_methodCascades_withSetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  String name;",
         "  void m1() {}",
         "  void m2() {}",
         "  void m() {",
         "    A a = new A();",
         "    a..m1()",
         "     ..name = 'name'",
         "     ..m2();",
         "  }",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_resolveAgainstNull() {
     Source source = addSource(EngineTestCase.createSource(["f(var p) {", "  return null == p;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_setter_inherited() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get x => 0;",
         "  set x(int p) {}",
         "}",
         "class B extends A {",
         "  int get x => super.x == null ? 0 : super.x;",
         "  int f() => x = 1;",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
   void test_setter_static() {
     Source source = addSource(EngineTestCase.createSource(["set s(x) {", "}", "", "main() {", "  s = 123;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertNoErrors(source);
     verify([source]);
   }
 
   /**
    * Resolve the given source and verify that the arguments in a specific method invocation were
    * correctly resolved.
    *
    * The source is expected to be source for a compilation unit, the first declaration is expected
    * to be a class, the first member of which is expected to be a method with a block body, and the
    * first statement in the body is expected to be an expression statement whose expression is a
@@ skipping 216 matching lines @@
         runJUnitTest(__test, __test.test_setter_inherited);
       });
       _ut.test('test_setter_static', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_setter_static);
       });
     });
   }
 }
 main() {
-//  ElementResolverTest.dartSuite();
-//  InheritanceManagerTest.dartSuite();
-//  LibraryElementBuilderTest.dartSuite();
-//  LibraryTest.dartSuite();
-//  StaticTypeAnalyzerTest.dartSuite();
-//  TypeOverrideManagerTest.dartSuite();
-//  TypeProviderImplTest.dartSuite();
-//  TypeResolverVisitorTest.dartSuite();
-//  EnclosedScopeTest.dartSuite();
-//  LibraryImportScopeTest.dartSuite();
-//  LibraryScopeTest.dartSuite();
-//  ScopeTest.dartSuite();
-//  CompileTimeErrorCodeTest.dartSuite();
-//  ErrorResolverTest.dartSuite();
-//  HintCodeTest.dartSuite();
-//  NonHintCodeTest.dartSuite();
-//  NonErrorResolverTest.dartSuite();
-//  SimpleResolverTest.dartSuite();
-//  StaticTypeWarningCodeTest.dartSuite();
-//  StaticWarningCodeTest.dartSuite();
-//  StrictModeTest.dartSuite();
-//  TypePropagationTest.dartSuite();
+  ElementResolverTest.dartSuite();
+  InheritanceManagerTest.dartSuite();
+  LibraryElementBuilderTest.dartSuite();
+  LibraryTest.dartSuite();
+  StaticTypeAnalyzerTest.dartSuite();
+  TypeOverrideManagerTest.dartSuite();
+  TypeProviderImplTest.dartSuite();
+  TypeResolverVisitorTest.dartSuite();
+  EnclosedScopeTest.dartSuite();
+  LibraryImportScopeTest.dartSuite();
+  LibraryScopeTest.dartSuite();
+  ScopeTest.dartSuite();
+  CompileTimeErrorCodeTest.dartSuite();
+  ErrorResolverTest.dartSuite();
+  HintCodeTest.dartSuite();
+  NonHintCodeTest.dartSuite();
+  NonErrorResolverTest.dartSuite();
+  SimpleResolverTest.dartSuite();
+  StaticTypeWarningCodeTest.dartSuite();
+  StaticWarningCodeTest.dartSuite();
+  StrictModeTest.dartSuite();
+  TypePropagationTest.dartSuite();
 }